Entwickeln mit erweitertem Denken

Erweitertes Denken verleiht Claude verbesserte Denkfähigkeiten für komplexe Aufgaben und bietet dabei unterschiedliche Transparenzgrade 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.1 (claude-opus-4-1-20250805)
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 Sonnet 3.7 und Claude 4 Modellen, aber die API-Strukturen bleiben exakt 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 formuliert.

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

Hier ist ein Beispiel des Standard-Antwortformats:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Lassen Sie 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 von erweitertem Denken 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 unendlich viele 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 dem 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 Denkprozess 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, besonders 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 Sonnet 3.7 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 Verkaufsteam.

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 Sie Streaming mit Denken handhaben:

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?"
        }
    ]
}'

In Konsole testen

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": "Lassen Sie 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, besonders für Denk-Inhalte.

Das Streaming-System muss Inhalte in Batches verarbeiten für optimale Leistung, was zu diesem “klumpigen” Lieferungsmuster führen kann, mit möglichen Verzögerungen zwischen Streaming-Events. 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 Denkblöcken: Während der Tool-Verwendung müssen Sie thinking Blöcke an die API für die letzte Assistenten-Nachricht zurückgeben. Schließen Sie den vollständigen unveränderten Block zurück an die API ein, um die Kontinuität der Argumentation zu erhalten.

Beispiel: Übergabe von Denkblö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 Ort 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 Denken, 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

# Denkblock und Tool-Verwendungsblock 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 - Denkblock und Tool-Ergebnis einschließen
# Keine neuen Denkblö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 Denkblö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 an die API einschließen. Dies ist kritisch für die Aufrechterhaltung des Argumentationsflusses des Modells und der Unterhaltungsintegrität.

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

Automatisch die bereitgestellten Denkblöcke filtern
Die relevanten Denkblöcke verwenden, die notwendig sind, um die Argumentation des Modells zu bewahren
Nur für die Eingabe-Tokens für die Claude gezeigten Blöcke berechnen

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 Denkblöcken während der Tool-Verwendung aus ein paar Gründen notwendig:

Argumentationskontinuität: Die Denkblö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 Denkblö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, was Claude ermöglicht, zwischen Tool-Aufrufen zu denken und nach Erhalt von Tool-Ergebnissen anspruchsvollere Argumentation zu führen.

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 Denkblöcke innerhalb einer Assistenten-Wendung 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.1, 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 Eingabe {block.input}")
    elif block.type == "text":
        print(f"Text: {block.text}")

# Sie würden die Tools ausführen und Ergebnisse zurückgeben...
# Nach Erhalt 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 Eingabe {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 Eingabe {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 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 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 Denkblöcke innerhalb der Wendung 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 Arbeitsabläufe hinweg aufrechtzuerhalten.

Entfernung von Denkblock-Kontext

Denkblöcke aus vorherigen Wendungen werden aus dem Kontext entfernt, was Cache-Breakpoints beeinflussen kann
Beim Fortsetzen von Unterhaltungen mit Tool-Verwendung werden Denkblöcke gecacht und zählen als Eingabe-Tokens, wenn sie aus dem Cache gelesen werden
Dies schafft einen Kompromiss: Während Denkblöcke visuell keinen Kontextfenster-Platz verbrauchen, zählen sie dennoch zu Ihrer Eingabe-Token-Nutzung, wenn sie gecacht sind
Wenn Denken deaktiviert wird, schlagen Anfragen fehl, wenn Sie Denk-Inhalte in der aktuellen Tool-Verwendungswendung ü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 Denkblöcke zwischen mehreren Tool-Aufrufen auftreten können
System-Prompts und Tools bleiben trotz Änderungen der Denk-Parameter oder Block-Entfernung gecacht

Während Denkblöcke für Caching und Kontextberechnungen entfernt werden, müssen sie beim Fortsetzen von Unterhaltungen mit Tool-Verwendung bewahrt werden, besonders mit verschachteltem Denken.

Verständnis des Denkblock-Caching-Verhaltens

Bei der Verwendung von erweitertem Denken mit Tool-Verwendung zeigen Denkblö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 Denkblöcke) gecacht werden
Diese gecachten Denkblöcke zählen als Eingabe-Tokens in Ihren Nutzungsmetriken, wenn sie aus dem Cache gelesen werden
Wenn ein Nicht-Tool-Ergebnis-Benutzerblock enthalten ist, werden alle vorherigen Denkblöcke ignoriert und aus dem Kontext entfernt

Detaillierter Beispielablauf:

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?"], 
Assistent: [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 Anfrageinhalts (nicht der Antwort). Der Cache enthält die ursprüngliche Benutzer-Nachricht, den ersten Denkblock, Tool-Verwendungsblock und das Tool-Ergebnis.

Anfrage 3:

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

Da ein Nicht-Tool-Ergebnis-Benutzerblock enthalten war, werden alle vorherigen Denkblöcke ignoriert. Diese Anfrage wird genauso verarbeitet wie:

Benutzer: ["Wie ist das Wetter in Paris?"], 
Assistent: [tool_use block 1], 
Benutzer: [tool_result_1, cache=True], 
Assistent: [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 Zeile aufteilen
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Leere Zeilen verwerfen
    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 Zeile aufteilen
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Leere Zeilen verwerfen
    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, die Änderung 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, würde das System automatisch max_tokens anpassen, um in das Kontextlimit zu passen. Das bedeutete, Sie konnten einen großen max_tokens Wert setzen und das System würde ihn stillschweigend nach Bedarf 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:

Denkblöcke aus vorherigen Wendungen werden entfernt und nicht zu Ihrem Kontextfenster gezählt
Aktuelles Wendungs-Denken zählt zu Ihrem max_tokens Limit für diese Wendung

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

Das effektive Kontextfenster wird berechnet als:

Kontextfenster =
  (aktuelle Eingabe-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, besonders bei der Arbeit mit mehrstufigen Unterhaltungen, die Denken einschließen.

Das Kontextfenster mit erweitertem Denken und Tool-Verwendung

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

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

Kontextfenster =
  (aktuelle Eingabe-Tokens + vorherige Denk-Tokens + Tool-Verwendungs-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 erweitertem Denken bei 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 Denkblöcke nicht in Ihrem Kontextfenster ansammeln

Diese Änderung wurde vorgenommen, um vorhersagbareres und transparenteres Verhalten zu bieten, besonders da maximale 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 Denkblöcke von Claude generiert wurden, wenn sie an die API zurückgegeben werden.

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

Wenn Sie Denkblö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 Modellen 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 Verifizierungszwecke.
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 redaktierte Denkblö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 Denkblöcke Benutzern zeigen, können Sie redaktierte Blöcke herausfiltern, während Sie normale Denkblö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 redaktiertes Denken elegant zu verwalten, ohne Ihre Benutzeroberfläche zu beschädigen

Hier ist ein Beispiel, das sowohl normale als auch redaktierte Denkblöcke zeigt:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Lassen Sie 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 redaktierter Denkblöcke in Ihrer Ausgabe ist erwartetes Verhalten. Das Modell kann diese redaktierte Argumentation immer noch verwenden, um seine Antworten zu informieren, während Sicherheitsleitplanken aufrechterhalten werden.

Wenn Sie redaktierte Denk-Behandlung in Ihrer Anwendung testen müssen, können Sie diesen speziellen Test-String als Ihren Prompt verwenden: ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB

Wenn Sie thinking und redacted_thinking Blöcke in einer mehrstufigen Unterhaltung an die API zurückgeben, müssen Sie den vollständigen unveränderten Block für die letzte Assistenten-Wendung zurück an die API einschließen. Dies ist kritisch für die Aufrechterhaltung des Argumentationsflusses des Modells. Wir empfehlen, immer alle Denkblöcke an die API zurückzugeben. Für weitere Details siehe den Abschnitt Bewahrung von Denkblöcken oben.

Beispiel: Arbeiten mit redaktierten Denkblö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 redaktiertes 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"
    }]
)

# Redaktierte Denkblöcke identifizieren
has_redacted_thinking = any(
    block.type == "redacted_thinking" for block in response.content
)

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

    # Alle Blöcke extrahieren (sowohl redaktierte als auch nicht-redaktierte)
    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"Insgesamt {len(all_thinking_blocks)} Denkblöcke gefunden")
    print(f"Diese Blöcke sind immer noch als Ausgabe-Tokens abrechenbar")

In Konsole testen

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-Eingabe-Tokens	Cache-Schreibvorgänge	Cache-Treffer	Ausgabe-Tokens
Claude Opus 4.1	$15 / MTok	$18,75 / MTok	$1,50 / MTok	$75 / MTok
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 Denkprozess verursacht Kosten für:

Während des Denkens verwendete Tokens (Ausgabe-Tokens)
Denkblöcke aus der letzten Assistenten-Wendung, die in nachfolgenden Anfragen enthalten sind (Eingabe-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:

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

Die abgerechnete Ausgabe-Token-Anzahl wird nicht mit der sichtbaren Token-Anzahl in der Antwort übereinstimmen. Ihnen wird der vollständige Denkprozess 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 Denkblö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 Denkblöcke nicht selbst entfernen. Die Anthropic API ignoriert automatisch Denkblöcke aus vorherigen Wendungen und sie werden nicht bei der Berechnung der Kontextnutzung berücksichtigt.
Prompt-Engineering: Überprüfen Sie unsere erweiterten Denk-Prompting-Tipps, wenn Sie Claudes Denkfä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 Denkblöcken
Verschachteltes Denken
Erweitertes Denken mit Prompt-Caching
Verständnis des Denkblock-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 Denkblöcken

Verschachteltes Denken

Erweitertes Denken mit Prompt-Caching

Verständnis des Denkblock-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 Denkblöcken

​Verschachteltes Denken

​Erweitertes Denken mit Prompt-Caching

​Verständnis des Denkblock-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 Denkblöcken

Verschachteltes Denken

Erweitertes Denken mit Prompt-Caching

Verständnis des Denkblock-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