Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Ausführen und Ergebnis zurückgeben

Lektion 6 von 14 Aktualisiert am 2. November 2026 Entwickler
Auf dieser Seite
  1. Der Schritt, den Sie vollständig kontrollieren
  2. Funktion auf der Client-Seite ausführen
  3. Das Tool-Nachricht bauen
  4. Ergebnis senden und finale Antwort erhalten
  5. Der vollständige Ablauf in einem Block
  6. Nachrichtenstruktur in jedem Schritt
  7. Auf das Inhaltsformat achten
  8. Kernaussagen

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
}
FeldRolle
role"tool" – identifiziert die Nachricht als Funktionsergebnis
nameDer Name der ausgeführten Funktion
contentDas Ergebnis als JSON-String
tool_call_idDie 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 passenden tool_call_id zurückgesendet
  • Der content der 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