Wird geladen

Implementierung mehrerer Turns

Lektion 2715 Min.
Wird geladen

Der Aufbau eines Konversationssystems mit Tools erfordert die Implementierung einer Schleife, die Claude so lange aufruft, bis es keine Tool-Nutzung mehr anfordert. Wenn Claude keine Tools mehr anfordert, signalisiert dies, dass eine endgültige Antwort für den Nutzer bereit ist.

Erkennen von Tool-Anfragen

Der Schlüssel, um zu wissen, ob Claude ein Tool nutzen möchte, liegt im Feld stop_reason der Antwortnachricht. Wenn Claude entscheidet, dass es ein Tool aufrufen muss, wird dieses Feld auf "tool_use" gesetzt. Dies gibt uns eine klare Möglichkeit zu prüfen, ob wir die Konversationsschleife fortsetzen müssen:

python
if response.stop_reason != "tool_use":
    break  # Claude is done, no more tools needed

Die Konversationsschleife

Die Hauptfunktion der Konversation folgt einem einfachen Muster:

python
def run_conversation(messages):
    while True:
        response = chat(messages, tools=[get_current_datetime_schema])
        add_assistant_message(messages, response)
        print(text_from_message(response))
        
        if response.stop_reason != "tool_use":
            break
            
        tool_results = run_tools(response)
        add_user_message(messages, tool_results)
    
    return messages

Diese Schleife läuft weiter, bis Claude eine endgültige Antwort liefert, ohne weitere Tools anzufordern.

Umgang mit mehreren Tool-Aufrufen

Claude kann in einer einzigen Antwort mehrere Tools anfordern. Der Inhalt der Nachricht enthält eine Liste von Blöcken, und wir müssen jeden Tool-Use-Block einzeln verarbeiten:

message.content enthält einen TextBlock und ToolUseBlocks für "10 + 10" und "30 + 30", die jeweils ausgeführt und als ToolResultBlock zurückgegeben werden.

Die Funktion run_tools übernimmt dies, indem sie nach Tool-Use-Blöcken filtert und jeden einzeln verarbeitet:

python
def run_tools(message):
    tool_requests = [
        block for block in message.content if block.type == "tool_use"
    ]
    tool_result_blocks = []
    
    for tool_request in tool_requests:
        # Verarbeite jede Tool-Anfrage...

Tool-Result-Blöcke

Jeder Tool-Use-Block muss mit einem entsprechenden Tool-Result-Block beantwortet werden. Die Verbindung zwischen ihnen wird über übereinstimmende IDs hergestellt:

Notebook-Zelle, in der run_tools get_current_datetime aufruft, wenn der Tool-Name übereinstimmt, und dann einen Tool-Result-Block erstellt.

Die Struktur des Tool-Result-Blocks umfasst:

python
tool_result_block = {
    "type": "tool_result",
    "tool_use_id": tool_request.id,
    "content": json.dumps(tool_output),
    "is_error": False
}

Fehlerbehandlung

Eine robuste Tool-Ausführung erfordert die Behandlung möglicher Fehler. Wenn ein Tool fehlschlägt, müssen wir Claude trotzdem einen Result-Block bereitstellen:

python
try:
    tool_output = run_tool(tool_request.name, tool_request.input)
    tool_result_block = {
        "type": "tool_result",
        "tool_use_id": tool_request.id,
        "content": json.dumps(tool_output),
        "is_error": False
    }
except Exception as e:
    tool_result_block = {
        "type": "tool_result", 
        "tool_use_id": tool_request.id,
        "content": f"Error: {e}",
        "is_error": True
    }

Skalierbares Tool-Routing

Um mehrere Tools zu unterstützen, erstelle eine Routing-Funktion, die Tool-Namen auf ihre Implementierungen abbildet:

python
def run_tool(tool_name, tool_input):
    if tool_name == "get_current_datetime":
        return get_current_datetime(**tool_input)
    elif tool_name == "another_tool":
        return another_tool(**tool_input)
    # Bei Bedarf weitere Tools hinzufügen

Dieser Ansatz macht es einfach, neue Tools hinzuzufügen, ohne die Kernlogik der Konversation zu verändern.

Vollständiger Workflow

Die vollständige mehrstufige Konversation funktioniert so:

  • Sende die Nutzernachricht zusammen mit den verfügbaren Tools an Claude
  • Claude antwortet mit Text und/oder Tool-Anfragen
  • Führe alle angeforderten Tools aus und erstelle Result-Blöcke
  • Sende die Tool-Ergebnisse als Nutzernachricht zurück
  • Wiederhole dies, bis Claude eine endgültige Antwort liefert

Dies schafft eine nahtlose Erfahrung, bei der Claude mehrere Tools über mehrere Turns hinweg nutzen kann, um komplexe Nutzeranfragen vollständig zu beantworten. Der Konversationsverlauf bewahrt den vollständigen Kontext und ermöglicht es Claude, auf vorherigen Tool-Ergebnissen aufzubauen, um umfassende Antworten zu liefern.