Ausführen und Ergebnis zurückgeben
Auf dieser Seite
Der Schritt, den Sie vollständig kontrollieren
Sie haben einen tool_call vom Modell erhalten. Er teilt Ihnen mit, welche Funktion aufgerufen werden soll und mit welchen Argumenten – nichts weiter. Jetzt übernimmt Ihr Code: Er führt die Funktion aus, holt das Ergebnis und sendet es als Nachricht mit der Rolle tool zurück an das Modell. Diese Lektion behandelt diesen gesamten Rundgang. Dies ist der einzige Moment im Zyklus, in dem Sie alle Entscheidungen treffen.
Funktion auf der Client-Seite ausführen
Lassen Sie uns das Dispatch-Dict aus Lektion 4 erneut betrachten und es mit der Antwort des Modells verbinden.
import json
from functools import partial
# Bereits definierte Funktionen
available_functions = {
"retrieve_payment_status": partial(retrieve_payment_status, df),
"retrieve_payment_date": partial(retrieve_payment_date, df),
}
# Das Modell hat einen tool_call zurückgegeben
tool_call = response.choices[0].message.tool_calls[0]
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Funktion ausführen
if function_name in available_functions:
result = available_functions[function_name](**function_params)
print(f"Ergebnis: {result}")
# → '{"status": "paid"}'
else:
result = json.dumps({"error": f"Function {function_name} not available"})
Hier wirken zwei Mechanismen. Der erste ist **function_params, der das Wörterbuch aus dem JSON in benannte Argumente zerlegt: Wenn das Modell {"transaction_id": "T1001"} generiert hat, ist der Aufruf exakt äquivalent zu retrieve_payment_status(transaction_id="T1001"). Der zweite ist der else-Block. Er ist weniger auffällig, aber essenziell. Ein Modell könnte einen Funktionsnamen halluzinieren, der nicht in Ihrem Dispatch existiert; ohne diese Prüfung würde Ihre Anwendung einen KeyError auslösen und die Konversation käme sofort zum Erliegen. Mit dieser Prüfung wird der Fehler zu Daten, die das Modell angemessen verarbeiten kann.
Das Tool-Nachricht bauen
Das Ergebnis muss dem Modell in einem spezifischen Format zurückgegeben werden – eine Nachricht mit der Rolle "tool":
tool_message = {
"role": "tool",
"name": function_name,
"content": result, # Muss ein String sein
"tool_call_id": tool_call.id
}
| Feld | Rolle |
|---|---|
role | "tool" – identifiziert die Nachricht als Funktionsergebnis |
name | Der Name der ausgeführten Funktion |
content | Das Ergebnis als JSON-String |
tool_call_id | Die ID des ursprünglichen tool_call – ermöglicht es dem Modell, das Ergebnis dem richtigen Aufruf zuzuordnen |
Ergebnis senden und finale Antwort erhalten
Das Modell hat kein Gedächtnis von einem Aufruf zum nächsten: Es erinnert sich nicht daran, dass Sie etwas gefragt haben. Daher müssen Sie den gesamten Gesprächsverlauf für das Modell neu aufbauen, einschließlich seiner eigenen Anfrage für einen Tool-Aufruf, bevor Sie das Ergebnis präsentieren.
# 1. Die Assistant-Nachricht (mit dem tool_call) hinzufügen
messages.append(response.choices[0].message)
# 2. Das Funktionsergebnis hinzufügen
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# 3. Das Modell erneut mit dem vollständigen Kontext aufrufen
final_response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
# 4. Die finale Antwort anzeigen
print(final_response.choices[0].message.content)
# → "Payment T1001 status is: paid."
Die Reihenfolge der beiden append-Operationen ist unverhandelbar: Die Assistant-Nachricht, die den tool_call enthält, muss vor der tool-Nachricht stehen, die darauf antwortet. Ein Tausch erzeugt eine inkonsistente Historie, die von der API abgelehnt wird.
Der vollständige Ablauf in einem Block
Hier ist der gesamte Prozess, von der Benutzerfrage bis zur endgültigen Antwort:
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"
# Funktionen und Tools (früher definiert)
available_functions = {
"retrieve_payment_status": partial(retrieve_payment_status, df),
"retrieve_payment_date": partial(retrieve_payment_date, df),
}
# Schritte 1-2: Benutzerfrage + API-Aufruf
messages = [
{"role": "user", "content": "What is the status of payment T1001?"}
]
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
# Schritte 3-4: tool_call extrahieren und ausführen
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)
# Client-seitige Ausführung
result = available_functions[function_name](**function_params)
# Schritt 5: Das Ergebnis zurück an das Modell senden
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)
Nachrichtenstruktur in jedem Schritt
Es lohnt sich, die messages-Liste zu inspizieren, sobald der Zyklus abgeschlossen ist, da dies der beste Weg ist, um fehlerhaftes Funktionsaufrufen zu debuggen. Sie enthält vier Nachrichten.
# Nachricht 1: Die Frage des Benutzers
{"role": "user", "content": "What is the status of payment T1001?"}
# Nachricht 2: Die Antwort des Modells mit dem tool_call
{"role": "assistant", "tool_calls": [{"id": "call_abc123", ...}]}
# Nachricht 3: Das Funktionsergebnis
{"role": "tool", "name": "retrieve_payment_status",
"content": '{"status": "paid"}', "tool_call_id": "call_abc123"}
# Nachricht 4 (implizit): Die finale Antwort des Modells
# → "Payment T1001 status is: paid."
Folgen Sie der ID call_abc123: Sie wird in Nachricht 2 geboren und erscheint erneut in Nachricht 3. Dieser Faden verknüpft die Anfrage mit ihrer Antwort. Diese Struktur ist das fundamentale Muster des Funktionsaufrufs; jede Variation, die Sie später antreffen, sei es mehrstufig oder parallel, wiederholt oder dupliziert lediglich dieses Muster.
Auf das Inhaltsformat achten
Ein Fehler tritt häufiger auf als alle anderen zusammen, und er hängt vom Typ des content-Felds ab: Es muss immer ein String sein.
# Korrekt — JSON-String
{"content": '{"status": "paid"}'}
# Korrekt — reiner Text
{"content": "The status is paid"}
# Falsch — Python-Wörterbuch (führt zu einem Fehler)
{"content": {"status": "paid"}}
Der Unterschied zwischen dem ersten und dem dritten Beispiel liegt in den Anführungszeichen, die das JSON umschließen. Wenn Ihre Funktion ein Wörterbuch zurückgibt, konvertieren Sie es mit json.dumps(), bevor Sie es senden – genau darum endeten alle Funktionen in Lektion 4 mit einem json.dumps().
Kernaussagen
- Die Funktionsexekution findet auf der Client-Seite in Ihrem Code statt – niemals durch das Modell
- Das Ergebnis wird in einer Nachricht mit der Rolle
"tool"und der passendentool_call_idzurückgesendet - Der
contentder Tool-Nachricht muss ein String sein (ein JSON-String) - Nach dem Senden des Ergebnisses rufen Sie
chat.complete()erneut auf, damit das Modell die finale Antwort formulieren kann - Überprüfen Sie stets, ob die angeforderte Funktion in Ihrem Dispatch-Dict existiert