Entwickeln mit erweitertem Denken

Erweitertes Denken verleiht Claude erweiterte Argumentationsfähigkeiten für komplexe Aufgaben und bietet dabei verschiedene Transparenzebenen in seinen schrittweisen Denkprozess, bevor es seine endgültige Antwort liefert.

Unterstützte Modelle

Erweitertes Denken wird in den folgenden Modellen unterstützt:

Claude Opus 4 (claude-opus-4-20250514)
Claude Sonnet 4 (claude-sonnet-4-20250514)
Claude Sonnet 3.7 (claude-3-7-sonnet-20250219)

Das API-Verhalten unterscheidet sich zwischen Claude 3.7 und Claude 4 Modellen, aber die API-Strukturen bleiben genau gleich.

Für weitere Informationen siehe Unterschiede im Denken zwischen Modellversionen.

Wie erweitertes Denken funktioniert

Wenn erweitertes Denken aktiviert ist, erstellt Claude thinking Inhaltsblöcke, in denen es seine interne Argumentation ausgibt. Claude integriert Erkenntnisse aus dieser Argumentation, bevor es eine endgültige Antwort erstellt.

Die API-Antwort wird thinking Inhaltsblöcke enthalten, gefolgt von text Inhaltsblöcken.

Hier ist ein Beispiel des Standard-Antwortformats:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Lass mich das Schritt für Schritt analysieren...",
      "signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
    },
    {
      "type": "text",
      "text": "Basierend auf meiner Analyse..."
    }
  ]
}

Für weitere Informationen über das Antwortformat des erweiterten Denkens siehe die Messages API Referenz.

Wie man erweitertes Denken verwendet

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

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 16000,
    "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
    },
    "messages": [
        {
            "role": "user",
            "content": "Gibt es eine unendliche Anzahl von Primzahlen, sodass n mod 4 == 3?"
        }
    ]
}'

Um erweitertes Denken zu aktivieren, fügen Sie ein thinking Objekt hinzu, mit dem type Parameter auf enabled gesetzt und den budget_tokens auf ein spezifiziertes Token-Budget für erweitertes Denken.

Der budget_tokens Parameter bestimmt die maximale Anzahl von Tokens, die Claude für seinen internen Argumentationsprozess verwenden darf. In Claude 4 Modellen gilt dieses Limit für vollständige Denk-Tokens und 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 verwendet, insbesondere bei Bereichen über 32k.

budget_tokens muss auf einen Wert kleiner als max_tokens gesetzt werden. Wenn Sie jedoch verschachteltes Denken mit Tools verwenden, können Sie dieses Limit überschreiten, da das Token-Limit zu Ihrem gesamten Kontextfenster (200k Tokens) wird.

Zusammengefasstes Denken

Mit aktiviertem erweiterten Denken 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.

Hier sind einige wichtige Überlegungen für zusammengefasstes Denken:

Ihnen werden die vollständigen Denk-Tokens berechnet, die durch die ursprüngliche Anfrage generiert wurden, nicht die Zusammenfassungs-Tokens.
Die berechnete Ausgabe-Token-Anzahl wird nicht mit der Anzahl der Tokens übereinstimmen, die Sie in der Antwort sehen.
Die ersten paar Zeilen der Denk-Ausgabe sind ausführlicher und bieten detaillierte Argumentation, die besonders hilfreich für Prompt-Engineering-Zwecke ist.
Da Anthropic das erweiterte Denken-Feature verbessern möchte, kann sich das Zusammenfassungsverhalten ändern.
Die Zusammenfassung bewahrt die Schlüsselideen von Claudes Denkprozess mit minimaler zusätzlicher Latenz und ermöglicht eine streambare Benutzererfahrung und einfache Migration von Claude 3.7 Modellen zu Claude 4 Modellen.
Die Zusammenfassung wird von einem anderen Modell verarbeitet als dem, das Sie in Ihren Anfragen anvisieren. Das Denk-Modell sieht die zusammengefasste Ausgabe nicht.

Claude Sonnet 3.7 gibt weiterhin vollständige Denk-Ausgabe zurück.

In seltenen Fällen, in denen Sie Zugang zur vollständigen Denk-Ausgabe für Claude 4 Modelle benötigen, kontaktieren Sie unser Vertriebsteam.

Streaming-Denken

Sie können erweiterte Denk-Antworten mit Server-Sent Events (SSE) streamen.

Wenn Streaming für erweitertes Denken aktiviert ist, erhalten Sie Denk-Inhalte über thinking_delta Events.

Für weitere Dokumentation zum Streaming über die Messages API siehe Streaming Messages.

Hier ist, wie man Streaming mit Denken handhabt:

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 16000,
    "stream": true,
    "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
    },
    "messages": [
        {
            "role": "user",
            "content": "Was ist 27 * 453?"
        }
    ]
}'

Beispiel Streaming-Ausgabe:

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

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

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "Lass mich das Schritt für Schritt lösen:\n\n1. Zuerst zerlege ich 27 * 453"}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n2. 453 = 400 + 50 + 3"}}

// Zusätzliche Denk-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": "27 * 453 = 12.231"}}

// Zusätzliche 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 Sie Streaming mit aktiviertem Denken verwenden, bemerken Sie möglicherweise, dass Text manchmal in größeren Blöcken ankommt, die sich mit kleinerer, Token-für-Token-Lieferung abwechseln. Dies ist erwartetes Verhalten, insbesondere für Denk-Inhalte.

Das Streaming-System muss Inhalte in Stapeln für optimale Leistung verarbeiten, was zu diesem “klumpigen” Lieferungsmuster mit möglichen Verzögerungen zwischen Streaming-Events führen kann. Wir arbeiten kontinuierlich daran, diese Erfahrung zu verbessern, mit zukünftigen Updates, die darauf fokussiert sind, Denk-Inhalte flüssiger zu streamen.

Erweitertes Denken mit Tool-Verwendung

Erweitertes Denken kann zusammen mit Tool-Verwendung verwendet werden, wodurch Claude durch Tool-Auswahl und Ergebnisverarbeitung argumentieren kann.

Wenn Sie erweitertes Denken mit Tool-Verwendung verwenden, beachten Sie die folgenden Einschränkungen:

Tool-Auswahl-Einschränkung: Tool-Verwendung mit Denken unterstützt nur tool_choice: {"type": "auto"} (der 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 Tool-Verwendung erzwingen, was mit erweitertem Denken inkompatibel ist.
Bewahrung von Denk-Blöcken: Während der Tool-Verwendung müssen Sie thinking Blöcke an die API für die letzte Assistant-Nachricht zurückgeben. Fügen Sie den vollständigen unveränderten Block zurück zur API hinzu, um die Kontinuität der Argumentation aufrechtzuerhalten.

Beispiel: Übergabe von Denk-Blöcken mit Tool-Ergebnissen

Hier ist ein praktisches Beispiel, das zeigt, wie man thinking Blöcke bewahrt, wenn Tool-Ergebnisse bereitgestellt werden:

weather_tool = {
    "name": "get_weather",
    "description": "Aktuelles Wetter für einen Standort abrufen",
    "input_schema": {
        "type": "object",
        "properties": {
            "location": {"type": "string"}
        },
        "required": ["location"]
    }
}

# Erste Anfrage - Claude antwortet mit Denken und Tool-Anfrage
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "Wie ist das Wetter in Paris?"}
    ]
)

Die API-Antwort wird Denk-, Text- und Tool-Use-Blöcke enthalten:

{
    "content": [
        {
            "type": "thinking",
            "thinking": "Der Benutzer möchte das aktuelle Wetter in Paris wissen. Ich habe Zugang zu einer Funktion `get_weather`...",
            "signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxYsNrcs...."
        },
        {
            "type": "text",
            "text": "Ich kann Ihnen helfen, die aktuellen Wetterinformationen für Paris zu erhalten. Lassen Sie mich das für Sie überprüfen"
        },
        {
            "type": "tool_use",
            "id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
            "name": "get_weather",
            "input": {
                "location": "Paris"
            }
        }
    ]
}

Jetzt setzen wir die Unterhaltung fort und verwenden das Tool

# Denk-Block und Tool-Use-Block extrahieren
thinking_block = next((block for block in response.content
                      if block.type == 'thinking'), None)
tool_use_block = next((block for block in response.content
                      if block.type == 'tool_use'), None)

# Ihre tatsächliche Wetter-API aufrufen, hier wäre Ihr tatsächlicher API-Aufruf
# nehmen wir an, das bekommen wir zurück
weather_data = {"temperature": 88}

# Zweite Anfrage - Denk-Block und Tool-Ergebnis einschließen
# Keine neuen Denk-Blöcke werden in der Antwort generiert
continuation = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "Wie ist das Wetter in Paris?"},
        # beachten Sie, dass der thinking_block sowie der tool_use_block übergeben wird
        # wenn dies nicht übergeben wird, wird ein Fehler ausgelöst
        {"role": "assistant", "content": [thinking_block, tool_use_block]},
        {"role": "user", "content": [{
            "type": "tool_result",
            "tool_use_id": tool_use_block.id,
            "content": f"Aktuelle Temperatur: {weather_data['temperature']}°F"
        }]}
    ]
)

Die API-Antwort wird jetzt nur Text enthalten

{
    "content": [
        {
            "type": "text",
            "text": "Derzeit beträgt die Temperatur in Paris 88°F (31°C)"
        }
    ]
}

Bewahrung von Denk-Blöcken

Während der Tool-Verwendung müssen Sie thinking Blöcke an die API zurückgeben, und Sie müssen den vollständigen unveränderten Block zurück zur API einschließen. Dies ist entscheidend für die Aufrechterhaltung des Argumentationsflusses des Modells und der Gesprächsintegrität.

Während Sie thinking Blöcke aus vorherigen assistant Rollen-Turns weglassen können, empfehlen wir, immer alle Denk-Blöcke für jede mehrteilige Unterhaltung an die API zurückzugeben. Die API wird:

Automatisch die bereitgestellten Denk-Blöcke filtern
Die relevanten Denk-Blöcke verwenden, die notwendig sind, um die Argumentation des Modells zu bewahren
Nur für die Input-Tokens für die Blöcke berechnen, die Claude gezeigt werden

Wenn Claude Tools aufruft, pausiert es seine Konstruktion einer Antwort, um auf externe Informationen zu warten. Wenn Tool-Ergebnisse zurückgegeben werden, wird Claude weiterhin diese bestehende Antwort aufbauen. Dies macht die Bewahrung von Denk-Blöcken während der Tool-Verwendung aus ein paar Gründen notwendig:

Argumentationskontinuität: Die Denk-Blöcke erfassen Claudes schrittweise Argumentation, die zu Tool-Anfragen führte. Wenn Sie Tool-Ergebnisse posten, stellt das Einschließen des ursprünglichen Denkens sicher, dass Claude seine Argumentation von dort fortsetzen kann, wo es aufgehört hat.
Kontexterhaltung: Während Tool-Ergebnisse als Benutzer-Nachrichten in der API-Struktur erscheinen, sind sie Teil eines kontinuierlichen Argumentationsflusses. Die Bewahrung von Denk-Blöcken erhält diesen konzeptionellen Fluss über mehrere API-Aufrufe hinweg. Für weitere Informationen zum Kontextmanagement siehe unseren Leitfaden zu Kontextfenstern.

Wichtig: Wenn Sie thinking Blöcke bereitstellen, muss die gesamte Sequenz aufeinanderfolgender thinking Blöcke mit den Ausgaben übereinstimmen, die vom Modell während der ursprünglichen Anfrage generiert wurden; Sie können die Sequenz dieser Blöcke nicht neu anordnen oder modifizieren.

Verschachteltes Denken

Erweitertes Denken mit Tool-Verwendung in Claude 4 Modellen unterstützt verschachteltes Denken, das Claude ermöglicht, zwischen Tool-Aufrufen zu denken und nach dem Erhalt von Tool-Ergebnissen anspruchsvollere Argumentation zu machen.

Mit verschachteltem Denken kann Claude:

Über die Ergebnisse eines Tool-Aufrufs argumentieren, bevor es entscheidet, was als nächstes zu tun ist
Mehrere Tool-Aufrufe mit Argumentationsschritten dazwischen verketten
Nuanciertere Entscheidungen basierend auf Zwischenergebnissen treffen

Um verschachteltes Denken zu aktivieren, fügen Sie den Beta-Header interleaved-thinking-2025-05-14 zu Ihrer API-Anfrage hinzu.

Hier sind einige wichtige Überlegungen für verschachteltes Denken:

Mit verschachteltem Denken können die budget_tokens den max_tokens Parameter überschreiten, da es das Gesamtbudget über alle Denk-Blöcke innerhalb eines Assistant-Turns darstellt.
Verschachteltes Denken wird nur für Tools unterstützt, die über die Messages API verwendet werden.
Verschachteltes Denken wird nur für Claude 4 Modelle unterstützt, mit dem Beta-Header interleaved-thinking-2025-05-14.
Direkte Aufrufe an Anthropics API erlauben es Ihnen, interleaved-thinking-2025-05-14 in Anfragen an jedes Modell zu übergeben, ohne Wirkung.
Auf Drittanbieter-Plattformen (z.B. Amazon Bedrock und Vertex AI), wenn Sie interleaved-thinking-2025-05-14 an ein anderes Modell als Claude Opus 4 oder Sonnet 4 übergeben, wird Ihre Anfrage fehlschlagen.

Tool-Verwendung ohne verschachteltes Denken

import anthropic

client = anthropic.Anthropic()

# Tools definieren
calculator_tool = {
    "name": "calculator",
    "description": "Mathematische Berechnungen durchführen",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Mathematischer Ausdruck zum Auswerten"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Produktdatenbank abfragen",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "SQL-Abfrage zum Ausführen"
            }
        },
        "required": ["query"]
    }
}

# Erste Anfrage - Claude denkt einmal vor allen Tool-Aufrufen
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    messages=[{
        "role": "user",
        "content": "Was ist der Gesamtumsatz, wenn wir 150 Einheiten von Produkt A zu je 50$ verkauft haben, und wie vergleicht sich das mit unserem durchschnittlichen monatlichen Umsatz aus der Datenbank?"
    }]
)

# Antwort enthält Denken gefolgt von Tool-Verwendungen
# Hinweis: Claude denkt einmal am Anfang, dann trifft alle Tool-Entscheidungen
print("Erste Antwort:")
for block in response.content:
    if block.type == "thinking":
        print(f"Denken (zusammengefasst): {block.thinking}")
    elif block.type == "tool_use":
        print(f"Tool-Verwendung: {block.name} mit Input {block.input}")
    elif block.type == "text":
        print(f"Text: {block.text}")

# Sie würden die Tools ausführen und Ergebnisse zurückgeben...
# Nach dem Zurückbekommen beider Tool-Ergebnisse antwortet Claude direkt ohne zusätzliches Denken

In diesem Beispiel ohne verschachteltes Denken:

Claude denkt einmal am Anfang, um die Aufgabe zu verstehen
Trifft alle Tool-Verwendungsentscheidungen im Voraus
Wenn Tool-Ergebnisse zurückgegeben werden, liefert Claude sofort eine Antwort ohne zusätzliches Denken

Tool-Verwendung mit verschachteltem Denken

import anthropic

client = anthropic.Anthropic()

# Gleiche Tool-Definitionen wie zuvor
calculator_tool = {
    "name": "calculator",
    "description": "Mathematische Berechnungen durchführen",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Mathematischer Ausdruck zum Auswerten"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Produktdatenbank abfragen",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "SQL-Abfrage zum Ausführen"
            }
        },
        "required": ["query"]
    }
}

# Erste Anfrage mit aktiviertem verschachtelten Denken
response = client.beta.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    betas=["interleaved-thinking-2025-05-14"],
    messages=[{
        "role": "user",
        "content": "Was ist der Gesamtumsatz, wenn wir 150 Einheiten von Produkt A zu je 50$ verkauft haben, und wie vergleicht sich das mit unserem durchschnittlichen monatlichen Umsatz aus der Datenbank?"
    }]
)

print("Erste Antwort:")
thinking_blocks = []
tool_use_blocks = []

for block in response.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Denken: {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Tool-Verwendung: {block.name} mit Input {block.input}")
    elif block.type == "text":
        print(f"Text: {block.text}")

# Erstes Tool-Ergebnis (Rechner)
calculator_result = "7500"  # 150 * 50

# Mit erstem Tool-Ergebnis fortfahren
response2 = client.beta.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    betas=["interleaved-thinking-2025-05-14"],
    messages=[
        {
            "role": "user",
            "content": "Was ist der Gesamtumsatz, wenn wir 150 Einheiten von Produkt A zu je 50$ verkauft haben, und wie vergleicht sich das mit unserem durchschnittlichen monatlichen Umsatz aus der Datenbank?"
        },
        {
            "role": "assistant",
            "content": [thinking_blocks[0], tool_use_blocks[0]]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[0].id,
                "content": calculator_result
            }]
        }
    ]
)

print("\nNach Rechner-Ergebnis:")
# Mit verschachteltem Denken kann Claude über das Rechner-Ergebnis nachdenken
# bevor es entscheidet, die Datenbank abzufragen
for block in response2.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Verschachteltes Denken: {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Tool-Verwendung: {block.name} mit Input {block.input}")

# Zweites Tool-Ergebnis (Datenbank)
database_result = "5200"  # Beispiel durchschnittlicher monatlicher Umsatz

# Mit zweitem Tool-Ergebnis fortfahren
response3 = client.beta.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    betas=["interleaved-thinking-2025-05-14"],
    messages=[
        {
            "role": "user",
            "content": "Was ist der Gesamtumsatz, wenn wir 150 Einheiten von Produkt A zu je 50$ verkauft haben, und wie vergleicht sich das mit unserem durchschnittlichen monatlichen Umsatz aus der Datenbank?"
        },
        {
            "role": "assistant",
            "content": [thinking_blocks[0], tool_use_blocks[0]]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[0].id,
                "content": calculator_result
            }]
        },
        {
            "role": "assistant",
            "content": thinking_blocks[1:] + tool_use_blocks[1:]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[1].id,
                "content": database_result
            }]
        }
    ]
)

print("\nNach Datenbank-Ergebnis:")
# Mit verschachteltem Denken kann Claude über beide Ergebnisse nachdenken
# bevor es die endgültige Antwort formuliert
for block in response3.content:
    if block.type == "thinking":
        print(f"Finales Denken: {block.thinking}")
    elif block.type == "text":
        print(f"Finale Antwort: {block.text}")

In diesem Beispiel mit verschachteltem Denken:

Claude denkt zunächst über die Aufgabe nach
Nach dem Erhalt des Rechner-Ergebnisses kann Claude erneut darüber nachdenken, was dieses Ergebnis bedeutet
Claude entscheidet dann, wie die Datenbank basierend auf dem ersten Ergebnis abgefragt werden soll
Nach dem Erhalt des Datenbank-Ergebnisses denkt Claude noch einmal über beide Ergebnisse nach, bevor es eine endgültige Antwort formuliert
Das Denk-Budget wird über alle Denk-Blöcke innerhalb des Turns verteilt

Dieses Muster ermöglicht anspruchsvollere Argumentationsketten, bei denen die Ausgabe jedes Tools die nächste Entscheidung informiert.

Erweitertes Denken mit Prompt-Caching

Prompt-Caching mit Denken hat mehrere wichtige Überlegungen:

Erweiterte Denk-Aufgaben dauern oft länger als 5 Minuten. Erwägen Sie die Verwendung der 1-Stunden-Cache-Dauer, um Cache-Treffer über längere Denk-Sitzungen und mehrstufige Workflows aufrechtzuerhalten.

Entfernung von Denk-Block-Kontext

Denk-Blöcke aus vorherigen Turns werden aus dem Kontext entfernt, was Cache-Breakpoints beeinflussen kann
Beim Fortsetzen von Unterhaltungen mit Tool-Verwendung werden Denk-Blöcke gecacht und zählen als Input-Tokens, wenn sie aus dem Cache gelesen werden
Dies schafft einen Kompromiss: Während Denk-Blöcke visuell keinen Kontextfenster-Platz verbrauchen, zählen sie dennoch zu Ihrer Input-Token-Nutzung, wenn sie gecacht sind
Wenn Denken deaktiviert wird, schlagen Anfragen fehl, wenn Sie Denk-Inhalte im aktuellen Tool-Verwendungs-Turn übergeben. In anderen Kontexten werden Denk-Inhalte, die an die API übergeben werden, einfach ignoriert

Cache-Invalidierungsmuster

Änderungen an Denk-Parametern (aktiviert/deaktiviert oder Budget-Zuteilung) invalidieren Nachrichten-Cache-Breakpoints
Verschachteltes Denken verstärkt die Cache-Invalidierung, da Denk-Blöcke zwischen mehreren Tool-Aufrufen auftreten können
System-Prompts und Tools bleiben trotz Änderungen der Denk-Parameter oder Block-Entfernung gecacht

Während Denk-Blöcke für Caching und Kontext-Berechnungen entfernt werden, müssen sie beim Fortsetzen von Unterhaltungen mit Tool-Verwendung, insbesondere mit verschachteltem Denken, bewahrt werden.

Verstehen des Denk-Block-Caching-Verhaltens

Bei der Verwendung von erweitertem Denken mit Tool-Verwendung zeigen Denk-Blöcke spezifisches Caching-Verhalten, das die Token-Zählung beeinflusst:

Wie es funktioniert:

Caching tritt nur auf, wenn Sie eine nachfolgende Anfrage stellen, die Tool-Ergebnisse enthält
Wenn die nachfolgende Anfrage gestellt wird, kann der vorherige Unterhaltungsverlauf (einschließlich Denk-Blöcke) gecacht werden
Diese gecachten Denk-Blöcke zählen als Input-Tokens in Ihren Nutzungsmetriken, wenn sie aus dem Cache gelesen werden
Wenn ein Nicht-Tool-Ergebnis-Benutzer-Block enthalten ist, werden alle vorherigen Denk-Blöcke ignoriert und aus dem Kontext entfernt

Detaillierter Beispiel-Ablauf:

Anfrage 1:

Benutzer: "Wie ist das Wetter in Paris?"

Antwort 1:

[thinking_block_1] + [tool_use block 1]

Anfrage 2:

Benutzer: ["Wie ist das Wetter in Paris?"], 
Assistant: [thinking_block_1] + [tool_use block 1], 
Benutzer: [tool_result_1, cache=True]

Antwort 2:

[thinking_block_2] + [text block 2]

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

Anfrage 3:

Benutzer: ["Wie ist das Wetter in Paris?"], 
Assistant: [thinking_block_1] + [tool_use block 1], 
Benutzer: [tool_result_1, cache=True], 
Assistant: [thinking_block_2] + [text block 2], 
Benutzer: [Text-Antwort, cache=True]

Da ein Nicht-Tool-Ergebnis-Benutzer-Block enthalten war, werden alle vorherigen Denk-Blöcke ignoriert. Diese Anfrage wird genauso verarbeitet wie:

Benutzer: ["Wie ist das Wetter in Paris?"], 
Assistant: [tool_use block 1], 
Benutzer: [tool_result_1, cache=True], 
Assistant: [text block 2], 
Benutzer: [Text-Antwort, cache=True]

Wichtige Punkte:

Dieses Caching-Verhalten geschieht automatisch, auch ohne explizite cache_control Markierungen
Dieses Verhalten ist konsistent, ob Sie reguläres Denken oder verschachteltes Denken verwenden

System-Prompt-Caching (bewahrt, wenn sich Denken ändert)

from anthropic import Anthropic
import requests
from bs4 import BeautifulSoup

client = Anthropic()

def fetch_article_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    # Script- und Style-Elemente entfernen
    for script in soup(["script", "style"]):
        script.decompose()

    # Text abrufen
    text = soup.get_text()

    # In Zeilen aufteilen und führende und nachfolgende Leerzeichen in jeder entfernen
    lines = (line.strip() for line in text.splitlines())
    # Multi-Headlines in eine Zeile pro Phrase aufteilen
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Leere Zeilen entfernen
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Den Inhalt des Artikels abrufen
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Nur genug Text für Caching verwenden (erste paar Kapitel)
LARGE_TEXT = book_content[:5000]

SYSTEM_PROMPT=[
    {
        "type": "text",
        "text": "Sie sind ein KI-Assistent, der mit literarischer Analyse beauftragt ist. Analysieren Sie den folgenden Text sorgfältig.",
    },
    {
        "type": "text",
        "text": LARGE_TEXT,
        "cache_control": {"type": "ephemeral"}
    }
]

MESSAGES = [
    {
        "role": "user",
        "content": "Analysieren Sie den Ton dieser Passage."
    }
]

# Erste Anfrage - Cache etablieren
print("Erste Anfrage - Cache etablieren")
response1 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    system=SYSTEM_PROMPT,
    messages=MESSAGES
)

print(f"Erste Antwort-Nutzung: {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analysieren Sie die Charaktere in dieser Passage."
})
# Zweite Anfrage - gleiche Denk-Parameter (Cache-Treffer erwartet)
print("\nZweite Anfrage - gleiche Denk-Parameter (Cache-Treffer erwartet)")
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    system=SYSTEM_PROMPT,
    messages=MESSAGES
)

print(f"Zweite Antwort-Nutzung: {response2.usage}")

# Dritte Anfrage - andere Denk-Parameter (Cache-Miss für Nachrichten)
print("\nDritte Anfrage - andere Denk-Parameter (Cache-Miss für Nachrichten)")
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Geändertes Denk-Budget
    },
    system=SYSTEM_PROMPT,  # System-Prompt bleibt gecacht
    messages=MESSAGES  # Nachrichten-Cache wird invalidiert
)

print(f"Dritte Antwort-Nutzung: {response3.usage}")

Nachrichten-Caching (invalidiert, wenn sich Denken ändert)

from anthropic import Anthropic
import requests
from bs4 import BeautifulSoup

client = Anthropic()

def fetch_article_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    # Script- und Style-Elemente entfernen
    for script in soup(["script", "style"]):
        script.decompose()

    # Text abrufen
    text = soup.get_text()

    # In Zeilen aufteilen und führende und nachfolgende Leerzeichen in jeder entfernen
    lines = (line.strip() for line in text.splitlines())
    # Multi-Headlines in eine Zeile pro Phrase aufteilen
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Leere Zeilen entfernen
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Den Inhalt des Artikels abrufen
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Nur genug Text für Caching verwenden (erste paar Kapitel)
LARGE_TEXT = book_content[:5000]

# Kein System-Prompt - stattdessen Caching in Nachrichten
MESSAGES = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": LARGE_TEXT,
                "cache_control": {"type": "ephemeral"},
            },
            {
                "type": "text",
                "text": "Analysieren Sie den Ton dieser Passage."
            }
        ]
    }
]

# Erste Anfrage - Cache etablieren
print("Erste Anfrage - Cache etablieren")
response1 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    messages=MESSAGES
)

print(f"Erste Antwort-Nutzung: {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analysieren Sie die Charaktere in dieser Passage."
})
# Zweite Anfrage - gleiche Denk-Parameter (Cache-Treffer erwartet)
print("\nZweite Anfrage - gleiche Denk-Parameter (Cache-Treffer erwartet)")
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000  # Gleiches Denk-Budget
    },
    messages=MESSAGES
)

print(f"Zweite Antwort-Nutzung: {response2.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response2.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analysieren Sie die Umgebung in dieser Passage."
})

# Dritte Anfrage - anderes Denk-Budget (Cache-Miss erwartet)
print("\nDritte Anfrage - anderes Denk-Budget (Cache-Miss erwartet)")
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Anderes Denk-Budget bricht Cache
    },
    messages=MESSAGES
)

print(f"Dritte Antwort-Nutzung: {response3.usage}")

Hier ist die Ausgabe des Skripts (Sie können leicht unterschiedliche Zahlen sehen)

Erste Anfrage - Cache etablieren
Erste Antwort-Nutzung: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 17, output_tokens: 700 }

Zweite Anfrage - gleiche Denk-Parameter (Cache-Treffer erwartet)

Zweite Antwort-Nutzung: { cache_creation_input_tokens: 0, cache_read_input_tokens: 1370, input_tokens: 303, output_tokens: 874 }

Dritte Anfrage - anderes Denk-Budget (Cache-Miss erwartet)
Dritte Antwort-Nutzung: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 747, output_tokens: 619 }

Dieses Beispiel zeigt, dass wenn Caching im Nachrichten-Array eingerichtet ist, das Ändern der Denk-Parameter (budget_tokens von 4000 auf 8000 erhöht) den Cache invalidiert. Die dritte Anfrage zeigt keinen Cache-Treffer mit cache_creation_input_tokens=1370 und cache_read_input_tokens=0, was beweist, dass nachrichten-basiertes Caching invalidiert wird, wenn sich Denk-Parameter ändern.

Max Tokens und Kontextfenstergröße mit erweitertem Denken

In älteren Claude-Modellen (vor Claude Sonnet 3.7), wenn die Summe aus Prompt-Tokens und max_tokens das Kontextfenster des Modells überschritt, passte das System automatisch max_tokens an, um in das Kontextlimit zu passen. Das bedeutete, Sie konnten einen großen max_tokens Wert setzen und das System würde ihn bei Bedarf stillschweigend reduzieren.

Mit Claude 3.7 und 4 Modellen wird max_tokens (was Ihr Denk-Budget einschließt, wenn Denken aktiviert ist) als striktes Limit durchgesetzt. Das System wird jetzt einen Validierungsfehler zurückgeben, wenn Prompt-Tokens + max_tokens die Kontextfenstergröße überschreitet.

Sie können unseren Leitfaden zu Kontextfenstern für eine gründlichere Vertiefung lesen.

Das Kontextfenster mit erweitertem Denken

Bei der Berechnung der Kontextfenster-Nutzung mit aktiviertem Denken gibt es einige Überlegungen zu beachten:

Denk-Blöcke aus vorherigen Turns werden entfernt und nicht zu Ihrem Kontextfenster gezählt
Aktueller Turn-Denken zählt zu Ihrem max_tokens Limit für diesen Turn

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

Das effektive Kontextfenster wird berechnet als:

Kontextfenster =
  (aktuelle Input-Tokens - vorherige Denk-Tokens) +
  (Denk-Tokens + verschlüsselte Denk-Tokens + Text-Ausgabe-Tokens)

Wir empfehlen die Verwendung der Token-Zähl-API, um genaue Token-Zählungen für Ihren spezifischen Anwendungsfall zu erhalten, insbesondere bei der Arbeit mit mehrteiligen Unterhaltungen, die Denken einschließen.

Das Kontextfenster mit erweitertem Denken und Tool-Verwendung

Bei der Verwendung von erweitertem Denken mit Tool-Verwendung müssen Denk-Blöcke explizit bewahrt und mit den Tool-Ergebnissen zurückgegeben werden.

Die effektive Kontextfenster-Berechnung für erweitertes Denken mit Tool-Verwendung wird zu:

Kontextfenster =
  (aktuelle Input-Tokens + vorherige Denk-Tokens + Tool-Use-Tokens) +
  (Denk-Tokens + verschlüsselte Denk-Tokens + Text-Ausgabe-Tokens)

Das Diagramm unten illustriert Token-Management für erweitertes Denken mit Tool-Verwendung:

Token-Management mit erweitertem Denken

Angesichts des Kontextfenster- und max_tokens Verhaltens mit erweiterten Denken Claude 3.7 und 4 Modellen müssen Sie möglicherweise:

Ihre Token-Nutzung aktiver überwachen und verwalten
max_tokens Werte anpassen, wenn sich Ihre Prompt-Länge ändert
Möglicherweise die Token-Zähl-Endpunkte häufiger verwenden
Sich bewusst sein, dass sich vorherige Denk-Blöcke nicht in Ihrem Kontextfenster ansammeln

Diese Änderung wurde vorgenommen, um vorhersagbareres und transparenteres Verhalten zu bieten, insbesondere da die maximalen Token-Limits erheblich gestiegen sind.

Denk-Verschlüsselung

Vollständiger Denk-Inhalt wird verschlüsselt und im signature Feld zurückgegeben. Dieses Feld wird verwendet, um zu verifizieren, dass Denk-Blöcke von Claude generiert wurden, wenn sie an die API zurückgegeben werden.

Es ist nur strikt notwendig, Denk-Blöcke zurückzusenden, wenn Sie Tools mit erweitertem Denken verwenden. Andernfalls können Sie Denk-Blöcke aus vorherigen Turns weglassen oder die API sie für Sie entfernen lassen, wenn Sie sie zurückgeben.

Wenn Sie Denk-Blöcke zurücksenden, empfehlen wir, alles so zurückzugeben, wie Sie es erhalten haben, für Konsistenz und um potenzielle Probleme zu vermeiden.

Hier sind einige wichtige Überlegungen zur Denk-Verschlüsselung:

Beim Streaming von Antworten wird die Signatur über ein signature_delta innerhalb eines content_block_delta Events kurz vor dem content_block_stop Event hinzugefügt.
signature Werte sind in Claude 4 erheblich länger als in vorherigen Modellen.
Das signature Feld ist ein undurchsichtiges Feld und sollte nicht interpretiert oder geparst werden - es existiert ausschließlich für Verifikationszwecke.
signature Werte sind plattformübergreifend kompatibel (Anthropic APIs, Amazon Bedrock und Vertex AI). Werte, die auf einer Plattform generiert wurden, sind mit einer anderen kompatibel.

Denk-Redaktion

Gelegentlich wird Claudes interne Argumentation von unseren Sicherheitssystemen markiert. Wenn dies auftritt, verschlüsseln wir einen Teil oder den gesamten thinking Block und geben ihn als redacted_thinking Block an Sie zurück. redacted_thinking Blöcke werden entschlüsselt, wenn sie an die API zurückgegeben werden, wodurch Claude seine Antwort fortsetzen kann, ohne Kontext zu verlieren.

Beim Erstellen kundenorientierter Anwendungen, die erweitertes Denken verwenden:

Seien Sie sich bewusst, dass redigierte Denk-Blöcke verschlüsselten Inhalt enthalten, der nicht menschenlesbar ist
Erwägen Sie eine einfache Erklärung wie: “Ein Teil von Claudes interner Argumentation wurde aus Sicherheitsgründen automatisch verschlüsselt. Dies beeinträchtigt nicht die Qualität der Antworten.”
Wenn Sie Denk-Blöcke Benutzern zeigen, können Sie redigierte Blöcke herausfiltern, während Sie normale Denk-Blöcke beibehalten
Seien Sie transparent, dass die Verwendung erweiterter Denk-Features gelegentlich dazu führen kann, dass einige Argumentationen verschlüsselt werden
Implementieren Sie angemessene Fehlerbehandlung, um redigiertes Denken elegant zu verwalten, ohne Ihre Benutzeroberfläche zu beschädigen

Hier ist ein Beispiel, das sowohl normale als auch redigierte Denk-Blöcke zeigt:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Lass mich das Schritt für Schritt analysieren...",
      "signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
    },
    {
      "type": "redacted_thinking",
      "data": "EmwKAhgBEgy3va3pzix/LafPsn4aDFIT2Xlxh0L5L8rLVyIwxtE3rAFBa8cr3qpPkNRj2YfWXGmKDxH4mPnZ5sQ7vB9URj2pLmN3kF8/dW5hR7xJ0aP1oLs9yTcMnKVf2wRpEGjH9XZaBt4UvDcPrQ..."
    },
    {
      "type": "text",
      "text": "Basierend auf meiner Analyse..."
    }
  ]
}

Das Sehen von redigierten Denk-Blöcken in Ihrer Ausgabe ist erwartetes Verhalten. Das Modell kann diese redigierte Argumentation immer noch verwenden, um seine Antworten zu informieren, während Sicherheitsleitplanken aufrechterhalten werden.

Wenn Sie das Handling von redigiertem Denken in Ihrer Anwendung testen müssen, können Sie diesen speziellen Test-String als Ihren Prompt verwenden: ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB

Beim Zurückgeben von thinking und redacted_thinking Blöcken an die API in einer mehrteiligen Unterhaltung müssen Sie den vollständigen unveränderten Block für den letzten Assistant-Turn zurück zur API einschließen. Dies ist entscheidend für die Aufrechterhaltung des Argumentationsflusses des Modells. Wir empfehlen, immer alle Denk-Blöcke an die API zurückzugeben. Für weitere Details siehe den Abschnitt Bewahrung von Denk-Blöcken oben.

Beispiel: Arbeiten mit redigierten Denk-Blöcken

Dieses Beispiel zeigt, wie man mit redacted_thinking Blöcken umgeht, die in Antworten erscheinen können, wenn Claudes interne Argumentation Inhalte enthält, die von Sicherheitssystemen markiert wurden:

import anthropic

client = anthropic.Anthropic()

# Verwendung eines speziellen Prompts, der redigiertes Denken auslöst (nur zu Demonstrationszwecken)
response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    messages=[{
        "role": "user",
        "content": "ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB"
    }]
)

# Redigierte Denk-Blöcke identifizieren
has_redacted_thinking = any(
    block.type == "redacted_thinking" for block in response.content
)

if has_redacted_thinking:
    print("Antwort enthält redigierte Denk-Blöcke")
    # Diese Blöcke sind in nachfolgenden Anfragen immer noch verwendbar

    # Alle Blöcke extrahieren (sowohl redigierte als auch nicht-redigierte)
    all_thinking_blocks = [
        block for block in response.content
        if block.type in ["thinking", "redacted_thinking"]
    ]

    # Beim Übergeben an nachfolgende Anfragen alle Blöcke ohne Änderung einschließen
    # Dies bewahrt die Integrität von Claudes Argumentation

    print(f"Gefunden {len(all_thinking_blocks)} Denk-Blöcke insgesamt")
    print(f"Diese Blöcke sind immer noch als Ausgabe-Tokens abrechenbar")

Unterschiede im Denken zwischen Modellversionen

Die Messages API behandelt Denken unterschiedlich zwischen Claude Sonnet 3.7 und Claude 4 Modellen, hauptsächlich in Redaktions- und Zusammenfassungsverhalten.

Siehe die Tabelle unten für einen komprimierten Vergleich:

Feature	Claude Sonnet 3.7	Claude 4 Modelle
Denk-Ausgabe	Gibt vollständige Denk-Ausgabe zurück	Gibt zusammengefasste Denk-Ausgabe zurück
Verschachteltes Denken	Nicht unterstützt	Unterstützt mit `interleaved-thinking-2025-05-14` Beta-Header

Preisgestaltung

Erweitertes Denken verwendet das Standard-Token-Preisschema:

Modell	Basis Input Tokens	Cache Writes	Cache Hits	Output Tokens
Claude Opus 4	$15 / MTok	$18.75 / MTok	$1.50 / MTok	$75 / MTok
Claude Sonnet 4	$3 / MTok	$3.75 / MTok	$0.30 / MTok	$15 / MTok
Claude Sonnet 3.7	$3 / MTok	$3.75 / MTok	$0.30 / MTok	$15 / MTok

Der Denk-Prozess verursacht Kosten für:

Tokens, die während des Denkens verwendet werden (Ausgabe-Tokens)
Denk-Blöcke vom letzten Assistant-Turn, die in nachfolgenden Anfragen enthalten sind (Input-Tokens)
Standard-Text-Ausgabe-Tokens

Wenn erweitertes Denken aktiviert ist, wird automatisch ein spezialisierter System-Prompt eingeschlossen, um diese Funktion zu unterstützen.

Bei der Verwendung von zusammengefasstem Denken:

Input-Tokens: Tokens in Ihrer ursprünglichen Anfrage (schließt Denk-Tokens aus vorherigen Turns aus)
Output-Tokens (abgerechnet): Die ursprünglichen Denk-Tokens, die Claude intern generiert hat
Output-Tokens (sichtbar): Die zusammengefassten Denk-Tokens, die Sie in der Antwort sehen
Keine Gebühr: Tokens, die zur Generierung der Zusammenfassung verwendet werden

Die abgerechnete Ausgabe-Token-Anzahl wird nicht mit der sichtbaren Token-Anzahl in der Antwort übereinstimmen. Ihnen wird der vollständige Denk-Prozess berechnet, nicht die Zusammenfassung, die Sie sehen.

Best Practices und Überlegungen für erweitertes Denken

Arbeiten mit Denk-Budgets

Budget-Optimierung: Das Mindestbudget beträgt 1.024 Tokens. Wir empfehlen, beim Minimum zu beginnen und das Denk-Budget schrittweise zu erhöhen, um den optimalen Bereich für Ihren Anwendungsfall zu finden. Höhere Token-Zählungen ermöglichen umfassendere Argumentation, aber mit abnehmenden Erträgen je nach Aufgabe. Die Erhöhung des Budgets kann die Antwortqualität auf Kosten erhöhter Latenz verbessern. Für kritische Aufgaben testen Sie verschiedene Einstellungen, um das optimale Gleichgewicht zu finden. Beachten Sie, dass das Denk-Budget eher ein Ziel als ein striktes Limit ist - die tatsächliche Token-Nutzung kann je nach Aufgabe variieren.
Ausgangspunkte: Beginnen Sie mit größeren Denk-Budgets (16k+ Tokens) für komplexe Aufgaben und passen Sie basierend auf Ihren Bedürfnissen an.
Große Budgets: Für Denk-Budgets über 32k empfehlen wir die Verwendung von Batch-Verarbeitung, um Netzwerkprobleme zu vermeiden. Anfragen, die das Modell dazu bringen, über 32k Tokens zu denken, verursachen lang laufende Anfragen, die gegen System-Timeouts und offene Verbindungslimits stoßen könnten.
Token-Nutzungsverfolgung: Überwachen Sie die Denk-Token-Nutzung, um Kosten und Leistung zu optimieren.

Leistungsüberlegungen

Antwortzeiten: Seien Sie auf potenziell längere Antwortzeiten aufgrund der zusätzlichen Verarbeitung vorbereitet, die für den Argumentationsprozess erforderlich ist. Berücksichtigen Sie, dass die Generierung von Denk-Blöcken die Gesamtantwortzeit erhöhen kann.
Streaming-Anforderungen: Streaming ist erforderlich, wenn max_tokens größer als 21.333 ist. Beim Streaming seien Sie darauf vorbereitet, sowohl Denk- als auch Text-Inhaltsblöcke zu handhaben, wenn sie ankommen.

Feature-Kompatibilität

Denken ist nicht kompatibel mit temperature oder top_k Modifikationen sowie erzwungener Tool-Verwendung.
Wenn Denken aktiviert ist, können Sie top_p auf Werte zwischen 1 und 0,95 setzen.
Sie können Antworten nicht vorab ausfüllen, wenn Denken aktiviert ist.
Änderungen am Denk-Budget invalidieren gecachte Prompt-Präfixe, die Nachrichten enthalten. Gecachte System-Prompts und Tool-Definitionen funktionieren jedoch weiterhin, wenn sich Denk-Parameter ändern.

Nutzungsrichtlinien

Aufgabenauswahl: Verwenden Sie erweitertes Denken für besonders komplexe Aufgaben, die von schrittweiser Argumentation profitieren, wie Mathematik, Programmierung und Analyse.
Kontextbehandlung: Sie müssen vorherige Denk-Blöcke nicht selbst entfernen. Die Anthropic API ignoriert automatisch Denk-Blöcke aus vorherigen Turns und sie werden nicht bei der Berechnung der Kontextnutzung einbezogen.
Prompt-Engineering: Überprüfen Sie unsere erweiterten Denk-Prompting-Tipps, wenn Sie Claudes Denk-Fähigkeiten maximieren möchten.

Nächste Schritte

Probieren Sie das erweiterte Denk-Kochbuch aus

Erkunden Sie praktische Beispiele des Denkens in unserem Kochbuch.

Erweiterte Denk-Prompting-Tipps

Lernen Sie Prompt-Engineering-Best-Practices für erweitertes Denken.

Prompt-Caching Streaming von Nachrichten

On this page

Unterstützte Modelle
Wie erweitertes Denken funktioniert
Wie man erweitertes Denken verwendet
Zusammengefasstes Denken
Streaming-Denken
Erweitertes Denken mit Tool-Verwendung
Bewahrung von Denk-Blöcken
Verschachteltes Denken
Erweitertes Denken mit Prompt-Caching
Verstehen des Denk-Block-Caching-Verhaltens
Max Tokens und Kontextfenstergröße mit erweitertem Denken
Das Kontextfenster mit erweitertem Denken
Das Kontextfenster mit erweitertem Denken und Tool-Verwendung
Token-Management mit erweitertem Denken
Denk-Verschlüsselung
Denk-Redaktion
Unterschiede im Denken zwischen Modellversionen
Preisgestaltung
Best Practices und Überlegungen für erweitertes Denken
Arbeiten mit Denk-Budgets
Leistungsüberlegungen
Feature-Kompatibilität
Nutzungsrichtlinien
Nächste Schritte

Erste Schritte

Modelle & Preise

Erfahren Sie mehr über Claude

Funktionen

Werkzeuge

Model Context Protocol (MCP)

Anwendungsfälle

Prompt Engineering

Testen & bewerten

Schutzmaßnahmen verstärken

Rechtszentrum

Entwickeln mit erweitertem Denken

Unterstützte Modelle

Wie erweitertes Denken funktioniert

Wie man erweitertes Denken verwendet

Zusammengefasstes Denken

Streaming-Denken

Erweitertes Denken mit Tool-Verwendung

Bewahrung von Denk-Blöcken

Verschachteltes Denken

Erweitertes Denken mit Prompt-Caching

Verstehen des Denk-Block-Caching-Verhaltens

Max Tokens und Kontextfenstergröße mit erweitertem Denken

Das Kontextfenster mit erweitertem Denken

Das Kontextfenster mit erweitertem Denken und Tool-Verwendung

Token-Management mit erweitertem Denken

Denk-Verschlüsselung

Denk-Redaktion

Unterschiede im Denken zwischen Modellversionen

Preisgestaltung

Best Practices und Überlegungen für erweitertes Denken

Arbeiten mit Denk-Budgets

Leistungsüberlegungen

Feature-Kompatibilität

Nutzungsrichtlinien

Nächste Schritte

Probieren Sie das erweiterte Denk-Kochbuch aus

Erweiterte Denk-Prompting-Tipps

Erste Schritte

Modelle & Preise

Erfahren Sie mehr über Claude

Funktionen

Werkzeuge

Model Context Protocol (MCP)

Anwendungsfälle

Prompt Engineering

Testen & bewerten

Schutzmaßnahmen verstärken

Rechtszentrum

​Unterstützte Modelle

​Wie erweitertes Denken funktioniert

​Wie man erweitertes Denken verwendet

​Zusammengefasstes Denken

​Streaming-Denken

​Erweitertes Denken mit Tool-Verwendung

​Bewahrung von Denk-Blöcken

​Verschachteltes Denken

​Erweitertes Denken mit Prompt-Caching

​Verstehen des Denk-Block-Caching-Verhaltens

​Max Tokens und Kontextfenstergröße mit erweitertem Denken

​Das Kontextfenster mit erweitertem Denken

​Das Kontextfenster mit erweitertem Denken und Tool-Verwendung

​Token-Management mit erweitertem Denken

​Denk-Verschlüsselung

​Denk-Redaktion

​Unterschiede im Denken zwischen Modellversionen

​Preisgestaltung

​Best Practices und Überlegungen für erweitertes Denken

​Arbeiten mit Denk-Budgets

​Leistungsüberlegungen

​Feature-Kompatibilität

​Nutzungsrichtlinien

​Nächste Schritte

Probieren Sie das erweiterte Denk-Kochbuch aus

Erweiterte Denk-Prompting-Tipps

Unterstützte Modelle

Wie erweitertes Denken funktioniert

Wie man erweitertes Denken verwendet

Zusammengefasstes Denken

Streaming-Denken

Erweitertes Denken mit Tool-Verwendung

Bewahrung von Denk-Blöcken

Verschachteltes Denken

Erweitertes Denken mit Prompt-Caching

Verstehen des Denk-Block-Caching-Verhaltens

Max Tokens und Kontextfenstergröße mit erweitertem Denken

Das Kontextfenster mit erweitertem Denken

Das Kontextfenster mit erweitertem Denken und Tool-Verwendung

Token-Management mit erweitertem Denken

Denk-Verschlüsselung

Denk-Redaktion

Unterschiede im Denken zwischen Modellversionen

Preisgestaltung

Best Practices und Überlegungen für erweitertes Denken

Arbeiten mit Denk-Budgets

Leistungsüberlegungen

Feature-Kompatibilität

Nutzungsrichtlinien

Nächste Schritte