Wird geladen

Mehrfache Konversationen mit Tools

Lektion 2710 Min.
Wird geladen

Beim Erstellen von Anwendungen mit mehreren Tools musst du Szenarien handhaben, in denen Claude möglicherweise mehrere Tools nacheinander aufrufen muss, um eine einzelne Nutzerfrage zu beantworten. Wenn ein Nutzer beispielsweise fragt „Welcher Tag ist in 103 Tagen von heute an?“, muss Claude zunächst das aktuelle Datum abrufen und dann 103 Tage dazu addieren.

Vier Nachrichten zwischen unserem Server und Claude, wobei der vollständige Nachrichtenverlauf der Übersichtlichkeit halber weggelassen wurde, wie unten beschrieben.

Dies erzeugt ein mehrfaches Konversationsmuster, bei dem Claude mehrere Tool-Anfragen stellt, bevor es eine endgültige Antwort liefert. Deine Anwendung muss dies automatisch handhaben.

Das Mehrfach-Tool-Muster

Hier ist, was im Hintergrund passiert, wenn Claude mehrere Tools benötigt:

  1. Nutzer fragt: „Welcher Tag ist in 103 Tagen von heute an?“
  2. Claude antwortet mit einem Tool-Nutzungs-Block, der get_current_datetime anfordert
  3. Dein Server ruft die Funktion auf und gibt das Ergebnis zurück
  4. Claude erkennt, dass es weitere Informationen benötigt, und fordert add_duration_to_datetime an
  5. Dein Server ruft diese Funktion auf und gibt das Ergebnis zurück
  6. Claude hat nun genug Informationen, um die endgültige Antwort zu liefern

Diagramm der oben genannten Schritte als fünf Nachrichten zwischen deinem Server und Claude, unter Verwendung von ToolUse- und ToolResult-Blöcken.

Aufbau einer Konversationsschleife

Um dieses Muster zu handhaben, benötigst du eine Konversationsschleife, die so lange fortgesetzt wird, bis Claude keine Tools mehr anfordert:

python
def run_conversation(messages):
    while True:
        response = chat(messages)

        add_assistant_message(messages, response)

        # Pseudocode
        if response isn't asking for a tool:
            break

        tool_result_blocks = run_tools(response)
        add_user_message(messages, tool_result_blocks)
        
    return messages

Die Schleife im obigen Code: Wenn Claude kein Tool anfordert, haben wir die endgültige Antwort, andernfalls führen wir das Tool aus und wiederholen den Vorgang.

Refactoring von Hilfsfunktionen

Bevor du die Konversationsschleife implementierst, musst du deine Hilfsfunktionen aktualisieren, damit sie mehrere Nachrichtenblöcke korrekt handhaben.

Aktualisieren der Nachrichten-Handler

Deine Funktionen add_user_message und add_assistant_message gehen derzeit davon aus, dass sie immer mit reinem Text arbeiten. Aktualisiere sie so, dass sie vollständige Nachrichtenobjekte handhaben können:

python
from anthropic.types import Message

def add_user_message(messages, message):
    user_message = {
        "role": "user",
        "content": message.content if isinstance(message, Message) else message
    }
    messages.append(user_message)

Dadurch kannst du entweder einen String, eine Liste von Blöcken oder ein vollständiges Nachrichtenobjekt übergeben.

Aktualisieren der Chat-Funktion

Ändere deine Chat-Funktion so, dass sie eine Liste von Tools akzeptiert und die vollständige Nachricht statt nur den Text zurückgibt:

python
def chat(messages, system=None, temperature=1.0, stop_sequences=[], tools=None):
    params = {
        "model": model,
        "max_tokens": 1000,
        "messages": messages,
        "temperature": temperature,
        "stop_sequences": stop_sequences,
    }
    
    if tools:
        params["tools"] = tools
        
    if system:
        params["system"] = system
        
    message = client.messages.create(**params)
    return message

Extrahieren von Text aus Nachrichten

Da die Chat-Funktion jetzt vollständige Nachrichten statt nur Text zurückgibt, füge eine Hilfsfunktion hinzu, um bei Bedarf Text zu extrahieren:

python
def text_from_message(message):
    return "\n".join(
        [block.text for block in message.content if block.type == "text"]
    )

Diese Funktion findet alle Textblöcke in einer Nachricht und fügt sie zusammen, was nützlich ist, wenn du die endgültige Antwort den Nutzern anzeigen musst.

Warum diese Änderungen wichtig sind

Diese Refactoring-Schritte bereiten deinen Code auf die Realität tool-fähiger Konversationen vor:

  • Mehrere Blöcke pro Nachricht – Claudes Antworten können sowohl Text- als auch Tool-Nutzungs-Blöcke enthalten
  • Flexible Nachrichtenverarbeitung – Deine Funktionen können jetzt mit verschiedenen Nachrichtenformaten arbeiten
  • Vollständige Nachrichtenerhaltung – Du behältst alle Informationen, die Claude bereitstellt, nicht nur die Textteile
  • Unterstützung für Tool-Listen – Deine Chat-Funktion kann jetzt mehrere Tools empfangen und verwenden

Mit diesen Grundlagen bist du bereit, die vollständige Konversationsschleife zu implementieren, die mehrere Tool-Aufrufe automatisch handhabt, und schafft so ein nahtloses Erlebnis, bei dem Claude beliebige Tools verwenden kann, die es benötigt, um Nutzerfragen vollständig zu beantworten.