Entwickeln mit erweitertem Denken

Erweitertes Denken verleiht Claude verbesserte Denkfähigkeiten für komplexe Aufgaben und bietet gleichzeitig unterschiedliche Transparenzstufen in seinen schrittweisen Denkprozessen, bevor er 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 exakt gleich.

Weitere Informationen finden Sie unter Unterschiede im Denken zwischen Modellversionen.

Wie erweitertes Denken funktioniert

Wenn erweitertes Denken aktiviert ist, erstellt Claude thinking-Inhaltsblöcke, in denen er seine internen Überlegungen ausgibt. Claude integriert Erkenntnisse aus diesen Überlegungen, bevor er eine endgültige Antwort formuliert.

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

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

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

Weitere Informationen zum Antwortformat des erweiterten Denkens finden Sie in der 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": "Are there an infinite number of prime numbers such that n mod 4 == 3?"
        }
    ]
}'

Um erweitertes Denken zu aktivieren, fügen Sie ein thinking-Objekt hinzu, wobei der thinking-Parameter auf enabled und das budget_tokens auf ein bestimmtes Token-Budget für erweitertes Denken gesetzt wird.

Der Parameter budget_tokens bestimmt die maximale Anzahl von Tokens, die Claude für seinen internen Denkprozess verwenden darf. Bei 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 nutzt, besonders bei Bereichen über 32k.

budget_tokens muss auf einen Wert kleiner als max_tokens gesetzt werden. Bei Verwendung von verschachteltem Denken mit Tools können Sie diese Grenze jedoch überschreiten, da die Token-Grenze dann Ihr gesamtes Kontextfenster (200k Tokens) wird.

Zusammengefasstes Denken

Bei 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 zum zusammengefassten Denken:

Ihnen werden die vollständigen Denk-Tokens berechnet, die durch die ursprüngliche Anfrage generiert wurden, nicht die zusammengefassten Tokens.
Die berechnete Ausgabe-Token-Anzahl wird nicht mit der Anzahl der Tokens übereinstimmen, die Sie in der Antwort sehen.
Die ersten Zeilen der Denkausgabe sind ausführlicher und bieten detaillierte Überlegungen, die besonders für Prompt-Engineering-Zwecke hilfreich sind.
Da Anthropic bestrebt ist, die Funktion des erweiterten Denkens zu verbessern, kann sich das Zusammenfassungsverhalten ändern.
Die Zusammenfassung bewahrt die Kernideen von Claudes Denkprozess mit minimaler zusätzlicher Latenz, ermöglicht ein streamfähiges Benutzererlebnis und eine 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 Denkmodell sieht die zusammengefasste Ausgabe nicht.

Claude Sonnet 3.7 gibt weiterhin die vollständige Denkausgabe zurück.

In seltenen Fällen, in denen Sie Zugriff auf die vollständige Denkausgabe für Claude 4-Modelle benötigen, kontaktieren Sie unser Vertriebsteam.

Streaming-Denken

Sie können erweiterte Denkantworten mithilfe von Server-Sent Events (SSE) streamen.

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

Weitere Dokumentation zum Streaming über die Messages API finden Sie unter Streaming Messages.

So können 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": "What is 27 * 453?"
        }
    ]
}'

Beispiel für 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": "Let me solve this step by step:\n\n1. First break down 27 * 453"}}

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

// Weitere thinking deltas...

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

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

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

event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "27 * 453 = 12,231"}}

// Weitere 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"}

Bei der Verwendung von Streaming mit aktiviertem Denken können Sie feststellen, dass Text manchmal in größeren Blöcken ankommt, die sich mit kleineren, Token-für-Token-Lieferungen abwechseln. Dies ist ein erwartetes Verhalten, insbesondere für Denkinhalte.

Das Streaming-System muss Inhalte in Batches verarbeiten, um eine optimale Leistung zu erzielen, was zu diesem “ungleichmäßigen” Liefermuster führen kann, mit möglichen Verzögerungen zwischen Streaming-Events. Wir arbeiten kontinuierlich daran, dieses Erlebnis zu verbessern, wobei zukünftige Updates darauf abzielen, Denkinhalte gleichmäßiger zu streamen.

Erweitertes Denken mit Tool-Nutzung

Erweitertes Denken kann zusammen mit Tool-Nutzung verwendet werden, wodurch Claude durch die Tool-Auswahl und Ergebnisverarbeitung denken kann.

Bei der Verwendung von erweitertem Denken mit Tool-Nutzung sollten Sie die folgenden Einschränkungen beachten:

Einschränkung der Tool-Auswahl: Tool-Nutzung mit Denken unterstützt nur tool_choice: any (nicht specific, auto oder andere Werte).
Erhaltung von Denkblöcken: Bei der Tool-Nutzung müssen Sie thinking-Blöcke für die letzte Assistentennachricht an die API zurückgeben. Geben Sie den vollständigen unveränderten Block an die API zurück, um die Kontinuität des Denkens zu gewährleisten.

Beispiel: Übergabe von Denkblöcken mit Tool-Ergebnissen

Hier ist ein praktisches Beispiel, das zeigt, wie Denkblöcke bei der Bereitstellung von Tool-Ergebnissen erhalten bleiben:

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

# First request - Claude responds with thinking and tool request
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": "What's the weather in Paris?"}
    ]
)

Die API-Antwort enthält thinking-, text- und tool_use-Blöcke:

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

Lassen Sie uns nun die Konversation fortsetzen und das Tool verwenden

# Extract thinking block and tool use block
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)

# Call your actual weather API, here is where your actual API call would go
# let's pretend this is what we get back
weather_data = {"temperature": 88}

# Second request - Include thinking block and tool result
# No new thinking blocks will be generated in the response
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": "What's the weather in Paris?"},
        # notice that the thinking_block is passed in as well as the tool_use_block
        # if this is not passed in, an error is raised
        {"role": "assistant", "content": [thinking_block, tool_use_block]},
        {"role": "user", "content": [{
            "type": "tool_result",
            "tool_use_id": tool_use_block.id,
            "content": f"Current temperature: {weather_data['temperature']}°F"
        }]}
    ]
)

Die API-Antwort enthält jetzt nur Text

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

Erhaltung von Denkblöcken

Bei der Tool-Nutzung müssen Sie thinking-Blöcke an die API zurückgeben, und Sie müssen den vollständigen unveränderten Block an die API zurückgeben. Dies ist entscheidend für die Aufrechterhaltung des Denkflusses des Modells und der Konversationsintegrität.

Obwohl Sie thinking-Blöcke aus früheren assistant-Rollen-Runden weglassen können, empfehlen wir, immer alle Denkblöcke an die API zurückzugeben, wenn es sich um eine Konversation mit mehreren Runden handelt. Die API wird:

Die bereitgestellten Denkblöcke automatisch filtern
Die relevanten Denkblöcke verwenden, die notwendig sind, um das Denken des Modells zu erhalten
Nur die Eingabe-Tokens für die Blöcke berechnen, die Claude gezeigt werden

Wenn Claude Tools aufruft, pausiert es die Erstellung einer Antwort, um auf externe Informationen zu warten. Wenn Tool-Ergebnisse zurückgegeben werden, wird Claude diese bestehende Antwort weiter aufbauen. Dies erfordert die Erhaltung von Denkblöcken während der Tool-Nutzung, aus mehreren Gründen:

Kontinuität des Denkens: Die Denkblöcke erfassen Claudes schrittweise Überlegungen, die zu Tool-Anfragen geführt haben. Wenn Sie Tool-Ergebnisse posten, stellt die Einbeziehung des ursprünglichen Denkens sicher, dass Claude sein Denken dort fortsetzen kann, wo es aufgehört hat.
Kontexterhaltung: Während Tool-Ergebnisse in der API-Struktur als Benutzernachrichten erscheinen, sind sie Teil eines kontinuierlichen Denkflusses. Die Erhaltung von Denkblöcken erhält diesen konzeptionellen Fluss über mehrere API-Aufrufe hinweg. Weitere Informationen zur Kontextverwaltung finden Sie in unserem Leitfaden zu Kontextfenstern.

Wichtig: Bei der Bereitstellung von thinking-Blöcken muss die gesamte Sequenz aufeinanderfolgender thinking-Blöcke mit den Ausgaben übereinstimmen, die das Modell während der ursprünglichen Anfrage generiert hat; Sie können die Reihenfolge dieser Blöcke nicht neu anordnen oder ändern.

Verschachteltes Denken

Erweitertes Denken mit Tool-Nutzung in Claude 4-Modellen unterstützt verschachteltes Denken, das es Claude ermöglicht, zwischen Tool-Aufrufen zu denken und nach Erhalt von Tool-Ergebnissen anspruchsvollere Überlegungen anzustellen.

Mit verschachteltem Denken kann Claude:

Über die Ergebnisse eines Tool-Aufrufs nachdenken, bevor er entscheidet, was als nächstes zu tun ist
Mehrere Tool-Aufrufe mit Denkschritten dazwischen verketten
Basierend auf Zwischenergebnissen differenziertere Entscheidungen treffen

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

Verschachteltes Denken wird nur für Tools unterstützt, die über die Messages API verwendet werden.

Bei verschachteltem Denken kann das budget_tokens den Parameter max_tokens überschreiten, da es das Gesamtbudget über alle Denkblöcke innerhalb einer Assistentenrunde darstellt.

Tool-Nutzung ohne verschachteltes Denken

import anthropic

client = anthropic.Anthropic()

# Define tools
calculator_tool = {
    "name": "calculator",
    "description": "Perform mathematical calculations",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Mathematical expression to evaluate"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Query product database",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "SQL query to execute"
            }
        },
        "required": ["query"]
    }
}

# First request - Claude thinks once before all tool calls
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": "What's the total revenue if we sold 150 units of product A at $50 each, and how does this compare to our average monthly revenue from the database?"
    }]
)

# Response includes thinking followed by tool uses
# Note: Claude thinks once at the beginning, then makes all tool decisions
print("First response:")
for block in response.content:
    if block.type == "thinking":
        print(f"Thinking (summarized): {block.thinking}")
    elif block.type == "tool_use":
        print(f"Tool use: {block.name} with input {block.input}")
    elif block.type == "text":
        print(f"Text: {block.text}")

# You would execute the tools and return results...
# After getting both tool results back, Claude directly responds without additional thinking

In diesem Beispiel ohne verschachteltes Denken:

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

Tool-Nutzung mit verschachteltem Denken

import anthropic

client = anthropic.Anthropic()

# Same tool definitions as before
calculator_tool = {
    "name": "calculator",
    "description": "Perform mathematical calculations",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Mathematical expression to evaluate"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Query product database",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "SQL query to execute"
            }
        },
        "required": ["query"]
    }
}

# First request with interleaved thinking enabled
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    # Enable interleaved thinking with beta header
    extra_headers={
        "anthropic-beta": "interleaved-thinking-2025-05-14"
    },
    messages=[{
        "role": "user",
        "content": "What's the total revenue if we sold 150 units of product A at $50 each, and how does this compare to our average monthly revenue from the database?"
    }]
)

print("Initial response:")
thinking_blocks = []
tool_use_blocks = []

for block in response.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Thinking: {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Tool use: {block.name} with input {block.input}")
    elif block.type == "text":
        print(f"Text: {block.text}")

# First tool result (calculator)
calculator_result = "7500"  # 150 * 50

# Continue with first tool result
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    extra_headers={
        "anthropic-beta": "interleaved-thinking-2025-05-14"
    },
    messages=[
        {
            "role": "user",
            "content": "What's the total revenue if we sold 150 units of product A at $50 each, and how does this compare to our average monthly revenue from the database?"
        },
        {
            "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("\nAfter calculator result:")
# With interleaved thinking, Claude can think about the calculator result
# before deciding to query the database
for block in response2.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Interleaved thinking: {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Tool use: {block.name} with input {block.input}")

# Second tool result (database)
database_result = "5200"  # Example average monthly revenue

# Continue with second tool result
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    extra_headers={
        "anthropic-beta": "interleaved-thinking-2025-05-14"
    },
    messages=[
        {
            "role": "user",
            "content": "What's the total revenue if we sold 150 units of product A at $50 each, and how does this compare to our average monthly revenue from the database?"
        },
        {
            "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("\nAfter database result:")
# With interleaved thinking, Claude can think about both results
# before formulating the final response
for block in response3.content:
    if block.type == "thinking":
        print(f"Final thinking: {block.thinking}")
    elif block.type == "text":
        print(f"Final response: {block.text}")

In diesem Beispiel mit verschachteltem Denken:

Claude denkt zunächst über die Aufgabe nach
Nach Erhalt des Taschenrechnerergebnisses 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 Datenbankergebnisses denkt Claude noch einmal über beide Ergebnisse nach, bevor er eine endgültige Antwort formuliert
Das Denkbudget wird auf alle Denkblöcke innerhalb der Runde verteilt

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

Erweitertes Denken mit Prompt-Caching

Prompt-Caching mit Denken hat mehrere wichtige Überlegungen:

Entfernung von Denkblock-Kontext

Denkblöcke aus früheren Runden werden aus dem Kontext entfernt, was Cache-Breakpoints beeinflussen kann
Bei der Fortsetzung von Konversationen mit Tool-Nutzung werden Denkblöcke zwischengespeichert und zählen als Eingabe-Tokens, wenn sie aus dem Cache gelesen werden
Dies schafft einen Kompromiss: Während Denkblöcke visuell keinen Kontextfensterplatz verbrauchen, zählen sie dennoch zu Ihrer Eingabe-Token-Nutzung, wenn sie zwischengespeichert werden
Wenn das Denken deaktiviert wird, schlagen Anfragen fehl, wenn Sie Denkinhalte in der aktuellen Tool-Nutzungsrunde übergeben. In anderen Kontexten werden an die API übergebene Denkinhalte einfach ignoriert

Cache-Invalidierungsmuster

Änderungen an Denkparametern (aktiviert/deaktiviert oder Budgetzuweisung) invalidieren Message-Cache-Breakpoints
Verschachteltes Denken verstärkt die Cache-Invalidierung, da Denkblöcke zwischen mehreren Tool-Aufrufen auftreten können
Systemprompts und Tools bleiben trotz Änderungen der Denkparameter oder Blockentfernung zwischengespeichert

Während Denkblöcke für Caching und Kontextberechnungen entfernt werden, müssen sie bei der Fortsetzung von Konversationen mit Tool-Nutzung erhalten bleiben, insbesondere bei verschachteltem Denken.

Verständnis des Caching-Verhaltens von Denkblöcken

Bei der Verwendung von erweitertem Denken mit Tool-Nutzung zeigen Denkblöcke ein 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 Konversationsverlauf (einschließlich Denkblöcke) zwischengespeichert werden
Diese zwischengespeicherten 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:

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

Antwort 1:

[thinking_block_1] + [tool_use block 1]

Anfrage 2:

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

Antwort 2:

[thinking_block_2] + [text block 2]

Anfrage 2 schreibt einen Cache des Anfrageinhalts (nicht der Antwort). Der Cache enthält die ursprüngliche Benutzernachricht, den ersten Denkblock, den Tool-Nutzungsblock und das Tool-Ergebnis.

Anfrage 3:

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

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

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

Wichtige Punkte:

Dieses Caching-Verhalten geschieht automatisch, auch ohne explizite cache_control-Marker
Dieses Verhalten ist konsistent, unabhängig davon, ob normales Denken oder verschachteltes Denken verwendet wird

System-Prompt-Caching (bleibt erhalten, wenn sich das 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')

    # Remove script and style elements
    for script in soup(["script", "style"]):
        script.decompose()

    # Get text
    text = soup.get_text()

    # Break into lines and remove leading and trailing space on each
    lines = (line.strip() for line in text.splitlines())
    # Break multi-headlines into a line each
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Drop blank lines
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Fetch the content of the article
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Use just enough text for caching (first few chapters)
LARGE_TEXT = book_content[:5000]

SYSTEM_PROMPT=[
    {
        "type": "text",
        "text": "You are an AI assistant that is tasked with literary analysis. Analyze the following text carefully.",
    },
    {
        "type": "text",
        "text": LARGE_TEXT,
        "cache_control": {"type": "ephemeral"}
    }
]

MESSAGES = [
    {
        "role": "user",
        "content": "Analyze the tone of this passage."
    }
]

# First request - establish cache
print("First request - establishing cache")
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"First response usage: {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analyze the characters in this passage."
})
# Second request - same thinking parameters (cache hit expected)
print("\nSecond request - same thinking parameters (cache hit expected)")
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"Second response usage: {response2.usage}")

# Third request - different thinking parameters (cache miss for messages)
print("\nThird request - different thinking parameters (cache miss for messages)")
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Changed thinking budget
    },
    system=SYSTEM_PROMPT,  # System prompt remains cached
    messages=MESSAGES  # Messages cache is invalidated
)

print(f"Third response usage: {response3.usage}")

Messages-Caching (wird ungültig, wenn sich das 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')

    # Remove script and style elements
    for script in soup(["script", "style"]):
        script.decompose()

    # Get text
    text = soup.get_text()

    # Break into lines and remove leading and trailing space on each
    lines = (line.strip() for line in text.splitlines())
    # Break multi-headlines into a line each
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Drop blank lines
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Fetch the content of the article
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Use just enough text for caching (first few chapters)
LARGE_TEXT = book_content[:5000]

# No system prompt - caching in messages instead
MESSAGES = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": LARGE_TEXT,
                "cache_control": {"type": "ephemeral"},
            },
            {
                "type": "text",
                "text": "Analyze the tone of this passage."
            }
        ]
    }
]

# First request - establish cache
print("First request - establishing cache")
response1 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    messages=MESSAGES
)

print(f"First response usage: {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analyze the characters in this passage."
})
# Second request - same thinking parameters (cache hit expected)
print("\nSecond request - same thinking parameters (cache hit expected)")
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000  # Same thinking budget
    },
    messages=MESSAGES
)

print(f"Second response usage: {response2.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response2.content
})
MESSAGES.append({
    "role": "user",
    "content": "Analyze the setting in this passage."
})

# Third request - different thinking budget (cache miss expected)
print("\nThird request - different thinking budget (cache miss expected)")
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Different thinking budget breaks cache
    },
    messages=MESSAGES
)

print(f"Third response usage: {response3.usage}")

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

First request - establishing cache
First response usage: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 17, output_tokens: 700 }

Second request - same thinking parameters (cache hit expected)

Second response usage: { cache_creation_input_tokens: 0, cache_read_input_tokens: 1370, input_tokens: 303, output_tokens: 874 }

Third request - different thinking budget (cache miss expected)
Third response usage: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 747, output_tokens: 619 }

Dieses Beispiel zeigt, dass wenn Caching im Messages-Array eingerichtet ist, die Änderung der Denkparameter (budget_tokens erhöht von 4000 auf 8000) den Cache ungültig macht. Die dritte Anfrage zeigt keinen Cache-Treffer mit cache_creation_input_tokens=1370 und cache_read_input_tokens=0, was beweist, dass nachrichtenbasiertes Caching ungültig wird, wenn sich Denkparameter ändern.

Max Tokens und Kontextfenstergröße mit erweitertem Denken

In älteren Claude-Modellen (vor Claude Sonnet 3.7) würde das System automatisch max_tokens anpassen, um in die Kontextgrenze zu passen, wenn die Summe aus Prompt-Tokens und max_tokens das Kontextfenster des Modells überschritt. Das bedeutete, dass Sie einen großen max_tokens-Wert festlegen konnten und das System diesen bei Bedarf stillschweigend reduzierte.

Bei Claude 3.7 und 4 Modellen wird max_tokens (was Ihr Denkbudget einschließt, wenn Denken aktiviert ist) als strikte Grenze durchgesetzt. Das System gibt jetzt einen Validierungsfehler zurück, wenn Prompt-Tokens + max_tokens die Kontextfenstergröße überschreiten.

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

Das Kontextfenster mit erweitertem Denken

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

Denkblöcke aus früheren Runden werden entfernt und nicht auf Ihr Kontextfenster angerechnet
Das aktuelle Denken zählt zu Ihrer max_tokens-Grenze für diese Runde

Das Diagramm unten zeigt die spezialisierte Token-Verwaltung, wenn erweitertes Denken aktiviert ist:

Das effektive Kontextfenster wird wie folgt berechnet:

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, insbesondere bei mehrteiligen Konversationen, die Denken beinhalten.

Das Kontextfenster mit erweitertem Denken und Tool-Nutzung

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

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

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

Das Diagramm unten veranschaulicht die Token-Verwaltung für erweitertes Denken mit Tool-Nutzung:

Verwaltung von Tokens 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
Beachten, dass sich vorherige Denkblöcke nicht in Ihrem Kontextfenster ansammeln

Diese Änderung wurde vorgenommen, um ein vorhersehbareres und transparenteres Verhalten zu bieten, insbesondere da die maximalen Token-Grenzen erheblich erhöht wurden.

Denkverschlüsselung

Vollständige Denkinhalte werden verschlüsselt und im Feld signature zurückgegeben. Dieses Feld wird verwendet, um zu überprüfen, ob Denkblöcke von Claude generiert wurden, wenn sie an die API zurückgegeben werden. 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.

Beachten Sie, dass das Signaturfeld deutlich länger sein wird als in früheren Modellen. Dies ist ein undurchsichtiges Feld und sollte nicht interpretiert oder analysiert werden - es existiert ausschließlich für Überprüfungszwecke.

Es ist nur dann unbedingt erforderlich, Denkblöcke zurückzusenden, wenn Tools mit erweitertem Denken verwendet werden. Andernfalls können Sie Denkblöcke aus früheren Runden weglassen oder die API sie für Sie entfernen lassen, wenn Sie sie zurückgeben.

Wenn Sie Denkblöcke zurücksenden, empfehlen wir, alles genau so zurückzugeben, wie Sie es erhalten haben, um Konsistenz zu gewährleisten und potenzielle Probleme zu vermeiden.

Denk-Redaktion

Gelegentlich werden Claudes interne Überlegungen von unseren Sicherheitssystemen markiert. Wenn dies geschieht, verschlüsseln wir einige oder alle thinking-Blöcke und geben sie als redacted_thinking-Block an Sie zurück. redacted_thinking-Blöcke werden entschlüsselt, wenn sie an die API zurückgegeben werden, sodass Claude seine Antwort ohne Kontextverlust fortsetzen kann.

Beim Aufbau kundenorientierter Anwendungen, die erweitertes Denken verwenden:

Beachten Sie, dass redigierte Denkblöcke verschlüsselte Inhalte enthalten, die nicht für Menschen lesbar sind
Erwägen Sie, eine einfache Erklärung wie diese zu geben: “Einige von Claudes internen Überlegungen wurden aus Sicherheitsgründen automatisch verschlüsselt. Dies hat keinen Einfluss auf die Qualität der Antworten.”
Wenn Sie Denkblöcke Benutzern zeigen, können Sie redigierte Blöcke herausfiltern und normale Denkblöcke beibehalten
Seien Sie transparent darüber, dass die Verwendung erweiterter Denkfunktionen gelegentlich dazu führen kann, dass einige Überlegungen verschlüsselt werden
Implementieren Sie eine angemessene Fehlerbehandlung, um redigiertes Denken ohne Beeinträchtigung Ihrer Benutzeroberfläche zu verwalten

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

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

Das Auftreten von redigierten Denkblöcken in Ihrer Ausgabe ist ein erwartetes Verhalten. Das Modell kann diese redigierten Überlegungen weiterhin nutzen, um seine Antworten zu informieren, während es Sicherheitsschranken aufrechterhält.

Wenn Sie die Handhabung von redigiertem Denken in Ihrer Anwendung testen müssen, können Sie diesen speziellen Teststring als Prompt verwenden: ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB

Wenn Sie thinking- und redacted_thinking-Blöcke in einer mehrteiligen Konversation an die API zurückgeben, müssen Sie den vollständigen unveränderten Block für die letzte Assistentenrunde an die API zurückgeben. Dies ist entscheidend für die Aufrechterhaltung des Denkflusses des Modells. Wir empfehlen, immer alle Denkblöcke an die API zurückzugeben. Weitere Details finden Sie im Abschnitt Erhaltung von Denkblöcken oben.

Beispiel: Arbeiten mit redigierten Denkblöcken

Dieses Beispiel zeigt, wie man mit redacted_thinking-Blöcken umgeht, die in Antworten erscheinen können, wenn Claudes interne Überlegungen Inhalte enthalten, die von Sicherheitssystemen markiert wurden:

import anthropic

client = anthropic.Anthropic()

# Using a special prompt that triggers redacted thinking (for demonstration purposes only)
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"
    }]
)

# Identify redacted thinking blocks
has_redacted_thinking = any(
    block.type == "redacted_thinking" for block in response.content
)

if has_redacted_thinking:
    print("Response contains redacted thinking blocks")
    # These blocks are still usable in subsequent requests

    # Extract all blocks (both redacted and non-redacted)
    all_thinking_blocks = [
        block for block in response.content
        if block.type in ["thinking", "redacted_thinking"]
    ]

    # When passing to subsequent requests, include all blocks without modification
    # This preserves the integrity of Claude's reasoning

    print(f"Found {len(all_thinking_blocks)} thinking blocks total")
    print(f"These blocks are still billable as output tokens")

Unterschiede im Denken zwischen Modellversionen

Die Messages API behandelt das Denken bei Claude Sonnet 3.7 und Claude 4 Modellen unterschiedlich, hauptsächlich in Bezug auf Redaktion und Zusammenfassung.

In der folgenden Tabelle finden Sie einen komprimierten Vergleich:

Funktion	Claude Sonnet 3.7	Claude 4 Modelle
Denkausgabe	Gibt vollständige Denkausgabe zurück	Gibt zusammengefasstes Denken 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	$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:

Tokens, die während des Denkens verwendet werden (Ausgabe-Tokens)
Denkblöcke aus der letzten Assistentenrunde, die in nachfolgenden Anfragen enthalten sind (Eingabe-Tokens)
Standard-Textausgabe-Tokens

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

Bei der Verwendung von zusammengefasstem Denken:

Eingabe-Tokens: Tokens in Ihrer ursprünglichen Anfrage (ohne Denk-Tokens aus früheren Runden)
Ausgabe-Tokens (berechnet): 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 werden

Die berechnete Ausgabe-Token-Anzahl wird nicht mit der sichtbaren Token-Anzahl in der Antwort übereinstimmen. Ihnen wird der vollständige Denkprozess in Rechnung gestellt, nicht die Zusammenfassung, die Sie sehen.

Best Practices und Überlegungen für erweitertes Denken

Arbeiten mit Denkbudgets

Budget-Optimierung: Das Mindestbudget beträgt 1.024 Tokens. Wir empfehlen, mit dem Minimum zu beginnen und das Denkbudget schrittweise zu erhöhen, um den optimalen Bereich für Ihren Anwendungsfall zu finden. Höhere Token-Anzahlen ermöglichen umfassendere Überlegungen, jedoch mit abnehmenden Erträgen je nach Aufgabe. Die Erhöhung des Budgets kann die Antwortqualität verbessern, allerdings auf Kosten erhöhter Latenz. Testen Sie für kritische Aufgaben verschiedene Einstellungen, um die optimale Balance zu finden. Beachten Sie, dass das Denkbudget eher ein Ziel als eine strikte Grenze ist – die tatsächliche Token-Nutzung kann je nach Aufgabe variieren.
Ausgangspunkte: Beginnen Sie mit größeren Denkbudgets (16k+ Tokens) für komplexe Aufgaben und passen Sie diese nach Bedarf an.
Große Budgets: Für Denkbudgets über 32k empfehlen wir die Verwendung von Batch-Verarbeitung, um Netzwerkprobleme zu vermeiden. Anfragen, die das Modell dazu bringen, über 32k Tokens nachzudenken, verursachen lang laufende Anfragen, die möglicherweise an Systemzeitüberschreitungen und offene Verbindungslimits stoßen.
Token-Nutzungsverfolgung: Überwachen Sie die Nutzung von Denk-Tokens, um Kosten und Leistung zu optimieren.

Leistungsüberlegungen

Antwortzeiten: Seien Sie auf möglicherweise längere Antwortzeiten vorbereitet, die durch die zusätzliche Verarbeitung für den Denkprozess erforderlich sind. 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 sollten Sie darauf vorbereitet sein, sowohl Denk- als auch Textinhaltsblöcke zu verarbeiten, wenn sie eintreffen.

Funktionskompatibilität

Denken ist nicht kompatibel mit temperature- oder top_k-Modifikationen sowie mit erzwungener Tool-Nutzung.
Wenn Denken aktiviert ist, können Sie top_p auf Werte zwischen 1 und 0,95 setzen.
Sie können keine Antworten vorausfüllen, wenn Denken aktiviert ist.
Änderungen am Denkbudget machen zwischengespeicherte Prompt-Präfixe ungültig, die Nachrichten enthalten. Zwischengespeicherte System-Prompts und Tool-Definitionen funktionieren jedoch weiterhin, wenn sich Denkparameter ändern.

Nutzungsrichtlinien

Aufgabenauswahl: Verwenden Sie erweitertes Denken für besonders komplexe Aufgaben, die von schrittweisem Denken profitieren, wie Mathematik, Programmierung und Analysen.
Kontextbehandlung: Sie müssen vorherige Denkblöcke nicht selbst entfernen. Die Anthropic API ignoriert automatisch Denkblöcke aus vorherigen Zügen und sie werden bei der Berechnung der Kontextnutzung nicht berücksichtigt.
Prompt-Engineering: Lesen Sie unsere Tipps zum Prompt-Engineering für erweitertes Denken, wenn Sie Claudes Denkfähigkeiten maximieren möchten.

Nächste Schritte

Probieren Sie das Kochbuch für erweitertes Denken aus

Erkunden Sie praktische Beispiele für Denken in unserem Kochbuch.

Tipps zum Prompt-Engineering für erweitertes Denken

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

EOF < /dev/null

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-Nutzung
Erhaltung von Denkblöcken
Verschachteltes Denken
Erweitertes Denken mit Prompt-Caching
Verständnis des Caching-Verhaltens von Denkblöcken
Max Tokens und Kontextfenstergröße mit erweitertem Denken
Das Kontextfenster mit erweitertem Denken
Das Kontextfenster mit erweitertem Denken und Tool-Nutzung
Verwaltung von Tokens mit erweitertem Denken
Denkverschlüsselung
Denk-Redaktion
Unterschiede im Denken zwischen Modellversionen
Preisgestaltung
Best Practices und Überlegungen für erweitertes Denken
Arbeiten mit Denkbudgets
Leistungsüberlegungen
Funktionskompatibilität
Nutzungsrichtlinien
Nächste Schritte

Erste Schritte

Modelle & Preise

Funktionen erkunden

Über Claude erfahren

Testen & evaluieren

Rechtliches Zentrum

Agent-Komponenten

Entwickeln mit erweitertem Denken

Unterstützte Modelle

Wie erweitertes Denken funktioniert

Wie man erweitertes Denken verwendet

Zusammengefasstes Denken

Streaming-Denken

Erweitertes Denken mit Tool-Nutzung

Erhaltung von Denkblöcken

Verschachteltes Denken

Erweitertes Denken mit Prompt-Caching

Verständnis des Caching-Verhaltens von Denkblöcken

Max Tokens und Kontextfenstergröße mit erweitertem Denken

Das Kontextfenster mit erweitertem Denken

Das Kontextfenster mit erweitertem Denken und Tool-Nutzung

Verwaltung von Tokens mit erweitertem Denken

Denkverschlüsselung

Denk-Redaktion

Unterschiede im Denken zwischen Modellversionen

Preisgestaltung

Best Practices und Überlegungen für erweitertes Denken

Arbeiten mit Denkbudgets

Leistungsüberlegungen

Funktionskompatibilität

Nutzungsrichtlinien

Nächste Schritte

Probieren Sie das Kochbuch für erweitertes Denken aus

Tipps zum Prompt-Engineering für erweitertes Denken

Erste Schritte

Modelle & Preise

Funktionen erkunden

Über Claude erfahren

Testen & evaluieren

Rechtliches Zentrum

Agent-Komponenten

​Unterstützte Modelle

​Wie erweitertes Denken funktioniert

​Wie man erweitertes Denken verwendet

​Zusammengefasstes Denken

​Streaming-Denken

​Erweitertes Denken mit Tool-Nutzung

​Erhaltung von Denkblöcken

​Verschachteltes Denken

​Erweitertes Denken mit Prompt-Caching

​Verständnis des Caching-Verhaltens von Denkblöcken

​Max Tokens und Kontextfenstergröße mit erweitertem Denken

​Das Kontextfenster mit erweitertem Denken

​Das Kontextfenster mit erweitertem Denken und Tool-Nutzung

​Verwaltung von Tokens mit erweitertem Denken

​Denkverschlüsselung

​Denk-Redaktion

​Unterschiede im Denken zwischen Modellversionen

​Preisgestaltung

​Best Practices und Überlegungen für erweitertes Denken

​Arbeiten mit Denkbudgets

​Leistungsüberlegungen

​Funktionskompatibilität

​Nutzungsrichtlinien

​Nächste Schritte

Probieren Sie das Kochbuch für erweitertes Denken aus

Tipps zum Prompt-Engineering für erweitertes Denken

Unterstützte Modelle

Wie erweitertes Denken funktioniert

Wie man erweitertes Denken verwendet

Zusammengefasstes Denken

Streaming-Denken

Erweitertes Denken mit Tool-Nutzung

Erhaltung von Denkblöcken

Verschachteltes Denken

Erweitertes Denken mit Prompt-Caching

Verständnis des Caching-Verhaltens von Denkblöcken

Max Tokens und Kontextfenstergröße mit erweitertem Denken

Das Kontextfenster mit erweitertem Denken

Das Kontextfenster mit erweitertem Denken und Tool-Nutzung

Verwaltung von Tokens mit erweitertem Denken

Denkverschlüsselung

Denk-Redaktion

Unterschiede im Denken zwischen Modellversionen

Preisgestaltung

Best Practices und Überlegungen für erweitertes Denken

Arbeiten mit Denkbudgets

Leistungsüberlegungen

Funktionskompatibilität

Nutzungsrichtlinien

Nächste Schritte