Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Uitvoeren en het resultaat retourneren

Les 6 van 14 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. De stap waar u volledige controle over heeft
  2. Voer de functie uit aan de clientzijde
  3. Bouw het tool-bericht op
  4. Stuur het resultaat en ontvang het definitieve antwoord
  5. De volledige stroom in één blok
  6. Berichtstructuur bij elke stap
  7. Let op het content-formaat
  8. Belangrijkste punten

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
}
VeldRol
role"tool"—identificeert het bericht als een functieresultaat
nameDe naam van de uitgevoerde functie
contentHet resultaat als een JSON-string
tool_call_idDe 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 bijbehorende tool_call_id
  • De content van 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