Udfør og returnér resultatet
På denne side
Det trin, du har fuld kontrol over
Du har modtaget et tool_call fra modellen. Det fortæller dig, hvilken funktion der skal kaldes, og med hvilke argumenter – ikke mere. Nu overtager din kode: den udfører funktionen, henter resultatet og sender det tilbage til modellen som en besked med rollen tool. Denne lektion dækker hele denne rundtur. Det er det eneste tidspunkt i cyklussen, hvor du træffer alle beslutningerne.
Udfør funktionen på klientsiden
Lad os genbesøge dispatch-ordbogen fra lektion 4 og forbinde den med modellens svar.
import json
from functools import partial
# Funktioner allerede defineret
available_functions = {
"retrieve_payment_status": partial(retrieve_payment_status, df),
"retrieve_payment_date": partial(retrieve_payment_date, df),
}
# Modellen returnerede et tool_call
tool_call = response.choices[0].message.tool_calls[0]
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Udfør funktionen
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"})
To mekanismer er på spil her. Den første er **function_params, som udpakker ordbogen fra JSON’en til navngivne argumenter: hvis modellen genererede {"transaction_id": "T1001"}, er kaldet præcis ækvivalent med retrieve_payment_status(transaction_id="T1001"). Den anden er else-blokken. Den er mindre prangende, men essentiel. En model kan hallucinere et funktionsnavn, der ikke findes i dit dispatch; uden denne tjek vil din app rejse en KeyError, og samtalen stopper brat. Med den bliver fejlen til data, som modellen kan håndtere gnidningsfrit.
Byg tool-beskeden
Resultatet skal sendes tilbage til modellen i et specifikt format – en besked med rollen "tool":
tool_message = {
"role": "tool",
"name": function_name,
"content": result, # Skal være en streng
"tool_call_id": tool_call.id
}
| Felt | Rolle |
|---|---|
role | "tool" – identificerer beskeden som et funktionsresultat |
name | Navnet på den udførte funktion |
content | Resultatet som en JSON-streng |
tool_call_id | ID’et på det oprindelige tool_call – lader modellen matche resultatet med det rigtige kald |
Send resultatet og få det endelige svar
Modellen har ingen hukommelse fra det ene kald til det næste: den husker ikke, at den bad dig om noget. Derfor skal du genopbygge hele samtalen for den, inklusive dens egen anmodning om et tool-kald, før du præsenterer resultatet.
# 1. Tilføj assistant-beskeden (med tool_call)
messages.append(response.choices[0].message)
# 2. Tilføj funktionsresultatet
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# 3. Kald modellen igen med den fulde kontekst
final_response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
# 4. Vis det endelige svar
print(final_response.choices[0].message.content)
# → "Payment T1001 status is: paid."
Rækkefølgen af de to append-operationer er ikke-forhandlingsbar: assistant-beskeden, der bærer tool_call, skal komme før tool-beskeden, der svarer på den. Hvis du bytter om på dem, skaber du en inkonsistent historik, som API’et afviser.
Hele flowet i én blok
Her er hele processen, fra brugerens spørgsmål til det endelige svar:
import os
import json
from mistralai.client import Mistral
from functools import partial
# Konfiguration
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"
# Funktioner og tools (defineret tidligere)
available_functions = {
"retrieve_payment_status": partial(retrieve_payment_status, df),
"retrieve_payment_date": partial(retrieve_payment_date, df),
}
# Trin 1-2: Brugerspørgsmål + API-kald
messages = [
{"role": "user", "content": "What is the status of payment T1001?"}
]
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
# Trin 3-4: Udtræk tool_call og udfør
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)
# Udførelse på klientsiden
result = available_functions[function_name](**function_params)
# Trin 5: Send resultatet tilbage til modellen
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)
Beskedstruktur ved hvert trin
Det er værd at inspicere messages-listen, når cyklussen er afsluttet, for det er den bedste måde at fejlfinde funktionskald, der opfører sig mærkeligt. Den indeholder fire beskeder.
# Besked 1: Brugerens spørgsmål
{"role": "user", "content": "What is the status of payment T1001?"}
# Besked 2: Modellens svar med tool_call
{"role": "assistant", "tool_calls": [{"id": "call_abc123", ...}]}
# Besked 3: Funktionsresultatet
{"role": "tool", "name": "retrieve_payment_status",
"content": '{"status": "paid"}', "tool_call_id": "call_abc123"}
# Besked 4 (implicit): Modellens endelige svar
# → "Payment T1001 status is: paid."
Følg ID’et call_abc123: det fødes i besked 2 og dukker op igen i besked 3. Den tråd forbinder anmodningen med dens svar. Denne struktur er fundamentalmønsteret for funktionskald; enhver variation, du støder på senere, hvad enten det er multi-turn eller parallelt, gentager eller duplicerer blot dette.
Pas på indholdsformatet
Én fejl optræder oftere end alle andre, og det handler om typen på feltet content: det skal altid være en streng.
# Korrekt – JSON-streng
{"content": '{"status": "paid"}'}
# Korrekt – almindelig tekst
{"content": "The status is paid"}
# Forkert – Python-ordbog (vil forårsage en fejl)
{"content": {"status": "paid"}}
Forskellen mellem det første og det tredje eksempel ligger i citationstegnene, der omslutter JSON’en. Hvis din funktion returnerer en ordbog, skal du konvertere den med json.dumps(), før du sender den – det er netop derfor, funktionerne i lektion 4 alle sluttede med et json.dumps().
Vigtige pointer
- Funktionsudførelse sker på klientsiden, i din kode – aldrig af modellen
- Resultatet sendes tilbage i en besked med rollen
"tool"og det matchendetool_call_id contenti tool-beskeden skal være en streng (en JSON-streng)- Efter at have sendt resultatet kalder du
chat.complete()igen, så modellen kan formulere det endelige svar - Verificér altid, at den anmodede funktion findes i din dispatch-ordbog