Uitvoeren en het resultaat retourneren
Op deze pagina
De stap waar u volledige controle over heeft
U heeft een tool_call van het model ontvangen. Dit vertelt u welke functie u moet aanroepen en met welke argumenten—niets meer. Nu neemt uw code het over: deze voert de functie uit, haalt het resultaat op en stuurt dit terug naar het model als een bericht met de rol tool. Deze les behandelt deze volledige cyclus. Dit is het enige moment in de lus waarin u alle beslissingen neemt.
Voer de functie uit aan de clientzijde
Laten we het dispatch-woordenboek uit Les 4 opnieuw bekijken en dit koppelen aan het antwoord van het model.
import json
from functools import partial
# Functies reeds gedefinieerd
available_functions = {
"retrieve_payment_status": partial(retrieve_payment_status, df),
"retrieve_payment_date": partial(retrieve_payment_date, df),
}
# Het model heeft een tool_call geretourneerd
tool_call = response.choices[0].message.tool_calls[0]
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Voer de functie uit
if function_name in available_functions:
result = available_functions[function_name](**function_params)
print(f"Result: {result}")
# → '{"status": "paid"}'
else:
result = json.dumps({"error": f"Function {function_name} not available"})
Hier zijn twee mechanismen aan het werk. Het eerste is **function_params, dat het woordenboek uit de JSON uitpakt tot benoemde argumenten: als het model {"transaction_id": "T1001"} heeft gegenereerd, is de aanroep exact equivalent aan retrieve_payment_status(transaction_id="T1001"). Het tweede mechanisme is het else-blok. Dit is minder opvallend, maar essentieel. Een model kan een functienaam hallucineren die niet bestaat in uw dispatch; zonder deze controle raise-t uw app een KeyError en stopt het gesprek abrupt. Met deze controle wordt de fout tot data die het model op een gecontroleerde manier kan afhandelen.
Bouw het tool-bericht op
Het resultaat moet in een specifiek formaat terug naar het model: een bericht met de rol "tool":
tool_message = {
"role": "tool",
"name": function_name,
"content": result, # Moet een string zijn
"tool_call_id": tool_call.id
}
| Veld | Rol |
|---|---|
role | "tool"—identificeert het bericht als een functieresultaat |
name | De naam van de uitgevoerde functie |
content | Het resultaat als een JSON-string |
tool_call_id | De ID van de oorspronkelijke tool_call—hiermee kan het model het resultaat koppelen aan de juiste aanroep |
Stuur het resultaat en ontvang het definitieve antwoord
Het model heeft geen geheugen van de ene aanroep naar de andere: het herinnert zich niet dat het u ergens om heeft gevraagd. U moet dus het volledige gesprek voor het model herbouwen, inclusief zijn eigen verzoek om een tool-aanroep, voordat u het resultaat presenteert.
# 1. Voeg het assistant-bericht toe (met de tool_call)
messages.append(response.choices[0].message)
# 2. Voeg het functieresultaat toe
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# 3. Roep het model opnieuw aan met de volledige context
final_response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
# 4. Toon het definitieve antwoord
print(final_response.choices[0].message.content)
# → "Payment T1001 status is: paid."
De volgorde van de twee append-bewerkingen is niet onderhandelbaar: het assistant-bericht dat de tool_call bevat, moet komen vóór het tool-bericht dat erop antwoordt. Als u deze omwisselt, ontstaat er een inconsistente geschiedenis die de API afwijst.
De volledige stroom in één blok
Hier is het volledige proces, van de vraag van de gebruiker tot het definitieve antwoord:
import os
import json
from mistralai.client import Mistral
from functools import partial
# Configuratie
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"
# Functies en tools (eerder gedefinieerd)
available_functions = {
"retrieve_payment_status": partial(retrieve_payment_status, df),
"retrieve_payment_date": partial(retrieve_payment_date, df),
}
# Stap 1-2: Vraag van de gebruiker + API-aanroep
messages = [
{"role": "user", "content": "What is the status of payment T1001?"}
]
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
# Stap 3-4: Extraheer de tool_call en voer uit
message = response.choices[0].message
if message.tool_calls:
tool_call = message.tool_calls[0]
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Uitvoering aan de clientzijde
result = available_functions[function_name](**function_params)
# Stap 5: Stuur het resultaat terug naar het model
messages.append(message)
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
final_response = client.chat.complete(
model=model, messages=messages, tools=tools
)
print(final_response.choices[0].message.content)
else:
print(message.content)
Berichtstructuur bij elke stap
Het is de moeite waard om de messages-lijst te inspecteren zodra de cyclus is voltooid, omdat dit de beste manier is om fouten in function calling op te sporen. Deze bevat vier berichten.
# Bericht 1: De vraag van de gebruiker
{"role": "user", "content": "What is the status of payment T1001?"}
# Bericht 2: Het antwoord van het model met de tool_call
{"role": "assistant", "tool_calls": [{"id": "call_abc123", ...}]}
# Bericht 3: Het functieresultaat
{"role": "tool", "name": "retrieve_payment_status",
"content": '{"status": "paid"}', "tool_call_id": "call_abc123"}
# Bericht 4 (impliciet): Het definitieve antwoord van het model
# → "Payment T1001 status is: paid."
Volg de ID call_abc123: deze ontstaat in Bericht 2 en verschijnt opnieuw in Bericht 3. Deze draad verbindt het verzoek met zijn antwoord. Deze structuur is het fundamentele patroon van function calling; elke variatie die u later tegenkomt, of het nu multi-turn of parallel is, herhaalt of dupliceert dit patroon slechts.
Let op het content-formaat
Eén fout komt vaker voor dan alle andere samen, en dit komt door het type van het veld content: dit moet altijd een string zijn.
# Correct — JSON-string
{"content": '{"status": "paid"}'}
# Correct — platte tekst
{"content": "The status is paid"}
# Onjuist — Python-woordenboek (veroorzaakt een fout)
{"content": {"status": "paid"}}
Het verschil tussen het eerste en het derde voorbeeld zit in de aanhalingstekens rond de JSON. Als uw functie een woordenboek retourneert, converteer dit dan met json.dumps() voordat u het verstuurt—dat is precies waarom de functies in Les 4 allemaal eindigden met een json.dumps().
Belangrijkste punten
- Functie-uitvoering vindt plaats aan de clientzijde, in uw code—nooit door het model
- Het resultaat wordt teruggestuurd in een bericht met de rol
"tool"en de bijbehorendetool_call_id - De
contentvan het tool-bericht moet een string zijn (een JSON-string) - Na het verzenden van het resultaat roept u
chat.complete()opnieuw aan, zodat het model het definitieve antwoord kan formuleren - Verifieer altijd dat de gevraagde functie bestaat in uw dispatch-woordenboek