Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Mehrstufige Gespräche

Lektion 7 von 14 Aktualisiert am 2. November 2026 Entwickler
Auf dieser Seite
  1. Über das hinaus, was einzelne Aufrufe bieten
  2. Das Prinzip: Historie erhalten
  3. Der vollständige Gesprächsloop
  4. Beispiel für ein mehrstufiges Gespräch
  5. Verkettung sequentieller Aufrufe
  6. Größe der Historie verwalten
  7. Kernaussagen

Ü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