Samtaler over flere runder i Python
På denne side
Hukommelse, der ikke rigtig er hukommelse
I modsætning til en søgemaskine følger en sprogmodel tråden i en samtale: Den tager højde for, hvad der er blevet sagt tidligere, og bygger sine svar op omkring denne akkumulerede kontekst. Dette kaldes en samtale over flere runder (multi-turn), og det er netop dette, der gør det muligt at stille ufuldstændige spørgsmål som „og med argumenter?”.
Teknisk set husker modellen dog ingenting. Ingen tilstand gemmes på serveren mellem kald. Ved hver anmodning skal du sende hele historikken igen, som modellen læser fra start til slut, før den svarer. Denne mekanisme forklarer to ting, som vi vender tilbage til senere: Du har det fulde ansvar for hukommelseshåndtering, og hver runde i samtalen koster mere end den foregående.
De tre roller, der strukturerer historikken
Hver besked i historikken har en rolle, der fortæller modellen, hvem der taler. Rollen system definerer den overordnede adfærd: Den placeres først og påvirker alle efterfølgende svar.
{"role": "system", "content": "You are an expert assistant in French cuisine. Always respond in French using precise culinary terms."}
Rollen user indeholder brugerens beskeder – altså spørgsmålet eller instruktionen, der sendes:
{"role": "user", "content": "How do I make perfect puff pastry?"}
Endelig indeholder rollen assistant modellens tidligere svar. Det er disse beskeder, du genindsætter i historikken for at bevare sammenhængen. At glemme dem svarer til at slette samtalens hukommelse ved hver eneste runde.
{"role": "assistant", "content": "To make perfect puff pastry, start by..."}
En komplet samtale, runde for runde
Koden nedenfor anvender dette princip: En funktion, der tilføjer spørgsmålet til historikken, kalder modellen og gemmer derefter svaret på det rette sted, før det returneres.
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
historique = [
{
"role": "system",
"content": "You are a teaching assistant specialized in Python programming. Respond concisely and include code examples."
}
]
def poser_question(question: str) -> str:
"""Sends a question and updates the history."""
historique.append({"role": "user", "content": question})
response = client.chat.complete(
model="mistral-small-latest",
messages=historique,
)
reponse_texte = response.choices[0].message.content
historique.append({"role": "assistant", "content": reponse_texte})
return reponse_texte
# Turn 1
print("Q: What is a decorator in Python?")
r1 = poser_question("What is a decorator in Python?")
print(f"R: {r1}\n")
# Turn 2 — the model knows the context
print("Q: Can you show me a concrete example?")
r2 = poser_question("Can you show me a concrete example?")
print(f"R: {r2}\n")
# Turn 3 — implicit reference to previous turns
print("Q: How do I use it with arguments?")
r3 = poser_question("How do I use it with arguments?")
print(f"R: {r3}\n")
Ved den tredje runde nævner spørgsmålet aldrig ordet „decorator” igen. Modellen forstår alligevel, at „bruge det” refererer til dette begreb, fordi den genlæser hele udvekslingen. Fjern linjen, der tilføjer svaret til historikken, og kør koden igen: Modellen vil spørge, hvad du taler om. Dette er det hurtigste bevis på, at kontinuiteten ikke kommer fra modellen, men fra din kode.
At forhindre, at historikken bliver uoverkommeligt dyr
Hver model har et begrænset kontekstvindue, målt i tokens. Efterhånden som historikken vokser, bliver hver anmodning dyrere, fordi alt bliver sendt igen. En samtale på tredive runder fakturerer effektivt begyndelsen tredive gange.
Den enkleste løsning er at afkorte historikken ved at beholde systembeskeden og de sidste N udvekslinger:
MAX_MESSAGES = 20
def ajouter_message(historique, role, content):
historique.append({"role": role, "content": content})
# Keep the system message + the last N messages
if len(historique) > MAX_MESSAGES + 1: # +1 for the system message
system_msg = historique[0]
historique = [system_msg] + historique[-(MAX_MESSAGES):]
return historique
Denne tilgang er billig, men brutal: Det, brugeren specificerede i anden runde, forsvinder for altid. Når samtalen er lang, og den ældre kontekst betyder noget – f.eks. ved et interview om kravspecifikationer – bør du i stedet opsummere den frem for at smide den væk:
def resumer_historique(client, historique):
"""Summarizes old messages to free up context."""
texte_complet = "\n".join(
f"{m['role']}: {m['content']}"
for m in historique[1:-4] # Exclude system and the last 4 messages
)
resume = client.chat.complete(
model="mistral-small-latest",
messages=[
{"role": "user", "content": f"Summarize this conversation in 3-4 sentences:\n{texte_complet}"}
]
)
return [
historique[0], # System message
{"role": "assistant", "content": f"[Conversation Summary] {resume.choices[0].message.content}"},
] + historique[-4:] # The last 4 messages
Idéen er at komprimere den fjerne fortid til nogle få sætninger, mens de sidste fire beskeder holdes intakte, da de bærer den umiddelbare kontekst. Resuméet bruger ét ekstra kald, men det betaler sig mange gange over i de efterfølgende runder.
Udarbejdelse af systembeskeden
Systembeskeden er det mest kraftfulde og underudnyttede værktøj i denne lektion. Mange nøjes med en generisk „Du er en hjælpsom assistent”, som ikke tilføjer noget værdi. En god systembesked angiver verificerbare begrænsninger:
system_prompt = """You are a Corsen AI technical assistant.
Rules:
- Respond in French with a professional tone
- Provide code examples when relevant
- If you are unsure, say so rather than making things up
- Limit your responses to 200 words unless asked otherwise
Context: The user is working on a Python 3.12 project with FastAPI."""
Hver linje her giver en målbar effekt: Længdebegrænsningen holder omkostningerne nede, opfordringen til at indrømme usikkerhed reducerer hallucinationer, og omtalen af tech-stacken undgår generiske svar, der er irrelevant for emnet. Kort, præcist og entydigt – det er alt, hvad der kræves.
Vigtige pointer
- Den komplette historikken sendes igen ved hver anmodning – modellen „husker” ingenting
- Tre roller (
system,user,assistant) strukturerer samtalen - Beskeden
systemdefinerer den overordnede adfærd – placer den altid først - Håndtér kontekststørrelsen ved at afkorte eller opsummere gamle beskeder
- Jo længere historikken er, desto flere tokens koster hver anmodning