Conversatie over meerdere beurten
Op deze pagina
Verder dan enkele aanroepen
In een echte applicatie stelt een gebruiker niet één vraag en verdwijnt vervolgens. Gebruikers koppelen verzoeken aan elkaar, komen terug op eerdere onderwerpen en geven hints zoals “hoe zit het met deze?”, die de zin op zich niet kan oplossen. Function calling moet werken binnen deze context van een conversatie over meerdere beurten, waarbij het model bij elke stap van de dialoog functies kan aanroepen zonder ooit uit het oog te verliezen wat eraan voorafging.
Het principe: geschiedenis behouden
Het komt neer op één zin: bewaar alle berichten in een lijst die bij elke uitwisseling groeit. Het model heeft geen eigen geheugen tussen API-aanroepen; de enige context die het heeft, is wat u terugstuurt. Deze volledige geschiedenis stelt het model in staat om impliciete verwijzingen te begrijpen.
import os
import json
from mistralai.client import Mistral
from functools import partial
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"
# Conversatiegeschiedenis
messages = [
{
"role": "system",
"content": "You are a payment tracking assistant. "
"Respond in concise English."
}
]
Volledige conversatielus
De onderstaande code werkt in twee fasen. process_tool_calls voert alle door het model gevraagde aanroepen uit en start de conversatie opnieuw met de resultaten; chat behandelt een volledige beurt, van de invoer van de gebruiker tot de uiteindelijke tekst.
def process_tool_calls(response, messages, available_functions, tools):
"""Verwerkt tool_calls en retourneert het definitieve antwoord."""
message = response.choices[0].message
messages.append(message)
# Voer elke tool_call uit
for tool_call in message.tool_calls:
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
if function_name in available_functions:
result = available_functions[function_name](**function_params)
else:
result = json.dumps({"error": f"Unknown function {function_name}"})
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# Roep het model opnieuw aan met de resultaten
return client.chat.complete(
model=model, messages=messages, tools=tools
)
def chat(user_input: str, messages: list, tools: list,
available_functions: dict) -> str:
"""Behandelt een volledige conversatiebeurt."""
messages.append({"role": "user", "content": user_input})
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
message = response.choices[0].message
# Blijf doorgaan zolang het model functies wil aanroepen
while message.tool_calls and len(message.tool_calls) > 0:
response = process_tool_calls(
response, messages, available_functions, tools
)
message = response.choices[0].message
# Het model is klaar: het antwoordt met tekst
messages.append(message)
return message.content
De while-lus is het cruciale onderdeel. Na ontvangst van een functieresultaat kan het model best nog een ander verzoek doen: de lus gaat door zolang er tool_calls worden geproduceerd en stopt pas wanneer er uiteindelijk tekst wordt teruggegeven. Een simpele if zou alleen de eerste aanroep afhandelen en vervolgens een leeg antwoord retourneren in elk geval waar twee aanroepen nodig waren.
Voorbeeld van een conversatie over meerdere beurten
Laten we bekijken hoe deze lus eruitziet over vier gekoppelde beurten.
# Beurt 1
reponse = chat("What is the status of payment T1001?",
messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 status: paid."
# Beurt 2 — vervolgvraag
reponse = chat("When was it made?",
messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 was made on March 15, 2026."
# Beurt 3 — nieuwe transactie
reponse = chat("Compare with payment T1003.",
messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1003 is pending, unlike T1001 which is paid."
# Beurt 4 — vraag zonder functie
reponse = chat("Thanks, that's all for today.",
messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "You're welcome! Feel free to ask if you have other questions."
Beurt 2 is degene die u nauwkeurig moet bekijken. “When was it made?” bevat geen identificatiecode; de geschiedenis is wat het model in staat stelt te begrijpen dat dit nog steeds verwijst naar T1001 en om retrieve_payment_date aan te roepen met het juiste argument. Verwijder de berichten van Beurt 1 en deze zin wordt onoplosbaar. In Beurt 3 kan het model beslissen meerdere functies aan te roepen—status en datum voor T1003—om de vergelijking op te bouwen met resultaten die al voor T1001 zijn verkregen. Beurt 4 activeert helemaal geen aanroepen: het model weet ook wanneer het zich moet inhouden.
Sequentiële aanroepen ketenen
Sommige verzoeken vereisen dat het model wacht op één resultaat voordat het weet wat het vervolgens moet vragen. De while-lus in chat() behandelt dit geval zonder ook maar één extra regel code.
# Gebruiker vraagt om iets waarvoor 2 sequentiële aanroepen nodig zijn
reponse = chat(
"Show me the status and date of payment T1002.",
messages, tools, available_functions
)
# Het model kan:
# 1. retrieve_payment_status(T1002) aanroepen
# 2. Het resultaat ontvangen
# 3. retrieve_payment_date(T1002) aanroepen
# 4. Het resultaat ontvangen
# 5. Het definitieve antwoord formuleren met beide informatiefragmenten
Vanuit het perspectief van de berichtengeschiedenis ziet de sequentiële stroom er als volgt uit:
user → assistant(tool_call_1) → tool(result_1) → assistant(tool_call_2) → tool(result_2) → assistant(response)
Tel de assistant-beurten mee: drie, wat betekent dat drie verzoeken aan de API worden gefactureerd. Dat is de kostprijs van sequentiële uitvoering, en de reden waarom de volgende les zich richt op parallelle aanroepen.
Geschiedenisgrootte beheren
In productie wordt een langdurige conversatie duur: elke beurt stuurt de volledige set eerdere berichten terug, en de tokenrekening groeit kwadratisch. Een eenvoudige strategie is om alleen het systeembericht en de meest recente uitwisselingen te bewaren.
def trim_messages(messages: list, max_messages: int = 20) -> list:
"""Behoudt het systeembericht en de laatste N berichten."""
system_messages = [m for m in messages if hasattr(m, "role")
and m.get("role") == "system"
or (isinstance(m, dict) and m.get("role") == "system")]
non_system = [m for m in messages if m not in system_messages]
if len(non_system) > max_messages:
non_system = non_system[-max_messages:]
return system_messages + non_system
Eén voorzorgsmaatregel voordat u deze functie implementeert: knip nooit een tool_call af zonder het bijbehorende tool-bericht. Als de afkapping tussen de twee valt, ontvangt de API een onbeantwoord aanroepverzoek en wijst het de query af. Pas het afkappunt aan om complete paren te behouden in plaats van blindelings berichten te tellen.
Belangrijkste punten
- Onderhoud een volledige geschiedenis van berichten zodat het model de context begrijpt
- Gebruik een while-lus om sequentiële functieaanroepen af te handelen
- Het model begrijpt impliciete verwijzingen (“die”, “de vorige”) dankzij de context
- Beperk in productie de grootte van de geschiedenis terwijl u tool_call/tool-paren intact houdt
- De hier getoonde
chat()-functie is een herbruikbaar patroon voor elke applicatie met function calling