Entwickeln mit erweitertem Denken

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

Unterstützte Modelle

Erweitertes Denken wird in den folgenden Modellen unterstützt:

Claude Opus 4.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 genau gleich.Für weitere Informationen siehe Unterschiede im Denken zwischen Modellversionen.

Wie erweitertes Denken funktioniert

Wenn erweitertes Denken aktiviert ist, erstellt Claude thinking Inhaltsblöcke, in denen es seine interne Argumentation ausgibt. Claude integriert Erkenntnisse aus dieser Argumentation, bevor es eine endgültige Antwort erstellt. Die API-Antwort wird thinking Inhaltsblöcke enthalten, gefolgt von text Inhaltsblöcken. Hier ist ein Beispiel des Standard-Antwortformats:

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

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

Wie man erweitertes Denken verwendet

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

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 16000,
    "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
    },
    "messages": [
        {
            "role": "user",
            "content": "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, mit dem type Parameter auf enabled gesetzt und den budget_tokens auf ein spezifiziertes Token-Budget für erweitertes Denken. Der budget_tokens Parameter bestimmt die maximale Anzahl von Tokens, die Claude für seinen internen Argumentationsprozess verwenden darf. In Claude 4 Modellen gilt dieses Limit für vollständige Denk-Tokens und nicht für die zusammengefasste Ausgabe. Größere Budgets können die Antwortqualität verbessern, indem sie eine gründlichere Analyse für komplexe Probleme ermöglichen, obwohl Claude möglicherweise nicht das gesamte zugewiesene Budget verwendet, insbesondere bei Bereichen über 32k. budget_tokens muss auf einen Wert kleiner als max_tokens gesetzt werden. Jedoch können Sie bei der Verwendung von verschachteltem Denken mit Tools 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 Vertriebsteam.

Streaming-Denken

Sie können erweiterte Denk-Antworten mit Server-Sent Events (SSE) streamen. Wenn Streaming für erweitertes Denken aktiviert ist, erhalten Sie Denk-Inhalte über thinking_delta Events. Für weitere Dokumentation über 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": "What is 27 * 453?"
        }
    ]
}'

In Konsole ausprobieren

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": "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"}}

// Additional thinking deltas...

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

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

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

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

// Additional text deltas...

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

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

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

Bei der Verwendung von Streaming mit aktiviertem Denken könnten Sie bemerken, dass Text manchmal in größeren Blöcken ankommt, die sich mit kleinerer, Token-für-Token-Lieferung abwechseln. Dies ist erwartetes Verhalten, insbesondere für Denk-Inhalte.Das Streaming-System muss Inhalte in Stapeln für optimale Leistung verarbeiten, was zu diesem “klumpigen” Lieferungsmuster mit möglichen Verzögerungen zwischen Streaming-Events führen kann. Wir arbeiten kontinuierlich daran, diese Erfahrung zu verbessern, mit zukünftigen Updates, die darauf fokussiert sind, Denk-Inhalte flüssiger zu streamen.

Erweitertes Denken mit Tool-Verwendung

Erweitertes Denken kann zusammen mit Tool-Verwendung verwendet werden, wodurch Claude durch Tool-Auswahl und Ergebnisverarbeitung argumentieren kann. Bei der Verwendung von erweitertem Denken mit Tool-Verwendung seien Sie sich der folgenden Einschränkungen bewusst:

Tool-Auswahl-Einschränkung: Tool-Verwendung mit Denken unterstützt nur tool_choice: {"type": "auto"} (der Standard) oder tool_choice: {"type": "none"}. Die Verwendung von tool_choice: {"type": "any"} oder tool_choice: {"type": "tool", "name": "..."} führt zu einem Fehler, da diese Optionen Tool-Verwendung erzwingen, was mit erweitertem Denken inkompatibel ist.
Bewahrung von Denk-Blöcken: Während der Tool-Verwendung müssen Sie thinking Blöcke an die API für die letzte Assistenten-Nachricht zurückgeben. Fügen Sie den vollständigen unveränderten Block zurück zur API hinzu, um die Argumentationskontinuität zu erhalten.

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

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

weather_tool = {
    "name": "get_weather",
    "description": "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 wird Denk-, Text- und tool_use-Blöcke enthalten:

{
    "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 das Gespräch 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 wird jetzt nur Text enthalten

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

Bewahrung von Denk-Blöcken

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

Während Sie thinking Blöcke aus vorherigen assistant Rollen-Wendungen weglassen können, empfehlen wir, immer alle Denk-Blöcke für jedes mehrstufige Gespräch an die API zurückzugeben. Die API wird:

Automatisch die bereitgestellten Denk-Blöcke filtern
Die relevanten Denk-Blöcke verwenden, die notwendig sind, um die Argumentation des Modells zu bewahren
Nur für die 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 Denk-Blöcken während der Tool-Verwendung aus ein paar Gründen notwendig:

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

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

Verschachteltes Denken

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

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

Um verschachteltes Denken zu aktivieren, fügen Sie den Beta-Header interleaved-thinking-2025-05-14 zu Ihrer API-Anfrage hinzu. Hier sind einige wichtige Überlegungen für verschachteltes Denken:

Mit verschachteltem Denken können die budget_tokens den max_tokens Parameter überschreiten, da es das Gesamtbudget über alle Denk-Blöcke innerhalb 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 mit dem Beta-Header interleaved-thinking-2025-05-14 unterstützt.
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()

# 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-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()

# 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.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": "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.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": "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.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": "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 dem Erhalt des Taschenrechner-Ergebnisses kann Claude wieder darüber nachdenken, was dieses Ergebnis bedeutet
Claude entscheidet dann, wie die Datenbank basierend auf dem ersten Ergebnis abgefragt werden soll
Nach dem Erhalt des Datenbank-Ergebnisses denkt Claude noch einmal über beide Ergebnisse nach, bevor es eine endgültige Antwort formuliert
Das Denk-Budget wird über alle Denk-Blöcke innerhalb der Wendung verteilt

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

Erweitertes Denken mit Prompt-Caching

Prompt-Caching mit Denken hat mehrere wichtige Überlegungen:

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

Denk-Block-Kontextentfernung

Denk-Blöcke aus vorherigen Wendungen werden aus dem Kontext entfernt, was Cache-Breakpoints beeinflussen kann
Bei der Fortsetzung von Gesprächen mit Tool-Verwendung werden Denk-Blöcke gecacht und zählen als Eingabe-Tokens, wenn sie aus dem Cache gelesen werden
Dies schafft einen Kompromiss: Während Denk-Blöcke visuell keinen Kontextfenster-Platz verbrauchen, zählen sie dennoch zu Ihrer Eingabe-Token-Verwendung, wenn sie gecacht sind
Wenn das Denken deaktiviert wird, schlagen Anfragen fehl, wenn Sie Denk-Inhalte in der aktuellen Tool-Verwendungs-Wendung übergeben. In anderen Kontexten werden Denk-Inhalte, die an die API übergeben werden, einfach ignoriert

Cache-Invalidierungsmuster

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

Während Denk-Blöcke für Caching und Kontextberechnungen entfernt werden, müssen sie bei der Fortsetzung von Gesprächen mit Tool-Verwendung bewahrt werden, insbesondere mit verschachteltem Denken.

Verstehen des Denk-Block-Caching-Verhaltens

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

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

Detaillierter 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 Benutzer-Nachricht, den ersten Denk-Block, Tool-Verwendungs-Block und das Tool-Ergebnis. Anfrage 3:

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

Da ein Nicht-Tool-Ergebnis-Benutzer-Block enthalten war, werden alle vorherigen Denk-Blö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 Markierungen
Dieses Verhalten ist konsistent, egal ob reguläres Denken oder verschachteltes Denken verwendet wird

System-Prompt-Caching (bewahrt bei Denk-Änderungen)

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}")

Nachrichten-Caching (invalidiert bei Denk-Änderungen)

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

Max Tokens und Kontextfenstergröße mit erweitertem Denken

In älteren Claude-Modellen (vor Claude Sonnet 3.7), wenn die Summe aus Prompt-Tokens und max_tokens das Kontextfenster des Modells überschritt, 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 bei Bedarf stillschweigend reduzieren. Mit Claude 3.7 und 4 Modellen wird max_tokens (was Ihr Denk-Budget einschließt, wenn Denken aktiviert ist) als striktes Limit durchgesetzt. Das System wird jetzt einen Validierungsfehler zurückgeben, wenn Prompt-Tokens + max_tokens die Kontextfenstergröße überschreitet.

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

Das Kontextfenster mit erweitertem Denken

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

Denk-Blö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 die spezialisierte Token-Verwaltung, wenn erweitertes Denken aktiviert ist:

Kontextfenster-Diagramm mit erweitertem Denken

Das effektive Kontextfenster wird berechnet als:

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

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

Das Kontextfenster mit erweitertem Denken und Tool-Verwendung

Bei der Verwendung von erweitertem Denken mit Tool-Verwendung müssen Denk-Blöcke explizit bewahrt und mit den Tool-Ergebnissen zurückgegeben werden. Die effektive Kontextfenster-Berechnung für erweitertes Denken mit Tool-Verwendung wird zu:

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

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

Kontextfenster-Diagramm mit erweitertem Denken und Tool-Verwendung

Token-Verwaltung mit erweitertem Denken

Angesichts des Kontextfenster- und max_tokens Verhaltens mit erweiterten Denk-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 vorherige Denk-Blöcke sich nicht in Ihrem Kontextfenster ansammeln

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

Denk-Verschlüsselung

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

Es ist nur strikt notwendig, Denk-Blöcke zurückzusenden, wenn Tools mit erweitertem Denken verwendet werden. Andernfalls können Sie Denk-Blöcke aus vorherigen Wendungen weglassen oder die API sie für Sie entfernen lassen, wenn Sie sie zurückgeben.Wenn Sie Denk-Blöcke zurücksenden, empfehlen wir, alles so zurückzugeben, wie Sie es erhalten haben, für Konsistenz und um potenzielle Probleme zu vermeiden.

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

Beim Streaming von Antworten wird die Signatur über ein signature_delta innerhalb eines content_block_delta Events kurz vor dem content_block_stop Event hinzugefügt.
signature Werte sind in Claude 4 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 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, wodurch Claude seine Antwort ohne Kontextverlust fortsetzen kann. Beim Erstellen kundenorientierter Anwendungen, die erweitertes Denken verwenden:

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

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

{
  "content": [
    {
      "type": "thinking",
      "thinking": "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 Sehen von redigierten Denk-Blöcken in Ihrer Ausgabe ist erwartetes Verhalten. Das Modell kann diese redigierte Argumentation immer noch verwenden, um seine Antworten zu informieren, während es Sicherheitsleitplanken aufrechterhält.Wenn Sie das Handling redigierter Denk-Blöcke in Ihrer Anwendung testen müssen, können Sie diesen speziellen Test-String als Ihren Prompt verwenden: ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB

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

Beispiel: Arbeiten mit redigierten Denk-Blöcken

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

import anthropic

client = anthropic.Anthropic()

# 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")

In Konsole ausprobieren

Unterschiede im Denken zwischen Modellversionen

Die Messages API behandelt Denken unterschiedlich zwischen Claude Sonnet 3.7 und Claude 4 Modellen, hauptsächlich im 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:

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

Leistungsüberlegungen

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

Feature-Kompatibilität

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

Nutzungsrichtlinien

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

Erste Schritte

Modelle & Preise

Mehr über Claude erfahren

Funktionen

Werkzeuge

Model Context Protocol (MCP)

Anwendungsfälle

Prompt Engineering

Testen & bewerten

Schutzmaßnahmen verstärken

Rechtszentrum

Entwickeln mit erweitertem Denken

Unterstützte Modelle

Wie erweitertes Denken funktioniert

Wie man erweitertes Denken verwendet

Zusammengefasstes Denken

Streaming-Denken

Erweitertes Denken mit Tool-Verwendung

Bewahrung von Denk-Blöcken

Verschachteltes Denken

Erweitertes Denken mit Prompt-Caching

Verstehen des Denk-Block-Caching-Verhaltens

Max Tokens und Kontextfenstergröße mit erweitertem Denken

Das Kontextfenster mit erweitertem Denken

Das Kontextfenster mit erweitertem Denken und Tool-Verwendung

Token-Verwaltung 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-Prompt-Tipps

Erste Schritte

Modelle & Preise

Mehr über Claude erfahren

Funktionen

Werkzeuge

Model Context Protocol (MCP)

Anwendungsfälle

Prompt Engineering

Testen & bewerten

Schutzmaßnahmen verstärken

Rechtszentrum

​Unterstützte Modelle

​Wie erweitertes Denken funktioniert

​Wie man erweitertes Denken verwendet

​Zusammengefasstes Denken

​Streaming-Denken

​Erweitertes Denken mit Tool-Verwendung

​Bewahrung von Denk-Blöcken

​Verschachteltes Denken

​Erweitertes Denken mit Prompt-Caching

​Verstehen des Denk-Block-Caching-Verhaltens

​Max Tokens und Kontextfenstergröße mit erweitertem Denken

​Das Kontextfenster mit erweitertem Denken

​Das Kontextfenster mit erweitertem Denken und Tool-Verwendung

​Token-Verwaltung 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-Prompt-Tipps

Unterstützte Modelle

Wie erweitertes Denken funktioniert

Wie man erweitertes Denken verwendet

Zusammengefasstes Denken

Streaming-Denken

Erweitertes Denken mit Tool-Verwendung

Bewahrung von Denk-Blöcken

Verschachteltes Denken

Erweitertes Denken mit Prompt-Caching

Verstehen des Denk-Block-Caching-Verhaltens

Max Tokens und Kontextfenstergröße mit erweitertem Denken

Das Kontextfenster mit erweitertem Denken

Das Kontextfenster mit erweitertem Denken und Tool-Verwendung

Token-Verwaltung 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