Mehrstufige Gespräche
Auf dieser Seite
Über das hinaus, was einzelne Aufrufe bieten
In einer echten Anwendung stellen Nutzer keine einzelne Frage und verschwinden dann. Sie verknüpfen Anfragen, kehren zu früheren Themen zurück und geben Hinweise wie „was ist mit diesem hier?”, die der Satz allein nicht auflösen kann. Funktionsaufrufe müssen innerhalb dieses Kontexts mehrstufiger Gespräche funktionieren, in dem das Modell Funktionen in jedem Schritt des Dialogs aufrufen kann, ohne den Überblick über das Vorgängere zu verlieren.
Das Prinzip: Historie erhalten
Das Wesentliche lässt sich in einem Satz zusammenfassen: Bewahren Sie alle Nachrichten in einer Liste, die mit jedem Austausch wächst. Das Modell verfügt zwischen API-Aufrufen über kein eigenes Gedächtnis; der einzige Kontext, den es hat, ist das, was Sie zurücksenden. Diese vollständige Historie ermöglicht es ihm, implizite Bezüge zu verstehen.
import os
import json
from mistralai.client import Mistral
from functools import partial
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"
# Gesprächshistorie
messages = [
{
"role": "system",
"content": "Sie sind eine Zahlungsverfolgungs-Assistenz. "
"Antworten Sie in knapper englischer Sprache."
}
]
Der vollständige Gesprächsloop
Der folgende Code arbeitet in zwei Phasen. process_tool_calls führt alle vom Modell angeforderten Aufrufe aus und startet das Gespräch mit den Ergebnissen neu; chat behandelt einen vollständigen Turn, von der Eingabe des Nutzers bis zum endgültigen Text.
def process_tool_calls(response, messages, available_functions, tools):
"""Verarbeitet tool_calls und gibt die endgültige Antwort zurück."""
message = response.choices[0].message
messages.append(message)
# Führen Sie jeden tool_call aus
for tool_call in message.tool_calls:
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
if function_name in available_functions:
result = available_functions[function_name](**function_params)
else:
result = json.dumps({"error": f"Unbekannte Funktion {function_name}"})
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# Rufen Sie das Modell erneut mit den Ergebnissen auf
return client.chat.complete(
model=model, messages=messages, tools=tools
)
def chat(user_input: str, messages: list, tools: list,
available_functions: dict) -> str:
"""Behandelt einen vollständigen Gesprächs-Turn."""
messages.append({"role": "user", "content": user_input})
response = client.chat.complete(
model=model, messages=messages, tools=tools
)
message = response.choices[0].message
# Schleifen Sie so lange, wie das Modell Funktionen aufrufen möchte
while message.tool_calls and len(message.tool_calls) > 0:
response = process_tool_calls(
response, messages, available_functions, tools
)
message = response.choices[0].message
# Das Modell ist fertig – es antwortet mit Text
messages.append(message)
return message.content
Die while-Schleife ist der kritische Bestandteil. Nach Erhalt eines Funktionsergebnisses kann das Modell sehr wohl einen weiteren anfordern: Die Schleife läuft so lange fort, wie es tool_calls produziert, und stoppt erst, wenn es schließlich Text zurückgibt. Ein einfaches if würde den ersten Aufruf behandeln und in jedem Fall, in dem zwei Aufrufe benötigt werden, eine leere Antwort zurückgeben.
Beispiel für ein mehrstufiges Gespräch
Sehen wir uns an, wie dieser Loop über vier verknüpfte Turns aussieht.
# Turn 1
reponse = chat("Was ist der Status der Zahlung T1001?",
messages, tools, available_functions)
print(f"Assistent: {reponse}")
# → "Zahlung T1001 Status: bezahlt."
# Turn 2 — Nachfolgefrage
reponse = chat("Wann wurde sie erstellt?",
messages, tools, available_functions)
print(f"Assistent: {reponse}")
# → "Zahlung T1001 wurde am 15. März 2026 erstellt."
# Turn 3 — Neue Transaktion
reponse = chat("Vergleichen Sie mit Zahlung T1003.",
messages, tools, available_functions)
print(f"Assistent: {reponse}")
# → "Zahlung T1003 ist ausstehend, im Gegensatz zu T1001, die bezahlt ist."
# Turn 4 — Frage ohne Funktion
reponse = chat("Danke, das war alles für heute.",
messages, tools, available_functions)
print(f"Assistent: {reponse}")
# → "Gerne! Fragen Sie gerne nach, wenn Sie weitere Fragen haben."
Turn 2 ist derjenige, den man genau unter die Lupe nehmen sollte. „Wann wurde sie erstellt?” enthält keinen Identifier; die Historie ist es, die es dem Modell ermöglicht zu verstehen, dass dies sich immer noch auf T1001 bezieht, und retrieve_payment_date mit dem korrekten Argument aufzurufen. Entfernen Sie die Nachrichten aus Turn 1, und dieser Satz wird unlösbar. In Turn 3 kann das Modell entscheiden, mehrere Funktionen aufzurufen – Status und Datum für T1003 –, um den Vergleich mit bereits für T1001 erzielten Ergebnissen zu erstellen. Turn 4 löst überhaupt keine Aufrufe aus: Das Modell weiß auch, wann es zurückhalten muss.
Verkettung sequentieller Aufrufe
Manche Anfragen erfordern, dass das Modell auf ein Ergebnis wartet, bevor es weiß, was es als Nächstes anfordern soll. Der while-Loop in chat() behandelt diesen Fall ohne eine einzige zusätzliche Zeile Code.
# Der Nutzer fragt nach etwas, das 2 sequentielle Aufrufe erfordert
reponse = chat(
"Zeigen Sie mir den Status und das Datum der Zahlung T1002.",
messages, tools, available_functions
)
# Das Modell kann:
# 1. retrieve_payment_status(T1002) aufrufen
# 2. Das Ergebnis empfangen
# 3. retrieve_payment_date(T1002) aufrufen
# 4. Das Ergebnis empfangen
# 5. Die endgültige Antwort mit beiden Informationen formulieren
Betrachtet aus der Perspektive der Nachrichtenhistorie sieht der sequentielle Fluss so aus:
user → assistant(tool_call_1) → tool(result_1) → assistant(tool_call_2) → tool(result_2) → assistant(response)
Zählen Sie die Assistenten-Turns: drei, was bedeutet, dass drei Anfragen der API in Rechnung gestellt werden. Das ist der Preis für die sequentielle Ausführung und der Grund, warum der nächste Lektion sich auf parallele Aufrufe konzentriert.
Größe der Historie verwalten
In der Produktion wird ein langanhaltendes Gespräch teuer: Jeder Turn sendet die gesamte Menge an vorherigen Nachrichten zurück, und die Token-Rechnung wächst quadratisch. Eine einfache Strategie besteht darin, nur die Systemnachricht und die jüngsten Austausche zu behalten.
def trim_messages(messages: list, max_messages: int = 20) -> list:
"""Behält die Systemnachricht und die letzten N Nachrichten bei."""
system_messages = [m for m in messages if hasattr(m, "role")
and m.get("role") == "system"
or (isinstance(m, dict) and m.get("role") == "system")]
non_system = [m for m in messages if m not in system_messages]
if len(non_system) > max_messages:
non_system = non_system[-max_messages:]
return system_messages + non_system
Eine Vorsicht vor dem Anbinden dieser Funktion: Schneiden Sie niemals einen tool_call ab, ohne seine entsprechende tool-Nachricht. Wenn die Trunkierung zwischen den beiden landet, empfängt die API eine unbeantwortete Aufrufanfrage und lehnt die Abfrage ab. Passen Sie den Schneidpunkt an, um vollständige Paare zu bewahren, anstatt Nachrichten blind zu zählen.
Kernaussagen
- Bewahren Sie eine vollständige Historie von Nachrichten bei, damit das Modell den Kontext versteht
- Verwenden Sie eine while-Schleife, um sequentielle Funktionsaufrufe zu behandeln
- Das Modell versteht implizite Bezüge („das eine”, „das vorherige”) dank des Kontexts
- Limitieren Sie in der Produktion die Größe der Historie, während Sie tool_call/tool-Paare intakt halten
- Die
chat()-Funktion, die hier gezeigt wird, ist ein wiederverwendbares Muster für jede Funktionsaufruf-Anwendung