0%

Gesprekken en instructies · oefening

Houd een gesprek gaande

In les 1 schreef je een geschiedenis met de hand. Een echt gesprek bouwt zijn geschiedenis gaandeweg op: stuur een vraag met alles wat tot nu toe gezegd is, lees het antwoord, voeg beide aan de geschiedenis toe en herhaal. Deze les bouwt de twee functies die dat doen.

Eén beurt tegelijk

Een beurt is één vraag en het antwoord daarop: een user-bericht gevolgd door een assistant-bericht. Een gesprek dat begint met het studiesysteembericht groeit zo:

[system]
[system, user, assistant]
[system, user, assistant, user, assistant]

Twee functies dekken dat af:

  • next_request(history, question) bouwt de body van het request voor een nieuwe vraag: {"model": MODEL, "messages": ...}, waarbij de berichten de hele geschiedenis zijn, gevolgd door de vraag als user-bericht.

  • add_turn(history, question, answer) geeft de geschiedenis terug met de afgeronde beurt erbij: de vraag als user-bericht, daarna het antwoord als assistant-bericht.

De demonstratie in conversation.py gebruikt ze in een lus:

history = [system_message()]
for question in ["My name is Sam.", "What is my name?"]:
    response = send_body(next_request(history, question))
    history = add_turn(history, question, answer_text(response))

Let op de toewijzing in de laatste regel. add_turn verandert history niet. Hij geeft een nieuwe lijst terug, en de lus laat history daarnaar verwijzen.

Laat de lijst van de aanroeper met rust

Beide functies moeten een nieuwe lijst teruggeven en de lijst die ze kregen precies laten zoals die was. Dit is waarom dat ertoe doet. Stel dat next_request de vraag met append aan de lijst van de aanroeper toevoegde. Het request mislukt omdat de dienst plat ligt, en send_body werpt een exception op. De geschiedenis van de aanroeper eindigt nu met een vraag die nooit een antwoord kreeg, en het volgende request stuurt die twee keer. Functies die nieuwe lijsten teruggeven, kunnen een geschiedenis niet zo half veranderd achterlaten.

Je hebt twee manieren om een nieuwe lijst te bouwen. + voegt twee lijsten samen tot een nieuwe en verandert geen van beide:

history = [{"role": "system", "content": "Be brief."}]
messages = history + [{"role": "user", "content": "What is a tuple?"}]
print(len(history), len(messages))

Of kopieer eerst de lijst en verander de kopie:

history = [{"role": "system", "content": "Be brief."}]
longer = history.copy()
longer.append({"role": "user", "content": "What is a tuple?"})
longer.append({"role": "assistant", "content": "An ordered collection you cannot change."})
print(len(history), len(longer))

Beide drukken eerst de oorspronkelijke lengte af, omdat de oorspronkelijke lijst nooit is aangeraakt. Gebruik in je functies welke je wilt. append aanroepen op history zelf zou de lijst van de aanroeper veranderen, en dat is precies wat je wilt vermijden.

Gebruik de constante MODEL in de body van next_request, zoals ask_model doet in llm_basics.py. Houd de vraag en het antwoord precies zoals ze gegeven zijn.

Voer het gesprek uit

Voer python conversation.py uit. De lus stuurt My name is Sam., voegt de beurt toe en stuurt daarna What is my name? met de geschiedenis ervoor:

A conversation that grows by whole turns:
  You: My name is Sam.
  Model: Nice to meet you, Sam.
  You: What is my name?
  Model: Your name is Sam.
  The history now holds 5 messages.
Trimming a long history:
Before trimming:
[pl-scripted echo] No scripted reply matches this prompt, so here is what I received.
Messages: 12
System message: You are a patient Python tutor. Answer only questions about the course notes and Python. If a question is about something else, say so and suggest a Python topic instead.
Last user message: How many messages did you get?
After trimming:
Run stopped at the next function to build: trim_history is built in Lesson 5.

Het model beantwoordde de tweede vraag vanuit de geschiedenis die jouw functies bouwden: het systeembericht en twee volledige beurten, vijf berichten. Daarna bouwt de demonstratie een langer gesprek van vijf verzonnen beurten en stuurt nog één vraag. Er kwamen twaalf berichten aan. Elke nieuwe beurt voegt er twee toe, en de volgende twee lessen gaan over waar dat toe leidt.

history bevat drie berichten. Je voert longer = add_turn(history, "Why?", "Because.") uit. Hoeveel berichten bevat elke lijst daarna?

Opdracht

Vervang in conversation.py de onafgemaakte bodies van add_turn en next_request.

  • add_turn(history, question, answer) geeft een nieuwe lijst terug: elk bericht in history, daarna {"role": "user", "content": question}, daarna {"role": "assistant", "content": answer}.

  • next_request(history, question) geeft {"model": MODEL, "messages": messages} terug, waarbij messages een nieuwe lijst is: elk bericht in history, daarna {"role": "user", "content": question}.

Geen van beide functies mag de lijst die ze kreeg veranderen. Houd de vraag en het antwoord precies zoals gegeven. Voer python conversation.py uit om het gesprek te zien groeien, en controleer daarna je werk.