Claude Platform Docs
MessagesDenken

Denken in Tool- und Multi-Turn-Workflows

Gehe einen vollständigen Tool-Use-Roundtrip über zwei Turns durch, der Thinking-Blöcke korrekt bewahrt, und sieh dir an, wie verschachteltes Denken den Ablauf verändert.

Diese Seite führt durch einen vollständigen Tool-Use-Roundtrip über zwei Turns mit aktiviertem Denken: Claude denkt, fordert einen Tool-Aufruf an, erhält das Ergebnis und schließt seine Antwort ab, wobei die „thinking blocks“ (Thinking-Blöcke) in jedem Schritt korrekt behandelt werden. Die vollständigen Regeln findest du auf der Seite Denken, in Denken mit Tool-Nutzung und Thinking-Blöcke bewahren; diese Seite zeigt diese Regeln angewendet in ausführbarem Code.

Die Regeln, die dieser Walkthrough anwendet

Jeder Link führt zur vollständigen Formulierung auf der Seite Denken:

Die Beispiele verwenden adaptives Denken; auf Modellen, die nur erweitertes Denken unterstützen, ersetze es durch thinking: {type: "enabled", budget_tokens: N}. Die Roundtrip-Regeln sind identisch.

Einen Tool-Use-Roundtrip über zwei Turns durchgehen

Das Beispiel definiert ein get_weather-Tool, lässt Claude denken und einen Tool-Aufruf anfordern und gibt dann das Tool-Ergebnis zusammen mit dem Assistant-Turn zurück, der exakt so wiedergegeben wird, wie er empfangen wurde, einschließlich Thinking-Block.

  1. Stelle die erste Anfrage mit einem verfügbaren Tool

    Sende eine Anfrage mit aktiviertem adaptivem Denken und definiertem Tool. Abgesehen vom thinking-Parameter ist dies eine standardmäßige Anfrage mit Tool-Nutzung:

    
client = anthropic.Anthropic()

weather_tool = {
    "name": "get_weather",
    "description": "Get current weather for a location",
    "input_schema": {
        "type": "object",
        "properties": {"location": {"type": "string", "description": "City name"}},
        "required": ["location"],
    },
}

# Erste Anfrage – Claude antwortet mit Denken und Tool-Anfrage
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    tools=[weather_tool],
    messages=[{"role": "user", "content": "What's the weather in Paris?"}],
)
print(response)

  2. Erfasse das Content-Array, um es zurückzugeben

    Du solltest thinking-, text- und tool_use-Blöcke im Antwortinhalt sehen, wenn Claude sich bei einem Durchlauf entschieden hat zu denken (bei einfacheren Anfragen kann der adaptive Modus den Thinking-Block überspringen). Lass dieses Content-Array unverändert: Der nächste Schritt sendet es wortwörtlich zurück.

    Output
    {
  "content": [
    {
      "type": "thinking",
      "thinking": "The user wants to know the current weather in Paris. I have access to a function `get_weather`...",
      "signature": "BDaL4VrbR2Oj0hO4XpJxT28J5T...."
    },
    {
      "type": "text",
      "text": "I can help you get the current weather information for Paris. Let me check that for you"
    },
    {
      "type": "tool_use",
      "id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
      "name": "get_weather",
      "input": {
        "location": "Paris"
      }
    }
  ]
}

  3. Gib das Tool-Ergebnis zurück und wiederhole den Assistant-Turn wortwörtlich

    Führe das Tool auf deiner Seite aus und sende dann eine zweite Anfrage, die zwei Nachrichten an die Konversation anhängt. Die erste ist der Assistant-Inhalt, exakt so zurückgegeben, wie er empfangen wurde, sodass der Thinking-Block neben dem tool_use-Block unverändert bleibt. Die zweite ist eine User-Nachricht, die das tool_result enthält.

    Jedes Beispiel ist ein eigenständiges Skript: Es wiederholt die erste Anfrage und sendet dann sofort die Folgeanfrage mit der gerade erhaltenen Antwort.

    
client = anthropic.Anthropic()
weather_tool = {
    "name": "get_weather",
    "description": "Get current weather for a location",
    "input_schema": {
        "type": "object",
        "properties": {"location": {"type": "string", "description": "City name"}},
        "required": ["location"],
    },
}
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    tools=[weather_tool],
    messages=[{"role": "user", "content": "What's the weather in Paris?"}],
)
# Extrahiere den tool_use-Block, um seine ID für das tool_result zu erhalten
tool_use_block = next(block for block in response.content if block.type == "tool_use")

# Rufe deine eigentliche Wetter-API auf; hier würde dein tatsächlicher API-Aufruf stehen
# Nehmen wir an, das ist die Antwort, die wir zurückbekommen
weather_data = {"temperature": 88}

# Zweite Anfrage – Füge den Assistant-Turn und das tool_result hinzu
continuation = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "What's the weather in Paris?"},
        # Gib den Assistant-Inhalt exakt so zurück, wie er empfangen wurde. Wenn ein Thinking-
        # Block vorhanden ist, muss er den tool_use-Block begleiten.
        {"role": "assistant", "content": response.content},
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": tool_use_block.id,
                    "content": f"Current temperature: {weather_data['temperature']}°F",
                }
            ],
        },
    ],
)
print(continuation)

  4. Lies die endgültige Antwort

    Du solltest sehen, wie Claude den Turn mit Text abschließt. Da „interleaved thinking“ (verschachteltes Denken) im adaptiven Modus automatisch erfolgt, kann die Fortsetzung auch mit einem neuen Thinking-Block vor dem endgültigen Text beginnen:

    Output
    {
  "content": [
    {
      "type": "text",
      "text": "Currently in Paris, the temperature is 88°F (31°C)"
    }
  ]
}

Wie verschachteltes Denken den Ablauf verändert

Verschachteltes Denken ermöglicht es Claude, zwischen Tool-Aufrufen zu denken und über jedes Tool-Ergebnis nachzudenken, bevor es darauf reagiert. Das Konzept und die Verfügbarkeit pro Modell werden in Verschachteltes Denken auf der Seite Denken behandelt; die Verschachtelung ändert, wo Thinking-Blöcke erscheinen, nicht, ob Tool-Aufrufe verkettet werden können. Der folgende Vergleich zeigt, was verschachteltes Denken in einem Workflow mit zwei Tools verändert:

Nächste Schritte

Denken

Der Überblick: Denken aktivieren, Thinking-Ausgabe lesen und die vollständigen Regeln für Tool-Nutzung, Caching und Streaming durchgehen.

Denken steuern

Steuere mit Effort-Stufen und Prompt-basierter Anleitung, wie oft und wie tief Claude denkt.

Erweitertes Denken

Manuelle Thinking-Budgets auf älteren Modellen: budget_tokens-Mechanik und Migration zu adaptivem Denken.

Was this page helpful?