Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Udfør og returnér resultatet

Lektion 6 af 14 Opdateret 2. november 2026 Udvikler
På denne side
  1. Det trin, du har fuld kontrol over
  2. Udfør funktionen på klientsiden
  3. Byg tool-beskeden
  4. Send resultatet og få det endelige svar
  5. Hele flowet i én blok
  6. Beskedstruktur ved hvert trin
  7. Pas på indholdsformatet
  8. Vigtige pointer

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
}
FeltRolle
role"tool" – identificerer beskeden som et funktionsresultat
nameNavnet på den udførte funktion
contentResultatet som en JSON-streng
tool_call_idID’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 matchende tool_call_id
  • content i 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