Erweitertes Denken

„Extended thinking" (erweitertes Denken) gibt Claude verbesserte Reasoning-Fähigkeiten für komplexe Aufgaben und bietet dabei unterschiedliche Grade an Transparenz in seinen schrittweisen Denkprozess, bevor es seine endgültige Antwort liefert.



Unterstützte Modelle

Erweitertes Denken ist auf allen aktuellen Claude-Modellen verfügbar. Wie du es aktivierst, hängt vom Modell ab:

Mit adaptivem Denken entscheidet das Modell bei jeder Anfrage, wann und wie viel es denkt. Auf Claude Mythos Preview, Claude Fable 5 und Claude Mythos 5 wird thinking: {type: "disabled"} nicht unterstützt. Für modellspezifische Verhaltensunterschiede (Denkausgabe, verschachteltes Denken und Block-Erhaltung) siehe Unterschiede im Denken zwischen Modellversionen.



Wie erweitertes Denken funktioniert

Wenn erweitertes Denken aktiviert ist, erstellt Claude thinking-Content-Blöcke, in denen es sein internes Reasoning ausgibt. Claude bezieht Erkenntnisse aus diesem Reasoning ein, bevor es eine endgültige Antwort formuliert.

Die API-Antwort enthält thinking-Content-Blöcke, gefolgt von text-Content-Blöcken.

Hier ist ein Beispiel für das Standard-Antwortformat:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Let me analyze this step by step...",
      "signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
    },
    {
      "type": "text",
      "text": "Based on my analysis..."
    }
  ]
}

Weitere Informationen zum Antwortformat des erweiterten Denkens findest du in der Messages-API-Referenz.



Wie du erweitertes Denken verwendest

Hier ist ein Beispiel für die Verwendung von erweitertem Denken in der Messages-API:

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": 10000},
    messages=[
        {
            "role": "user",
            "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?",
        }
    ],
)

# Die Antwort enthält zusammengefasste Denkblöcke und Textblöcke
for block in response.content:
    match block.type:
        case "thinking":
            print(f"\nThinking summary: {block.thinking}")
        case "text":
            print(f"\nResponse: {block.text}")

Um erweitertes Denken zu aktivieren, füge ein thinking-Objekt mit type auf enabled gesetzt und einem budget_tokens-Wert hinzu. Bei Modellen, bei denen manuelles erweitertes Denken veraltet oder nicht unterstützt ist (siehe Unterstützte Modelle), verwende stattdessen type: "adaptive" wie in Adaptives Denken beschrieben.

Der Parameter budget_tokens legt die maximale Anzahl von Tokens fest, die Claude für seinen internen Reasoning-Prozess verwenden kann. Dieses Limit gilt für die vollständigen Denk-Tokens, nicht für die zusammengefasste Ausgabe. Größere Budgets können die Antwortqualität verbessern, indem sie eine gründlichere Analyse für komplexe Probleme ermöglichen, obwohl Claude möglicherweise nicht das gesamte zugewiesene Budget nutzt, insbesondere bei Bereichen über 32k.

budget_tokens muss auf einen Wert kleiner als max_tokens gesetzt werden. Wenn du jedoch verschachteltes Denken mit Tools verwendest, kannst du dieses Limit überschreiten, da das Token-Limit dann dein gesamtes Kontextfenster wird. Da budget_tokens kleiner als max_tokens sein muss, kann erweitertes Denken nicht mit max_tokens: 0 (Cache-Vorwärmung) kombiniert werden.



Steuerung der Denkanzeige

Das Feld display in der Thinking-Konfiguration steuert, wie Thinking-Inhalte in API-Antworten zurückgegeben werden. Es akzeptiert zwei Werte:

• "summarized": Thinking-Blöcke enthalten zusammengefassten Thinking-Text. Siehe Zusammengefasstes Thinking für Details. Dies ist die Standardeinstellung bei Claude Opus 4.6, Claude Sonnet 4.6 und früheren Claude 4-Modellen.
• "omitted": Thinking-Blöcke werden mit einem leeren thinking-Feld zurückgegeben. Das signature-Feld enthält weiterhin das verschlüsselte vollständige Thinking für die Kontinuität über mehrere Turns hinweg (siehe Thinking-Verschlüsselung). Dies ist die Standardeinstellung bei Claude Fable 5, Claude Mythos 5, Claude Sonnet 5, Claude Opus 4.8, Claude Opus 4.7 und Claude Mythos Preview.

Die Einstellung display: "omitted" ist nützlich, wenn deine Anwendung den Nutzern keine Thinking-Inhalte anzeigt. Der Hauptvorteil ist eine schnellere Zeit bis zum ersten Text-Token beim Streaming: Der Server überspringt das Streaming der Thinking-Tokens vollständig und liefert nur die Signatur, sodass das Streaming der endgültigen Textantwort früher beginnt.

Hier sind einige wichtige Überlegungen zum ausgelassenen Thinking:

• Dir werden weiterhin die vollständigen Thinking-Tokens berechnet. Das Auslassen reduziert die Latenz, nicht die Kosten.
• Wenn du Thinking-Blöcke in Multi-Turn-Konversationen zurückgibst, übergib sie unverändert. Der Server entschlüsselt die signature, um das ursprüngliche Thinking für die Prompt-Konstruktion zu rekonstruieren (siehe Thinking-Blöcke beibehalten). Jeglicher Text, den du im thinking-Feld eines zurückgesendeten ausgelassenen Blocks platzierst, wird ignoriert.
• display ist ungültig mit thinking.type: "disabled" (es gibt nichts anzuzeigen).
• Wenn du thinking.type: "adaptive" verwendest und das Modell das Thinking für eine einfache Anfrage überspringt, wird unabhängig von display kein Thinking-Block erzeugt.

Automatisierte Pipelines, die Denkinhalte niemals an Endnutzer weitergeben, können den Overhead des Empfangs von Denk-Tokens über die Leitung überspringen. Latenzempfindliche Anwendungen erhalten dieselbe Reasoning-Qualität, ohne darauf warten zu müssen, dass Denktext gestreamt wird, bevor die endgültige Antwort beginnt.

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000,
        "display": "omitted",
    },
    messages=[
        {"role": "user", "content": "What is 27 * 453?"},
    ],
)

for block in response.content:
    if block.type == "thinking":
        if block.thinking:
            print(f"Thinking: {block.thinking}")
        else:
            print("Thinking: [omitted]")
    elif block.type == "text":
        print(f"Response: {block.text}")

Wenn display: "omitted" gesetzt ist, enthält die Antwort thinking-Blöcke mit einem leeren thinking-Feld:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "",
      "signature": "EosnCkYICxIMMb3LzNrMu..."
    },
    {
      "type": "text",
      "text": "The answer is 12,231."
    }
  ]
}

Beim Streaming mit display: "omitted" werden keine thinking_delta-Events ausgegeben; siehe Streaming von Denken für die Event-Sequenz.



Zusammengefasstes Denken

Wenn erweitertes Denken aktiviert ist, gibt die Messages API für Claude 4-Modelle eine Zusammenfassung von Claudes vollständigem Denkprozess zurück. Zusammengefasstes Denken bietet die vollen Intelligenzvorteile des erweiterten Denkens und verhindert gleichzeitig Missbrauch. Dies ist das Standardverhalten bei Claude 4-Modellen, wenn das Feld display in der Thinking-Konfiguration nicht gesetzt oder auf "summarized" gesetzt ist. Bei Claude Fable 5, Claude Mythos 5, Claude Sonnet 5, Claude Opus 4.8, Claude Opus 4.7 und Claude Mythos Preview ist display stattdessen standardmäßig auf "omitted" gesetzt, sodass du display: "summarized" explizit setzen musst, um zusammengefasstes Denken zu erhalten.

Hier sind einige wichtige Überlegungen zum zusammengefassten Denken:

• Dir werden die vollständigen Thinking-Token berechnet, die durch die ursprüngliche Anfrage generiert wurden, nicht die Zusammenfassungs-Token.
• Die abgerechnete Anzahl der Output-Token wird nicht mit der Anzahl der Token übereinstimmen, die du in der Antwort siehst.
• Bei Claude 4-Modellen sind die ersten Zeilen der Thinking-Ausgabe ausführlicher und liefern detaillierte Überlegungen, die besonders für Prompt-Engineering-Zwecke hilfreich sind. Claude Mythos Preview fasst ab dem ersten Token zusammen, sodass seine Thinking-Blöcke diese ausführliche Einleitung nicht zeigen.
• Da Anthropic bestrebt ist, die Funktion des erweiterten Denkens zu verbessern, kann sich das Zusammenfassungsverhalten ändern.
• Die Zusammenfassung bewahrt die Kernideen von Claudes Denkprozess mit minimaler zusätzlicher Latenz und ermöglicht so eine streambare Benutzererfahrung.
• Die Zusammenfassung wird von einem anderen Modell verarbeitet als dem, das du in deinen Anfragen ansprichst. Das Thinking-Modell sieht die zusammengefasste Ausgabe nicht.



Streaming von Denken

Du kannst Antworten mit erweitertem Denken über Server-Sent Events (SSE) streamen.

Wenn Streaming für erweitertes Denken aktiviert ist, erhältst du Denkinhalte über thinking_delta-Events.

Wenn display: "omitted" gesetzt ist, werden keine thinking_delta-Events ausgegeben. Siehe Steuerung der Denkanzeige.

Weitere Dokumentation zum Streaming über die Messages-API findest du unter Streaming Messages.

So handhabst du Streaming mit Denken:

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": 10000},
    messages=[
        {
            "role": "user",
            "content": "What is the greatest common divisor of 1071 and 462?",
        }
    ],
) as stream:
    thinking_started = False
    response_started = False

    for event in stream:
        if event.type == "content_block_start":
            print(f"\nStarting {event.content_block.type} block...")
            # Setze Flags für jeden neuen Block zurück
            thinking_started = False
            response_started = False
        elif event.type == "content_block_delta":
            if event.delta.type == "thinking_delta":
                if not thinking_started:
                    print("Thinking: ", end="", flush=True)
                    thinking_started = True
                print(event.delta.thinking, end="", flush=True)
            elif event.delta.type == "text_delta":
                if not response_started:
                    print("Response: ", end="", flush=True)
                    response_started = True
                print(event.delta.text, end="", flush=True)
        elif event.type == "content_block_stop":
            print("\nBlock complete.")

Beispiel-Streaming-Ausgabe:

event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-sonnet-4-6", "stop_reason": null, "stop_sequence": null}}

event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": "", "signature": ""}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "I need to find the GCD of 1071 and 462 using the Euclidean algorithm.\n\n1071 = 2 × 462 + 147"}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n462 = 3 × 147 + 21\n147 = 7 × 21 + 0\n\nSo GCD(1071, 462) = 21"}}

// Additional thinking deltas...

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}

event: content_block_stop
data: {"type": "content_block_stop", "index": 0}

event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "The greatest common divisor of 1071 and 462 is **21**."}}

// Additional text deltas...

event: content_block_stop
data: {"type": "content_block_stop", "index": 1}

event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}

event: message_stop
data: {"type": "message_stop"}

Wenn display: "omitted" gesetzt ist, öffnet sich der Thinking-Block, ein einzelnes signature_delta kommt an, und der Block schließt sich ohne thinking_delta-Events. Das Text-Streaming beginnt unmittelbar danach:

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":"","signature":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"signature_delta","signature":"EosnCkYICxIMMb3LzNrMu..."}}

event: content_block_stop
data: {"type":"content_block_stop","index":0}

event: content_block_start
data: {"type":"content_block_start","index":1,"content_block":{"type":"text","text":""}}



Erweitertes Denken mit Tool-Nutzung

Erweitertes Denken kann zusammen mit Tool-Nutzung verwendet werden, wodurch Claude die Tool-Auswahl und die Verarbeitung von Ergebnissen durchdenken kann.

Wenn du erweitertes Denken mit Tool-Nutzung verwendest, beachte die folgenden Einschränkungen:

1. Einschränkung bei der Tool-Auswahl: Tool-Nutzung mit Denken unterstützt nur tool_choice: {"type": "auto"} (Standard) oder tool_choice: {"type": "none"}. Die Verwendung von tool_choice: {"type": "any"} oder tool_choice: {"type": "tool", "name": "..."} führt zu einem Fehler, da diese Optionen die Tool-Nutzung erzwingen, was mit erweitertem Denken nicht kompatibel ist.

2. Erhaltung von Thinking-Blöcken: Während der Tool-Nutzung musst du thinking-Blöcke für die letzte Assistant-Nachricht an die API zurückgeben. Gib den vollständigen, unveränderten Block an die API zurück, um die Reasoning-Kontinuität zu wahren.



Umschalten von Denkmodi in Konversationen

Du kannst das Denken nicht mitten in einem Assistant-Turn umschalten, auch nicht während Tool-Nutzungs-Schleifen. Der gesamte Assistant-Turn sollte in einem einzigen Denkmodus arbeiten:

• Wenn Denken aktiviert ist, sollte der letzte Assistant-Turn mit einem Thinking-Block beginnen.
• Wenn Denken deaktiviert ist, sollte der letzte Assistant-Turn keine Thinking-Blöcke enthalten.

Aus Sicht des Modells sind Tool-Nutzungs-Schleifen Teil des Assistant-Turns. Ein Assistant-Turn ist erst abgeschlossen, wenn Claude seine vollständige Antwort beendet hat, die mehrere Tool-Aufrufe und -Ergebnisse umfassen kann.

Zum Beispiel ist diese Sequenz vollständig Teil eines einzigen Assistant-Turns:

User: "What's the weather in Paris?"
Assistant: [thinking] + [tool_use: get_weather]
User: [tool_result: "20°C, sunny"]
Assistant: [text: "The weather in Paris is 20°C and sunny"]

Obwohl es mehrere API-Nachrichten gibt, ist die Tool-Nutzungs-Schleife konzeptionell Teil einer kontinuierlichen Assistant-Antwort.



Graceful Degradation beim Denken

Wenn ein Denkkonflikt mitten im Turn auftritt (z. B. das Ein- oder Ausschalten des Denkens während einer Tool-Nutzungs-Schleife), deaktiviert die API das Denken für diese Anfrage automatisch. Um die Modellqualität zu erhalten und innerhalb der Verteilung zu bleiben, kann die API:

• Thinking-Blöcke aus der Konversation entfernen, wenn sie eine ungültige Turn-Struktur erzeugen würden
• Das Denken für die aktuelle Anfrage deaktivieren, wenn der Konversationsverlauf mit aktiviertem Denken nicht kompatibel ist

Das bedeutet, dass der Versuch, das Denken mitten im Turn umzuschalten, keinen Fehler verursacht, aber das Denken wird für diese Anfrage stillschweigend deaktiviert. Um zu bestätigen, ob das Denken aktiv war, prüfe auf das Vorhandensein von thinking-Blöcken in der Antwort.



Praktische Hinweise

Best Practice: Plane deine Denkstrategie zu Beginn jedes Turns, anstatt zu versuchen, mitten im Turn umzuschalten.

Beispiel: Umschalten des Denkens nach Abschluss eines Turns

User: "What's the weather?"
Assistant: [tool_use] (thinking disabled)
User: [tool_result]
Assistant: [text: "It's sunny"]
User: "What about tomorrow?"
Assistant: [thinking] + [text: "..."] (thinking enabled - new turn)

Indem du den Assistant-Turn abschließt, bevor du das Denken umschaltest, stellst du sicher, dass das Denken für die neue Anfrage tatsächlich aktiviert ist.



Erhaltung von Thinking-Blöcken

Während der Tool-Nutzung musst du thinking-Blöcke an die API zurückgeben, und du musst den vollständigen, unveränderten Block an die API zurückgeben. Dies ist entscheidend für die Aufrechterhaltung des Reasoning-Flusses des Modells und der Konversationsintegrität.

Wenn Claude Tools aufruft, pausiert es die Erstellung einer Antwort, um auf externe Informationen zu warten. Wenn Tool-Ergebnisse zurückgegeben werden, setzt Claude die Erstellung dieser bestehenden Antwort fort. Dies erfordert die Erhaltung von Thinking-Blöcken während der Tool-Nutzung, aus mehreren Gründen:

1. Reasoning-Kontinuität: Die Thinking-Blöcke erfassen Claudes schrittweises Reasoning, das zu Tool-Anfragen geführt hat. Wenn du Tool-Ergebnisse sendest, stellt das Einbeziehen des ursprünglichen Denkens sicher, dass Claude sein Reasoning dort fortsetzen kann, wo es aufgehört hat.

2. Kontexterhaltung: Obwohl Tool-Ergebnisse in der API-Struktur als User-Nachrichten erscheinen, sind sie Teil eines kontinuierlichen Reasoning-Flusses. Die Erhaltung von Thinking-Blöcken bewahrt diesen konzeptionellen Fluss über mehrere API-Aufrufe hinweg. Weitere Informationen zum Kontextmanagement findest du im Leitfaden zu Kontextfenstern.

Wichtig: Wenn du thinking-Blöcke bereitstellst, muss die gesamte Sequenz aufeinanderfolgender thinking-Blöcke mit den Ausgaben übereinstimmen, die das Modell während der ursprünglichen Anfrage generiert hat; du kannst die Reihenfolge dieser Blöcke nicht neu anordnen oder ändern.



Verschachteltes Denken

Erweitertes Denken mit Tool-Nutzung in Claude-4-Modellen unterstützt „interleaved thinking" (verschachteltes Denken), das es Claude ermöglicht, zwischen Tool-Aufrufen zu denken und nach dem Erhalt von Tool-Ergebnissen anspruchsvolleres Reasoning durchzuführen.

Mit verschachteltem Denken kann Claude:

• Über die Ergebnisse eines Tool-Aufrufs nachdenken, bevor es entscheidet, was als Nächstes zu tun ist
• Mehrere Tool-Aufrufe mit Reasoning-Schritten dazwischen verketten
• Nuanciertere Entscheidungen basierend auf Zwischenergebnissen treffen

Wie du verschachteltes Denken aktivierst, hängt vom Modell ab:

Frühere Claude-4-Modelle bedeutet hier Claude Sonnet 4.5, Claude Opus 4.1 (veraltet), Claude Opus 4 (eingestellt, außer auf Google Cloud) und Claude Sonnet 4 (eingestellt, außer auf Bedrock und Google Cloud).

Hier sind einige wichtige Überlegungen zum verschachtelten Denken:

• Mit verschachteltem Denken kann budget_tokens den max_tokens-Parameter überschreiten, da es das Gesamtbudget über alle Thinking-Blöcke innerhalb eines Assistant-Turns darstellt.
• Verschachteltes Denken wird nur für Tools unterstützt, die über die Messages-API verwendet werden.
• Die Claude-API und Claude Platform on AWS akzeptieren interleaved-thinking-2025-05-14 in Anfragen an jedes Modell, ohne einen Fehler zurückzugeben. Bei Modellen, die verschachteltes Denken nicht unterstützen, wird der Header ignoriert. Bei Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6 und Claude Sonnet 5 ist er veraltet und wird sicher ignoriert. Bei Claude Mythos Preview ist er nicht erforderlich und wird sicher ignoriert.
• Auf partnerbetriebenen Plattformen (zum Beispiel Amazon Bedrock und Google Cloud) schlägt deine Anfrage fehl, wenn du interleaved-thinking-2025-05-14 an ein anderes Modell als Claude Opus 4.8, Claude Opus 4.7, Claude Sonnet 5, Claude Opus 4.6, Claude Sonnet 4.6, Claude Opus 4.5, Claude Opus 4.1 (veraltet), Opus 4 (eingestellt, außer auf Google Cloud), Sonnet 4.5 oder Sonnet 4 (eingestellt, außer auf Bedrock und Google Cloud) übergibst.



Erweitertes Denken mit Prompt-Caching

Prompt-Caching mit Denken hat mehrere wichtige Überlegungen:

Entfernung von Thinking-Blöcken aus dem Kontext

• Bei früheren Opus-/Sonnet-Modellen und allen Haiku-Modellen werden Thinking-Blöcke aus vorherigen Turns aus dem Kontext entfernt, was Cache-Breakpoints beeinflussen kann. Bei Opus 4.5+ und Sonnet 4.6+ werden sie standardmäßig beibehalten.
• Beim Fortsetzen von Konversationen mit Tool-Nutzung werden Thinking-Blöcke gecacht und zählen als Input-Tokens, wenn sie aus dem Cache gelesen werden
• Dies schafft einen Kompromiss: Während Thinking-Blöcke visuell keinen Platz im Kontextfenster verbrauchen, zählen sie dennoch zu deiner Input-Token-Nutzung, wenn sie gecacht sind
• Wenn das Denken deaktiviert wird und du Denkinhalte im aktuellen Tool-Nutzungs-Turn übergibst, werden die Denkinhalte entfernt und das Denken bleibt für diese Anfrage deaktiviert

Cache-Invalidierungsmuster

• Änderungen an Denkparametern (aktiviert/deaktiviert oder Budget-Zuweisung) invalidieren Cache-Breakpoints für Nachrichten
• Verschachteltes Denken verstärkt die Cache-Invalidierung, da Thinking-Blöcke zwischen mehreren Tool-Aufrufen auftreten können
• System-Prompts und Tools bleiben trotz Änderungen an Denkparametern oder Block-Entfernung gecacht



Verständnis des Caching-Verhaltens von Thinking-Blöcken

Wenn du erweitertes Denken mit Tool-Nutzung verwendest, zeigen Thinking-Blöcke ein spezifisches Caching-Verhalten, das die Token-Zählung beeinflusst:

Wie es funktioniert:

1. Caching erfolgt nur, wenn du eine nachfolgende Anfrage stellst, die Tool-Ergebnisse enthält
2. Wenn die nachfolgende Anfrage gestellt wird, kann der vorherige Konversationsverlauf (einschließlich Thinking-Blöcken) gecacht werden
3. Diese gecachten Thinking-Blöcke zählen als Input-Tokens in deinen Nutzungsmetriken, wenn sie aus dem Cache gelesen werden
4. Wenn ein Nicht-Tool-Ergebnis-User-Block enthalten ist: Bei Opus 4.5+ und Sonnet 4.6+ werden vorherige Thinking-Blöcke beibehalten; bei früheren Opus-/Sonnet-Modellen und allen Haiku-Modellen werden alle vorherigen Thinking-Blöcke ignoriert und aus dem Kontext entfernt

Detaillierter Beispielablauf:

Anfrage 1:

User: "What's the weather in Paris?"

Antwort 1:

[thinking_block_1] + [tool_use block 1]

Anfrage 2:

User: ["What's the weather in Paris?"],
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True]

Antwort 2:

[thinking_block_2] + [text block 2]

Anfrage 2 schreibt einen Cache des Anfrageinhalts (nicht der Antwort). Der Cache enthält die ursprüngliche User-Nachricht, den ersten Thinking-Block, den Tool-Use-Block und das Tool-Ergebnis.

Anfrage 3:

User: ["What's the weather in Paris?"],
Assistant: [thinking_block_1] + [tool_use block 1],
User: [tool_result_1, cache=True],
Assistant: [thinking_block_2] + [text block 2],
User: [Text response, cache=True]

Bei Opus 4.5+ und Sonnet 4.6+ werden alle vorherigen Thinking-Blöcke standardmäßig beibehalten. Bei früheren Opus-/Sonnet-Modellen und allen Haiku-Modellen werden, da ein Nicht-Tool-Ergebnis-User-Block enthalten war, alle vorherigen Thinking-Blöcke ignoriert und aus dem Kontext entfernt. Diese Anfrage wird genauso verarbeitet wie:

User: ["What's the weather in Paris?"],
Assistant: [tool_use block 1],
User: [tool_result_1, cache=True],
Assistant: [text block 2],
User: [Text response, cache=True]

Wichtige Punkte:

• Dieses Caching-Verhalten erfolgt automatisch, auch ohne explizite cache_control-Marker
• Dieses Verhalten ist konsistent, unabhängig davon, ob reguläres Denken oder verschachteltes Denken verwendet wird



Max-Tokens und Kontextfenstergröße mit erweitertem Denken

max_tokens (das dein Denkbudget einschließt, wenn Denken aktiviert ist) wird als striktes Limit durchgesetzt. Bei Claude-4.5-Modellen und neuer akzeptiert die API die Anfrage, wenn Input-Tokens plus max_tokens die Kontextfenstergröße überschreiten. Wenn die Generierung dann das Kontextfenster-Limit erreicht, stoppt sie mit stop_reason: "model_context_window_exceeded". Bei früheren Modellen gibt die API stattdessen einen Validierungsfehler zurück. Siehe Umgang mit Stop-Reasons.



Das Kontextfenster mit erweitertem Denken

Bei der Berechnung der Kontextfensternutzung mit aktiviertem Denken gibt es einige Überlegungen zu beachten:

• Bei Opus 4.5+ und Sonnet 4.6+ werden Thinking-Blöcke aus vorherigen Turns beibehalten und zählen zu deinem Kontextfenster; bei früheren Opus-/Sonnet-Modellen und allen Haiku-Modellen werden sie entfernt und nicht gezählt
• Das Denken des aktuellen Turns zählt zu deinem max_tokens-Limit für diesen Turn

Das folgende Diagramm zeigt das spezialisierte Token-Management, wenn erweitertes Denken aktiviert ist:

Das effektive Kontextfenster wird wie folgt berechnet:

context window =
  (current input tokens - previous thinking tokens) +
  (thinking tokens + encrypted thinking tokens + text output tokens)

Verwende die Token-Counting-API, um genaue Token-Zählungen für deinen spezifischen Anwendungsfall zu erhalten, insbesondere wenn du mit mehrstufigen Konversationen arbeitest, die Denken enthalten.



Das Kontextfenster mit erweitertem Denken und Tool-Nutzung

Wenn du erweitertes Denken mit Tool-Nutzung verwendest, müssen Thinking-Blöcke explizit erhalten und mit den Tool-Ergebnissen zurückgegeben werden.

Die effektive Kontextfensterberechnung für erweitertes Denken mit Tool-Nutzung wird zu:

context window =
  (current input tokens + previous thinking tokens + tool use tokens) +
  (thinking tokens + encrypted thinking tokens + text output tokens)

Das folgende Diagramm veranschaulicht das Token-Management für erweitertes Denken mit Tool-Nutzung:



Verwaltung von Tokens mit erweitertem Denken

Angesichts des Kontextfenster- und max_tokens-Verhaltens mit erweitertem Denken musst du möglicherweise:

• Deine Token-Nutzung aktiver überwachen und verwalten
• max_tokens-Werte anpassen, wenn sich deine Prompt-Länge ändert
• Möglicherweise die Token-Counting-Endpunkte häufiger verwenden
• Dir bewusst sein, dass sich vorherige Thinking-Blöcke nicht in deinem Kontextfenster ansammeln



Denkverschlüsselung

Der vollständige Denkinhalt wird verschlüsselt und im Feld signature zurückgegeben. Dieses Feld wird verwendet, um zu verifizieren, dass die Denkblöcke von Claude generiert wurden, wenn sie an die API zurückgegeben werden.

Hier sind einige wichtige Überlegungen zur Verschlüsselung des Denkens:

• Beim Streaming von Antworten wird die Signatur über ein signature_delta innerhalb eines content_block_delta-Events direkt vor dem content_block_stop-Event hinzugefügt.
• signature-Werte sind in Claude 4-Modellen deutlich länger als in früheren Modellen.
• Das signature-Feld ist ein opakes Feld und sollte nicht interpretiert oder geparst werden.
• signature-Werte sind plattformübergreifend kompatibel (Claude APIs, Amazon Bedrock und Google Cloud). Werte, die auf einer Plattform generiert wurden, sind mit einer anderen kompatibel.



Redacted-Thinking-Blöcke

Zusätzlich zu regulären thinking-Blöcken kann die API redacted_thinking-Blöcke zurückgeben. Ein redacted_thinking-Block enthält verschlüsselte Denkinhalte in einem data-Feld, ohne lesbare Zusammenfassung:

{
  "type": "redacted_thinking",
  "data": "..."
}

Das data-Feld ist undurchsichtig und verschlüsselt. Wie das signature-Feld bei regulären Thinking-Blöcken solltest du redacted_thinking-Blöcke unverändert an die API zurückgeben, wenn du eine mehrstufige Konversation mit Tools fortsetzt.



Unterschiede im Denken zwischen Modellversionen

Die Messages-API behandelt Denken je nach Claude-Modellversion unterschiedlich. Die folgende Tabelle gibt einen komprimierten Vergleich:

¹ Setze display: "summarized", um zusammengefasstes Denken zu erhalten. Auf Claude Fable 5, Claude Mythos 5 und Claude Mythos Preview werden rohe Denk-Tokens niemals zurückgegeben.
² Mit adaptivem Denken. Der interleaved-thinking-2025-05-14-Beta-Header ist bei diesen Modellen nicht erforderlich und wird sicher ignoriert, falls enthalten.
³ Blöcke werden entfernt, wenn die Konversation auf einem Modell fortgesetzt wird, das das Mythos-Denkformat nicht unterstützt.



Thinking-Block-Erhaltung nach Modell

Ob Thinking-Blöcke aus vorherigen Assistant-Turns standardmäßig im Kontext erhalten bleiben, hängt von der Modellklasse ab. Opus: Claude Opus 4.5 und spätere Opus-Modelle behalten alle vorherigen Thinking-Blöcke; Claude Opus 4.1 (veraltet) und frühere Opus-Modelle behalten nur das Denken des letzten Assistant-Turns. Sonnet: Claude Sonnet 4.6 und spätere Sonnet-Modelle behalten alle; Claude Sonnet 4.5 und frühere Sonnet-Modelle behalten nur den letzten Turn. Haiku: Alle Haiku-Modelle bis einschließlich Claude Haiku 4.5 behalten nur den letzten Turn. Claude Mythos Preview behält ebenfalls alle vorherigen Thinking-Blöcke.

Vorteile der Thinking-Block-Erhaltung:

• Cache-Optimierung: Bei der Verwendung von Tool-Nutzung ermöglichen erhaltene Thinking-Blöcke Cache-Treffer, da sie mit Tool-Ergebnissen zurückgegeben und inkrementell über den Assistant-Turn hinweg gecacht werden, was zu Token-Einsparungen in mehrstufigen Workflows führt
• Keine Auswirkung auf die Intelligenz: Die Erhaltung von Thinking-Blöcken hat keine negativen Auswirkungen auf die Modellleistung

Wichtige Überlegungen:

• Kontextnutzung: Lange Konversationen verbrauchen mehr Kontextplatz, da Thinking-Blöcke im Kontext beibehalten werden
• Automatisches Verhalten: Dies ist der Standard für jedes Modell wie oben aufgeführt. Keine Code-Änderungen oder Beta-Header sind erforderlich
• Abwärtskompatibilität: Um dieses Feature zu nutzen, gib weiterhin vollständige, unveränderte Thinking-Blöcke an die API zurück, wie du es für Tool-Nutzung tun würdest



Preise

Vollständige Preisinformationen einschließlich Basistarifen, Cache-Schreibvorgängen, Cache-Treffern und Output-Token findest du auf der Preisseite.

Der Denkprozess verursacht Kosten für:

• Token, die während des Denkens verwendet werden (Output-Token)
• Thinking-Blöcke aus vorherigen Assistenten-Turns, die im Kontext behalten werden: nur der letzte Turn bei früheren Opus/Sonnet-Modellen und allen Haiku-Modellen; standardmäßig alle Turns bei Opus 4.5+ und Sonnet 4.6+ (Input-Token)
• Standard-Text-Output-Token

Bei Verwendung von zusammengefasstem Denken:

• Input-Token: Token in deiner ursprünglichen Anfrage (ohne Thinking-Token aus vorherigen Turns)
• Output-Token (abgerechnet): Die ursprünglichen Thinking-Token, die Claude intern generiert hat
• Output-Token (sichtbar): Die zusammengefassten Thinking-Token, die du in der Antwort siehst
• Keine Kosten: Token, die zur Generierung der Zusammenfassung verwendet werden

Bei Verwendung von display: "omitted":

• Input-Token: Token in deiner ursprünglichen Anfrage (wie bei zusammengefasstem Denken)
• Output-Token (abgerechnet): Die ursprünglichen Thinking-Token, die Claude intern generiert hat (wie bei zusammengefasstem Denken)
• Output-Token (sichtbar): Null Thinking-Token (das thinking-Feld ist leer)

Um zu sehen, wie viele abgerechnete Output-Token für internes Reasoning aufgewendet wurden, lies usage.output_tokens_details.thinking_tokens in der Antwort aus. Dieser Wert spiegelt das rohe Reasoning wider, das das Modell generiert hat (nicht den zusammengefassten Text, der im Body zurückgegeben wird), und ist immer kleiner oder gleich output_tokens. Ziehe ihn von output_tokens ab, um den Nicht-Reasoning-Anteil der Ausgabe näherungsweise zu bestimmen.

{
  "usage": {
    "input_tokens": 25,
    "output_tokens": 348,
    "output_tokens_details": {
      "thinking_tokens": 312
    }
  }
}

output_tokens bleibt die inklusive, maßgebliche Gesamtsumme, die für die Abrechnung verwendet wird. output_tokens_details ist eine schreibgeschützte Aufschlüsselung für Observability-Zwecke.



Best Practices und Überlegungen für erweitertes Denken



Arbeiten mit Thinking-Budgets

• Budget-Optimierung: Das minimale Budget beträgt 1.024 Token. Beginne mit dem Minimum und erhöhe das Thinking-Budget schrittweise, um den optimalen Bereich für deinen Anwendungsfall zu finden. Höhere Token-Anzahlen ermöglichen umfassenderes Reasoning, allerdings mit abnehmendem Grenznutzen je nach Aufgabe. Eine Erhöhung des Budgets kann die Antwortqualität verbessern, geht aber mit erhöhter Latency einher. Teste für kritische Aufgaben verschiedene Einstellungen, um die optimale Balance zu finden. Beachte, dass das Thinking-Budget ein Zielwert und keine strikte Grenze ist. Die tatsächliche Token-Nutzung kann je nach Aufgabe variieren.
• Ausgangspunkte: Beginne bei komplexen Aufgaben mit größeren Thinking-Budgets (16k+ Token) und passe sie nach Bedarf an.
• Große Budgets: Verwende für Thinking-Budgets über 32k die Batch-Verarbeitung, um Netzwerkprobleme zu vermeiden. Anfragen, die das Modell dazu bringen, über 32k Token nachzudenken, führen zu lang laufenden Anfragen, die auf System-Timeouts und Limits für offene Verbindungen stoßen können.
• Tracking der Token-Nutzung: Überwache die Nutzung von Thinking-Token, um Kosten und Performance zu optimieren. Das Feld usage.output_tokens_details.thinking_tokens in der Antwort gibt an, wie viele der abgerechneten Output-Token internes Reasoning waren. Beim Streaming erscheint diese Aufschlüsselung nur im finalen message_delta-Event.



Performance-Überlegungen

• Antwortzeiten: Stelle dich auf längere Antwortzeiten aufgrund der zusätzlichen Verarbeitung ein. Das Generieren von Thinking-Blöcken erhöht die Gesamtantwortzeit.
• Streaming-Anforderungen: Die SDKs erfordern Streaming, wenn max_tokens größer als 21.333 ist, um HTTP-Timeouts bei lang laufenden Anfragen zu vermeiden. Dies ist eine clientseitige Validierung, keine API-Einschränkung. Wenn du Events nicht inkrementell verarbeiten musst, verwende .stream() mit .get_final_message() (Python) oder .finalMessage() (TypeScript), um das vollständige Message-Objekt zu erhalten, ohne einzelne Events verarbeiten zu müssen. Siehe Streaming Messages für Details. Sei beim Streaming darauf vorbereitet, sowohl Thinking- als auch Text-Content-Blöcke zu verarbeiten, sobald sie eintreffen.
• Thinking für geringere Latency auslassen: Wenn deine Anwendung keine Thinking-Inhalte anzeigt, setze display: "omitted" in der Thinking-Konfiguration, um die Zeit bis zum ersten Text-Token zu reduzieren. Siehe Steuerung der Thinking-Anzeige.



Feature-Kompatibilität

• Thinking ist nicht kompatibel mit Änderungen an temperature oder top_k sowie mit erzwungener Tool-Nutzung.
• Wenn Thinking aktiviert ist, kannst du top_p auf Werte zwischen 1 und 0,95 setzen.
• Du kannst Antworten nicht vorausfüllen, wenn Thinking aktiviert ist.
• Änderungen am Thinking-Budget machen gecachte Prompt-Präfixe ungültig, die Nachrichten enthalten. Gecachte System-Prompts und Tool-Definitionen funktionieren jedoch weiterhin, wenn sich Thinking-Parameter ändern.



Nutzungsrichtlinien

• Aufgabenauswahl: Verwende erweitertes Denken für besonders komplexe Aufgaben, die von schrittweisem Reasoning profitieren, wie Mathematik, Programmierung und Analyse.
• Kontext-Handling: Du musst vorherige Thinking-Blöcke nicht selbst entfernen. Bei Opus 4.5+ und Sonnet 4.6+ behält die Claude API Thinking-Blöcke aus vorherigen Turns standardmäßig bei; bei früheren Opus/Sonnet-Modellen und allen Haiku-Modellen werden sie automatisch ignoriert und nicht bei der Berechnung der Kontextnutzung berücksichtigt.
• Prompt Engineering: Sieh dir die Prompting-Tipps für erweitertes Denken an, wenn du Claudes Thinking-Fähigkeiten maximieren möchtest.



Nächste Schritte