Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Nachrichten-API von Anthropic Claude
Dieser Abschnitt enthält Inferenzparameter und ein Codebeispiel für die Verwendung der Nachrichten-API Anthropic Claude.
**Topics**
+ [Übersicht über die Nachrichten-API von Anthropic Claude](#model-parameters-anthropic-claude-messages-overview)
+ [Verwendung des Tools](model-parameters-anthropic-claude-messages-tool-use.md)
+ [Erweitertes Denken](claude-messages-extended-thinking.md)
+ [Adaptives Denken](claude-messages-adaptive-thinking.md)
+ [Verschlüsselung beim Denken](claude-messages-thinking-encryption.md)
+ [Unterschiede im Denken zwischen den Modellversionen](claude-messages-thinking-differences.md)
+ [Verdichtung](claude-messages-compaction.md)
+ [Holen Sie sich validierte JSON-Ergebnisse aus Modellen](claude-messages-structured-outputs.md)
+ [Anforderung und Antwort](model-parameters-anthropic-claude-messages-request-response.md)
+ [Codebeispiele](api-inference-examples-claude-messages-code-examples.md)
+ [Unterstützte Modelle](claude-messages-supported-models.md)
## Übersicht über die Nachrichten-API von Anthropic Claude
Sie können die Nachrichten-API verwenden, um Chat-Bots oder virtuelle Assistentenanwendungen zu erstellen. Die API verwaltet den Konversationsaustausch zwischen einem Benutzer und einem Anthropic-Claude-Modell (Assistent).
**Anmerkung**
In diesem Thema wird gezeigt, wie die Anthropic Claude Nachrichten-API mit den Basisinferenzoperationen ([InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)oder [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)) verwendet wird. Wir empfehlen jedoch, die Converse-API zu verwenden, um Nachrichten in Ihrer Anwendung zu implementieren. Die Converse-API bietet einen einheitlichen Satz von Parametern, die für alle Modelle funktionieren, die Nachrichten unterstützen. Weitere Informationen finden Sie unter [Führen einer Konversation mit den Converse-API-Operationen](conversation-inference.md).
Einschränkungen gelten für die folgenden Operationen:`InvokeModel`, `InvokeModelWithResponseStream``Converse`, und`ConverseStream`. Einzelheiten finden Sie unter [API-Einschränkungen](inference-api-restrictions.md).
Anthropic trainiert Claude-Modelle so, dass sie abwechselnd als Benutzer und als Assistent kommunizieren. Wenn Sie eine neue Nachricht erstellen, geben Sie mit dem Nachrichtenparameter die vorherigen Gesprächsrunden an. Das Modell generiert dann die nächste Nachricht in der Konversation.
Jede Eingabenachricht muss ein Objekt mit einer Rolle und einem Inhalt sein. Sie können eine einzelne Benutzerrollennachricht angeben oder mehrere Benutzer- und Assistentennachrichten einbeziehen.
Wenn Sie die Technik verwenden, die Antwort von Claude vorab auszufüllen (indem Sie den Anfang von Claudes Antwort mithilfe einer endgültigen Nachricht der Assistentenrolle ausfüllen), antwortet Claude und macht dort weiter, wo Sie aufgehört haben. Bei dieser Technik gibt Claude nach wie vor eine Antwort mit der Assistentenrolle zurück.
Wenn für die endgültige Nachricht die Assistentenrolle verwendet wird, wird der Inhalt der Antwort sofort mit dem Inhalt dieser Nachricht fortgesetzt. Sie können dies verwenden, um einen Teil der Antwort des Modells einzuschränken.
Beispiel mit einer einzigen Benutzernachricht:
```
[{"role": "user", "content": "Hello, Claude"}]
```
Beispiel mit mehreren Konversationsrunden:
```
[
{"role": "user", "content": "Hello there."},
{"role": "assistant", "content": "Hi, I'm Claude. How can I help you?"},
{"role": "user", "content": "Can you explain LLMs in plain English?"},
]
```
Beispiel mit einer teilweise ausgefüllten Antwort von Claude:
```
[
{"role": "user", "content": "Please describe yourself using only JSON"},
{"role": "assistant", "content": "Here is my JSON description:\n{"},
]
```
Der Inhalt jeder Eingabenachricht kann entweder eine einzelne Zeichenfolge oder ein Array von Inhaltsblöcken sein, wobei jeder Block einen bestimmten Typ hat. Die Verwendung einer Zeichenfolge ist eine Abkürzung für ein Array aus einem Inhaltsblock vom Typ „text“. Die folgenden Eingabenachrichten sind gleichwertig:
```
{"role": "user", "content": "Hello, Claude"}
```
```
{"role": "user", "content": [{"type": "text", "text": "Hello, Claude"}]}
```
Informationen zum Erstellen von Prompts für Anthropic-Claude-Modelle finden Sie unter [Einführung in das Prompting](https://docs.anthropic.com/claude/docs/intro-to-prompting) in der Dokumentation zu Anthropic Claude. Wenn Sie bereits Prompts zur [Textvervollständigung](model-parameters-anthropic-claude-text-completion.md) haben, die Sie zur Nachrichten-API migrieren möchten, finden Sie weitere Informationen unter [Migration von Textvervollständigungen](https://docs.anthropic.com/claude/reference/migrating-from-text-completions-to-messages).
**Wichtig**
Der Timeout-Zeitraum für Inferenzaufrufe an Modelle von Anthropic Claude 3.7 Sonnet und Claude 4 beträgt 60 Minuten. Standardmäßig läuft das Timeout für AWS SDK-Clients nach 1 Minute ab. Wir empfehlen, dass Sie das Lese-Timeout Ihres AWS SDK-Clients auf mindestens 60 Minuten erhöhen. Ändern Sie beispielsweise im AWS Python Botocore SDK den Wert des Felds `read_timeout` in [botocore.config](https://botocore.amazonaws.com/v1/documentation/api/latest/reference/config.html#) auf mindestens 3 600.
### System-Prompts
Sie können der Anfrage auch einen System-Prompt hinzufügen. Mit einem System-Prompt können Sie Anthropic Claude Kontextinformationen und Anweisungen bereitstellen, wie etwa die Angabe eines bestimmten Ziels oder einer bestimmten Rolle. Geben Sie im `system`-Feld einen System-Prompt an, wie im folgenden Beispiel dargestellt.
```
"system": "You are Claude, an AI assistant created by Anthropic to be helpful,
harmless, and honest. Your goal is to provide informative and substantive responses
to queries while avoiding potential harms."
```
Weitere Informationen finden Sie unter [System-Prompts](https://docs.anthropic.com/en/docs/system-prompts) in der Anthropic-Dokumentation.
### Multimodale Prompts
Ein multimodaler Prompt kombiniert mehrere Modalitäten (Bilder und Text) in einem einzigen Prompt. Sie geben die Modalitäten im Eingabefeld `content` an. Das folgende Beispiel zeigt, wie Sie Anthropic Claude dazu auffordern können, den Inhalt eines bereitgestellten Bildes zu beschreiben. Einen Beispielcode finden Sie unter [Multimodale Code-Beispiele](api-inference-examples-claude-messages-code-examples.md#api-inference-examples-claude-multimodal-code-example).
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/jpeg",
"data": "iVBORw..."
}
},
{
"type": "text",
"text": "What's in these images?"
}
]
}
]
}
```
Jedes Bild, das Sie in eine Anfrage aufnehmen, wird auf Ihre Token-Nutzung angerechnet. Weitere Informationen finden Sie unter [Kosten für Bilder](https://docs.anthropic.com/claude/docs/vision#image-costs) in der Anthropic-Dokumentation.
# Verwendung des Tools
**Warnung**
Einige der folgenden Funktionen werden, wie angegeben, in der Betaversion angeboten. Diese Funktionen werden Ihnen als „Beta-Service“ gemäß der Definition in den AWS Servicebedingungen zur Verfügung gestellt. Es unterliegt Ihrer Vereinbarung mit AWS und den AWS Servicebedingungen sowie der geltenden Muster-EULA.
Bei Anthropic-Claude-Modellen können Sie ein Tool angeben, mit dem das Modell eine Nachricht beantworten kann. Sie könnten beispielsweise ein Tool angeben, das den beliebtesten Song eines Radiosenders ermittelt. Wenn der Benutzer die Nachricht weitergibt *Was ist der beliebteste Song bei WZPZ?*, stellt das Modell fest, dass das von Ihnen angegebene Tool bei der Beantwortung der Frage helfen kann. In seiner Antwort fordert das Modell Sie auf, das Tool in seinem Namen auszuführen. Anschließend führen Sie das Tool aus und übergeben das Tool-Ergebnis an das Modell, das dann eine Antwort für die ursprüngliche Nachricht generiert. Weitere Informationen finden Sie unter [Verwendung des Tools (Funktionsaufruf)](https://docs.anthropic.com/en/docs/tool-use) in der Anthropic-Claude-Dokumentation.
**Tipp**
Es wird empfohlen, die Converse-API zur Integration der Tool-Nutzung in Ihre Anwendung zu verwenden. Weitere Informationen finden Sie unter [Verwenden eines Tools, um eine Amazon-Bedrock-Modellantwort zu vervollständigen](tool-use.md).
**Wichtig**
Claude Sonnet 4.5 behält jetzt die absichtliche Formatierung der Zeichenfolgenparameter für Tool-Aufrufe bei. Bisher wurden nachfolgende Zeilenumbrüche in Zeichenfolgenparametern manchmal fälschlicherweise entfernt. Mit dieser Korrektur wird sichergestellt, dass Tools, die eine genaue Formatierung erfordern (wie Text-Editoren), Parameter genau wie vorgesehen erhalten. Dies ist eine behind-the-scenes Verbesserung, für die keine API-Änderungen erforderlich sind. Tools mit Zeichenfolgenparametern können jetzt jedoch Werte mit abschließenden Zeilenumbrüchen empfangen, die zuvor entfernt wurden.
**Anmerkung**
Claude Sonnet 4.5 beinhaltet automatische Optimierungen zur Verbesserung der Modellleistung. Durch diese Optimierungen können Anfragen kleine Mengen an Token hinzugefügt werden. Diese vom System hinzugefügten Token werden Ihnen jedoch nicht in Rechnung gestellt.
Sie geben die Tools, die Sie einem Modell zur Verfügung stellen möchten, im Feld `tools` an. Das folgende Beispiel bezieht sich auf ein Tool, das den beliebtesten Song eines Radiosenders ermittelt.
```
[
{
"name": "top_song",
"description": "Get the most popular song played on a radio station.",
"input_schema": {
"type": "object",
"properties": {
"sign": {
"type": "string",
"description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP."
}
},
"required": [
"sign"
]
}
}
]
```
Wenn das Modell ein Tool benötigt, um eine Antwort auf eine Nachricht zu generieren, gibt es Informationen über das angeforderte Tool und die Eingabe für das Tool im `content`-Nachrichtenfeld zurück. Außerdem wird der Grund für den Stopp der Antwort auf `tool_use` festgelegt.
```
{
"id": "msg_bdrk_01USsY5m3XRUF4FCppHP8KBx",
"type": "message",
"role": "assistant",
"model": "claude-3-sonnet-20240229",
"stop_sequence": null,
"usage": {
"input_tokens": 375,
"output_tokens": 36
},
"content": [
{
"type": "tool_use",
"id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
"name": "top_song",
"input": {
"sign": "WZPZ"
}
}
],
"stop_reason": "tool_use"
}
```
In Ihrem Code rufen Sie das Tool im Namen des Tools auf. Anschließend übergeben Sie das Tool-Ergebnis (`tool_result`) in einer Benutzernachricht an das Modell.
```
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_bdrk_01SnXQc6YVWD8Dom5jz7KhHy",
"content": "Elemental Hotel"
}
]
}
```
In seiner Antwort verwendet das Modell das Tool-Ergebnis, um eine Antwort auf die ursprüngliche Nachricht zu generieren.
```
{
"id": "msg_bdrk_012AaqvTiKuUSc6WadhUkDLP",
"type": "message",
"role": "assistant",
"model": "claude-3-sonnet-20240229",
"content": [
{
"type": "text",
"text": "According to the tool, the most popular song played on radio station WZPZ is \"Elemental Hotel\"."
}
],
"stop_reason": "end_turn"
}
```
## Differenziertes Tool-Streaming
Differenziertes Tool-Streaming ist eine Anthropic-Claude-Modellfunktion, die mit Claude Sonnet 4.5, Claude Haiku 4.5, Claude Sonnet 4 und Claude Opus 4 verfügbar ist. Mit differenziertem Tool-Streaming können Claude-Entwickler Parameter für die Verwendung von Tools ohne Pufferung oder JSON-Validierung streamen, wodurch die Latenz beim Empfang großer Parameter reduziert wird.
**Anmerkung**
Wenn Sie differenziertes Tool-Streaming verwenden, erhalten Sie möglicherweise ungültige oder unvollständige JSON-Eingaben. Bitte achten Sie darauf, diese Grenzfälle in Ihrem Code zu berücksichtigen.
Wenn Sie dieses Feature nutzen möchten, fügen Sie einfach den Header `fine-grained-tool-streaming-2025-05-14` zu einer Anfrage zur Verwendung eines Tools hinzu.
Hier ist ein Beispiel dafür, wie der Header beim differenzierten Tool-Streaming angegeben werden kann:
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"anthropic_beta": ["fine-grained-tool-streaming-2025-05-14"],
"messages": [
{
"role": "user",
"content": "Can you write a long poem and make a file called poem.txt?"
}
],
"tools": [
{
"name": "make_file",
"description": "Write text to a file",
"input_schema": {
"type": "object",
"properties": {
"filename": {
"type": "string",
"description": "The filename to write text to"
},
"lines_of_text": {
"type": "array",
"description": "An array of lines of text to write to the file"
}
},
"required": [
"filename",
"lines_of_text"
]
}
}
]
}
```
In diesem Beispiel ermöglicht es Claude durch differenziertes Tool-Streaming, die Zeilen eines langen Gedichts ohne Pufferung in den Tool-Aufruf `make_file` zu streamen, um zu überprüfen, ob es sich bei dem Parameter `lines_of_text` um einen gültigen JSON-Wert handelt. Das bedeutet, dass Sie den Parameter-Stream sehen können, sobald er eingeht, ohne darauf warten zu müssen, dass der gesamte Parameter gepuffert und validiert ist.
Bei differenziertem Tool-Streaming beginnen die Chunks, die das Tool verwenden, schneller zu streamen. Sie sind oft länger und enthalten weniger Wortumbrüche. Dies ist auf Unterschiede im Chunking-Verhalten zurückzuführen.
Ein Beispiel ohne differenziertes Streaming (Verzögerung von 15 Sekunden):
```
Chunk 1: '{"'
Chunk 2: 'query": "Ty'
Chunk 3: 'peScri'
Chunk 4: 'pt 5.0 5.1 '
Chunk 5: '5.2 5'
Chunk 6: '.3'
Chunk 8: ' new f'
Chunk 9: 'eatur'
...
```
Mit differenziertem Streaming (3 Sekunden Verzögerung):
```
Chunk 1: '{"query": "TypeScript 5.0 5.1 5.2 5.3'
Chunk 2: ' new features comparison'
```
**Anmerkung**
Da beim differenzierten Streaming Parameter ohne Pufferung oder JSON-Validierung gesendet werden, gibt es keine Garantie dafür, dass der resultierende Stream in einer gültigen JSON-Zeichenfolge abgeschlossen wird. Insbesondere wenn der Stopp-Grund `max_tokens` erreicht ist, kann es sein, dass der Stream nach der Hälfte eines Parameters endet und unvollständig ist. In der Regel müssen Sie spezielle Support-Programme schreiben, um zu regeln, was passiert, wenn der Wert erreicht `max_tokens` ist.
## Computer Use (Beta)
Computer Use ist eine Funktion des Anthropic-Claude-Modells (in der Betaversion), die mit Claude 3.5 Sonnet v2, Claude Sonnet 4.5, Claude Haiku 4.5, Claude 3.7 Sonnet, Claude Sonnet 4 und Claude Opus 4 verfügbar ist. Mithilfe von Computer Use kann Claude Aufgaben durch grundlegende GUI-Aktionen automatisieren.
**Warnung**
Die Funktion zur Computernutzung wird Ihnen als „Beta-Service“ gemäß der Definition in den AWS Servicebedingungen zur Verfügung gestellt. Sie unterliegt Ihrer Vereinbarung mit AWS und den AWS Servicebedingungen sowie der geltenden Muster-EULA. Bitte beachten Sie, dass die Computer-Use-API besondere Risiken birgt, die sich von Standard-API-Features oder Chat-Schnittstellen unterscheiden. Diese Risiken steigen, wenn die Computer-Use-API für die Interaktion mit dem Internet verwendet wird. Zur Minimierung der Risiken sollten Sie folgende Vorsichtsmaßnahmen in Betracht ziehen:
Betreiben Sie das Computer-Use-Feature in einer speziellen virtuellen Maschine oder in einem Container mit minimalen Rechten, um gezielte oder versehentliche Angriffe auf das System zu verhindern.
Zur Verhinderung von Informationsdiebstahl sollten Sie der Computer-Use-API keinen Zugriff auf sensible Konten oder Daten gewähren.
Beschränkung des APIs Internetzugangs zur Computernutzung auf die erforderlichen Domänen, um das Risiko bösartiger Inhalte zu verringern.
Um eine adäquate Aufsicht zu gewährleisten, sollte bei sensiblen Aufgaben (wie Entscheidungen, die erhebliche Auswirkungen auf die reale Welt haben könnten) sowie Aufgaben, die eine ausdrückliche Zustimmung erfordern (wie die Annahme von Cookies, die Ausführung von Finanztransaktionen oder die Zustimmung zu Nutzungsbedingungen), ein HITL einbezogen werden.
Alle Inhalte, für die Sie Claude Anzeige- oder Zugriffsberechtigungen erteilen, können möglicherweise Anweisungen außer Kraft setzen oder Claude zu Fehlern oder unbeabsichtigten Aktionen verleiten. Daher ist es wichtig, angemessene Vorsichtsmaßnahmen zu treffen und Claude z. B. von sensiblen Oberflächen fernzuhalten, auch zur Vermeidung von Risiken im Zusammenhang mit einer Promptinjektion. Bevor Sie die Computer-Use-Features in eigenen Produkten aktivieren oder die erforderlichen Genehmigungen anfordern, informieren Sie die Endbenutzer bitte über alle einschlägigen Risiken und holen Sie gegebenenfalls deren Zustimmung ein.
Die Computer-Use-API bietet mehrere vordefinierte Computer-Use-Tools, die Sie verwenden können. Sie können dann einen Prompt mit Ihrer Anfrage erstellen, z. B. „Sende Ben eine E-Mail mit den Notizen von meinem letzten Treffen“ und einen Screenshot (falls erforderlich). Die Antwort enthält eine Liste von `tool_use`-Aktionen im JSON-Format (z. B. scroll\$1down, left\$1button\$1press, screenshot). Ihr Code führt die Computeraktionen aus und stellt Claude einen Screenshot zur Verfügung, der die Ausgaben zeigt (falls angefordert).
Seit Veröffentlichung von Claude 3.5 v2 wurde der Parameter „tools“ aktualisiert und akzeptiert nun polymorphe Tooltypen. Zu ihrer Unterscheidung wurde eine neue `tool.type`-Eigenschaft hinzugefügt. Der Parameter `type` ist optional. Wenn er weggelassen wird, wird davon ausgegangen, dass es sich bei dem Tool um ein benutzerdefiniertes Tool handelt (bisher der einzige unterstützte Tooltyp). Für den Zugriff auf Computer-Use-Feature müssen Sie den `anthropic_beta`-Parameter mit einer entsprechenden Aufzählung verwenden, deren Wert von der verwendeten Modellversion abhängt. Weitere Informationen können Sie der folgenden Tabelle entnehmen.
Nur Anfragen, die mit diesem Parameter und enum gestellt wurden, können die Computer-Use-Tools verwenden. Er kann wie folgt angegeben werden: `"anthropic_beta": ["computer-use-2025-01-24"]`.
| Modell | Beta-Header |
| --- | --- |
| Claude Opus4.5 Claude Opus4.1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet | computer-use-2025-01-24 |
| Claude 3.5 Sonnet v2 | computer-use-2024-10-22 |
Weitere Informationen finden Sie unter [Computer Use (Beta)](https://docs.anthropic.com/en/docs/build-with-claude/computer-use) in der Anthropic-Dokumentation.
Im Folgenden finden Sie ein Antwortbeispiel, bei dem davon ausgegangen wird, dass die Anfrage einen Screenshot Ihres Desktops mit einem Firefox-Symbol enthielt.
```
{
"id": "msg_123",
"type": "message",
"role": "assistant",
"model": "anthropic.claude-3-5-sonnet-20241022-v2:0",
"content": [
{
"type": "text",
"text": "I see the Firefox icon. Let me click on it and then navigate to a weather website."
},
{
"type": "tool_use",
"id": "toolu_123",
"name": "computer",
"input": {
"action": "mouse_move",
"coordinate": [
708,
736
]
}
},
{
"type": "tool_use",
"id": "toolu_234",
"name": "computer",
"input": {
"action": "left_click"
}
}
],
"stop_reason": "tool_use",
"stop_sequence": null,
"usage": {
"input_tokens": 3391,
"output_tokens": 132
}
}
```
## Anthropic-definierte Tools
Anthropic bietet eine Reihe von Tools, mit denen bestimmte Claude-Modelle Computer effektiv nutzen können. Bei der Angabe eines Anthropic-definierten Tools sind die Felder `description` und `tool_schema` nicht erforderlich oder zulässig. Anthropic-definierte Tools werden durch Anthropic definiert. Sie müssen die Ergebnisse des Tools jedoch explizit auswerten und `tool_results` an Claude zurückgeben. Wie bei jedem Tool führt das Modell das Tool nicht automatisch aus. Jedes Anthropic-definierte Tool hat Versionen, die für bestimmte Modelle Claude 3.5 Sonnet (neu) und Claude 3.7 Sonnet optimiert sind:
| Modell | Tool | Hinweise |
| --- | --- | --- |
| ClaudeClaude Opus4.1 ClaudeClaude Opus4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 | {
"type": "text_editor_20250124",
"name": "str_replace_based_edit_tool"
} | Aktualisierung des bestehenden Tools `str_replace_editor` |
| Claude 3.7 Sonnet | {
"type": "computer_20250124",
"name": "computer"
} | Beinhaltet neue Aktionen für eine genauere Steuerung |
| Claude 3.7 Sonnet | {
"type": "text_editor_20250124",
"name": "str_replace_editor"
} | Gleiche Funktionen wie in der Version 20241022 |
| Claude 3.5 Sonnet v2 | {
"type": "bash_20250124",
"name": "bash"
} | Gleiche Funktionen wie in der Version 20241022 |
| Claude 3.5 Sonnet v2 | {
"type": "text_editor_20241022",
"name": "str_replace_editor"
} |
| Claude 3.5 Sonnet v2 | {
"type": "bash_20241022",
"name": "bash"
} |
| Claude 3.5 Sonnet v2 | {
"type": "computer_20241022",
"name": "computer"
} |
Das Feld `type` identifiziert das Tools und seine Parameter zu Validierungszwecken. Das Feld `name` ist der Tool-Name, der dem Modell zur Verfügung gestellt wird.
Wenn Sie das Modell auffordern möchten, eines dieser Tools zu verwenden, können Sie das Tool explizit anhand des Felds `name` referenzieren. Das Feld `name` muss innerhalb der Tool-Liste eindeutig sein. Sie können ein Tool nicht mit demselben `name` definieren wie ein Anthropic-definiertes Tool in demselben API-Aufruf.
## Automatisches Löschen von Tool-Aufrufen (Beta)
**Warnung**
Das automatische Löschen von Tool-Aufrufen wird als „Beta-Service“ gemäß der Definition in den AWS Servicebedingungen zur Verfügung gestellt.
**Anmerkung**
Diese Funktion wird derzeit von Claude Sonnet 4/4.5, Claude Haiku 4.5 und Claude Opus 4/4.1/4.5 unterstützt.
Das automatische Löschen von Werkzeugaufrufen ist eine Funktion des Modells Anthropic Claude (in der Beta-Phase). Mit dieser Funktion kann Claude alte Ergebnisse der Werkzeugnutzung automatisch löschen, wenn Sie sich den Token-Grenzwerten nähern, was ein effizienteres Kontextmanagement in Szenarien mit mehreren Werkzeugeinsätzen ermöglicht. Wenn Sie das Löschen von Tool-Aufrufen nutzen möchten, müssen Sie dem Anforderungsparameter anthropic\$1beta in der Liste der Beta-Header `context-management-2025-06-27` hinzufügen. Sie müssen außerdem die Verwendung von angeben `clear_tool_uses_20250919` und aus den folgenden Konfigurationsoptionen auswählen.
Dies sind die verfügbaren Steuerelemente für die Kontextmanagement-Strategie von `clear_tool_uses_20250919`. Alle sind optional oder haben Standardwerte:
| **Konfigurationsoption** | **Beschreibung** |
| --- | --- |
| `trigger` Standard: 100 000 Eingabe-Token | Definiert, wann die Strategie zur Kontextbearbeitung aktiviert wird. Sobald der Prompt diesen Schwellenwert überschreitet, beginnt der Löschvorgang. Sie können diesen Wert entweder in input\$1tokens oder tool\$1uses angeben. |
| `keep` Standard: 3 Tool-Anwendungen | Definiert, wie viele aktuelle use/result Werkzeugpaare nach dem Löschen beibehalten werden sollen. Die API entfernt zuerst die ältesten Tool-Interaktionen, wobei die neuesten beibehalten werden. Dies ist hilfreich, wenn das Modell Zugriff auf die letzten Tool-Interaktionen benötigt, um die Konversation effektiv fortzusetzen. |
| `clear_at_least` (optional) | Dadurch wird sichergestellt, dass bei jeder Aktivierung der Strategie eine Mindestanzahl an Token gelöscht wird. Wenn die API nicht mindestens die angegebene Menge löschen kann, wird die Strategie nicht angewendet. Dies ist nützlich, um festzustellen, ob es sich lohnt, den Prompt-Cache für das Löschen von Kontexten zu unterbrechen. |
| `exclude_tools` (optional) | Liste der Tool-Namen, deren Tool-Anwendungen und Ergebnisse niemals gelöscht werden sollten. Dies ist nützlich, um wichtigen Kontext zu bewahren. |
| `clear_tool_inputs`: (optional, Standard falsch) | Steuert, ob die Tool-Aufruf-Parameter zusammen mit den Tool-Ergebnissen gelöscht werden. Standardmäßig werden nur die Tool-Ergebnisse gelöscht, wobei die ursprünglichen Tool-Aufrufe von Claude sichtbar bleiben, sodass Claude auch nach dem Entfernen der Ergebnisse sehen kann, welche Operationen ausgeführt wurden. |
**Anmerkung**
Durch das Löschen von Tools wird Ihr Cache ungültig, wenn Ihre Präfixe Ihre Tools enthalten.
------
#### [ Request ]
```
response = client.beta.messages.create(
betas=["context-management-2025-06-27"],
model="claude-sonnet-4-20250514",
max_tokens=4096,
messages=[
{
"role": "user",
"content": "Create a simple command line calculator app using Python"
}
],
tools=[
{
"type": "text_editor_20250728",
"name": "str_replace_based_edit_tool",
"max_characters": 10000
},
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 3
}
],
extra_body={
"context_management": {
"edits": [
{
"type": "clear_tool_uses_20250919",
# The below parameters are OPTIONAL:
# Trigger clearing when threshold is exceeded
"trigger": {
"type": "input_tokens",
"value": 30000
},
# Number of tool uses to keep after clearing
"keep": {
"type": "tool_uses",
"value": 3
},
# Optional: Clear at least this many tokens
"clear_at_least": {
"type": "input_tokens",
"value": 5000
},
# Exclude these tools uses from being cleared
"exclude_tools": ["web_search"]
}
]
}
}
)
```
------
#### [ Response ]
```
{
"id": "msg_123",
"type": "message",
"role": "assistant",
"content": [
{
"type": "tool_use",
"id": "toolu_456",
"name": "data_analyzer",
"input": {
"data": "sample data"
}
}
],
"context_management": {
"applied_edits": [
{
"type": "clear_tool_uses_20250919",
"cleared_tool_uses": 8, # Number of tool use/result pairs that were cleared
"cleared_input_tokens": 50000 # Total number of input tokens removed from the prompt
}
]
}
"stop_reason": "tool_use",
"usage": {
"input_tokens": 150,
"output_tokens": 50
}
}
```
------
#### [ Streaming Response ]
```
data: {"type": "message_start", "message": {"id": "msg_123", "type": "message", "role": "assistant"}}
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "tool_use", "id": "toolu_456", "name": "data_analyzer", "input": {}}}
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "input_json_delta", "partial_json": "{\"data\": \"sample"}}
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "input_json_delta", "partial_json": " data\"}"}}
data: {"type": "content_block_stop", "index": 0}
data: {"type": "message_delta", "delta": {"stop_reason": "tool_use"}}
data: {"type": "message_stop"}
{
"type": "message_delta",
"delta": {
"stop_reason": "end_turn",
"stop_sequence": null,
},
"usage": {
"output_tokens": 1024
},
"context_management": {
"applied_edits": [...],
}
}
```
------
**Anmerkung**
Bedrock unterstützt derzeit kein `clear_tool_uses_20250919` Kontextmanagement auf der CountTokens API.
## Speicher-Tool (Beta)
**Warnung**
Memory Tool wird als „Beta-Service“ gemäß der Definition in den AWS Servicebedingungen zur Verfügung gestellt.
Claude Sonnet 4.5 umfasst ein neues Speicher-Tool, das Kunden die Möglichkeit bietet, den Speicher für alle Konversationen zu verwalten. Mit diesem Feature können Kunden Claude ermöglichen, Informationen außerhalb des Kontextfensters abzurufen, indem sie Zugriff auf ein lokales Verzeichnis gewähren. Dieses Feature wird als Beta-Feature verfügbar sein. Wenn Sie dieses Feature nutzen möchten, müssen Sie den Beta-Header `context-management-2025-06-27` verwenden.
Tool-Definition:
```
{
"type": "memory_20250818",
"name": "memory"
}
```
Beispielanforderung:
```
{
"max_tokens": 2048,
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["context-management-2025-06-27"],
"tools": [{
"type": "memory_20250818",
"name": "memory"
}],
"messages": [
{
"role": "user",
"content": [{"type": "text", "text": "Remember that my favorite color is blue and I work at Amazon?"}]
}
]
}
```
Beispielantwort:
```
{
"id": "msg_vrtx_014mQ5ficCRB6PEa5k5sKqHd",
"type": "message",
"role": "assistant",
"model": "claude-sonnet-4-20250514",
"content": [
{
"type": "text",
"text": "I'll start by checking your memory directory and then record this important information about you."
},
{
"type": "tool_use",
"id": "toolu_vrtx_01EU1UrCDigyPMRntr3VYvUB",
"name": "memory",
"input": {
"command": "view",
"path": "/memories"
}
}
],
"stop_reason": "tool_use",
"stop_sequence": null,
"usage": {
"input_tokens": 1403,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 0,
"output_tokens": 87
},
"context_management": {
"applied_edits": []
}
}
```
## Überlegungen zu den Kosten bei der Tool-Nutzung
Die Preise für Anfragen zur Nutzung von Tools basieren auf folgenden Faktoren:
1. Die Gesamtzahl der an das Modell gesendeten Eingabe-Token (einschließlich des Parameters tools)
1. Die Anzahl der generierten Ausgabe-Token
Tools haben denselben Preis wie alle anderen Claude-API-Anfragen, enthalten jedoch zusätzliche Token pro Anfrage. Die zusätzlichen Token, die sich aus der Nutzung des Tools ergeben, stammen aus den folgenden Quellen:
+ Parameter `tools` in den API-Anfragen. Zum Beispiel Tool-Namen, Beschreibungen und Schemas.
+ Alle `tool_use`-Inhaltsblöcke in API-Anfragen und -Antworten.
+ Alle `tool_result`-Inhaltsblöcke in API-Anfragen.
Wenn Sie Tools nutzen, enthalten die Anthropic-Modelle automatisch einen speziellen System-Prompt, der die Verwendung von Tools ermöglicht. Die Anzahl der für jedes Modell erforderlichen Tool-Nutzungstoken ist in der folgenden Tabelle aufgeführt. In dieser Tabelle sind die zuvor beschriebenen zusätzlichen Token nicht enthalten. Beachten Sie, dass in dieser Tabelle davon ausgegangen wird, dass mindestens ein Tool bereitgestellt wird. Wenn keine Tools bereitgestellt werden, werden bei der Toolauswahl „Keine“ 0 zusätzliche System-Prompt-Token verwendet.
| Modell | Auswahl des Tools | Anzahl der System-Prompt-Token für die Tool-Nutzung |
| --- | --- | --- |
| Claude Opus4.5 Claude Opus4.1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet Claude 3.5 Sonnet v2 | auto oder none | 346 |
| Claude Opus4,5 Claude Opus4.1 Claude Opus 4 Claude Sonnet 4.5 Claude Haiku 4.5 Claude Sonnet 4 Claude 3.7 Sonnet Claude 3.5 Sonnet v2 | any oder tool | 313 |
| Claude 3.5 Sonnet | auto oder none | 294 |
| Claude 3.5 Sonnet | any oder tool | 261 |
| Claude 3 Opus | auto oder none | 530 |
| Claude 3 Opus | any oder tool | 281 |
| Claude 3 Sonnet | auto oder none | 159 |
| Claude 3 Sonnet | any oder tool | 235 |
| Claude 3 Haiku | auto oder none | 264 |
| Claude 3 Haiku | any oder tool | 340 |
## Tool zur Werkzeugsuche (Beta)
Das Tool Search Tool ermöglicht Claude die Arbeit mit Hunderten oder sogar Tausenden von Tools, ohne dass alle ihre Definitionen im Voraus in das Kontextfenster geladen werden müssen. Anstatt alle Tools sofort zu deklarieren, können Sie sie mit `defer_loading: true` markieren und über den Claude Werkzeugsuchmechanismus nur die Tools finden und laden, die Sie benötigen.
Um auf diese Funktion zugreifen zu können, müssen Sie den Beta-Header `tool-search-tool-2025-10-19` verwenden. Beachten Sie, dass diese Funktion derzeit nur über [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)und verfügbar ist [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) APIs.
Tool-Definition:
```
{
"type": "tool_search_tool_regex",
"name": "tool_search_tool_regex"
}
```
Anfragebeispiel:
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": [
"tool-search-tool-2025-10-19"
],
"max_tokens": 4096,
"tools": [{
"type": "tool_search_tool_regex",
"name": "tool_search_tool_regex"
},
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": ["location"]
},
"defer_loading": true
},
{
"name": "search_files",
"description": "Search through files in the workspace",
"input_schema": {
"type": "object",
"properties": {
"query": {
"type": "string"
},
"file_types": {
"type": "array",
"items": {
"type": "string"
}
}
},
"required": ["query"]
},
"defer_loading": true
}
],
"messages": [{
"role": "user",
"content": "What's the weather in Seattle?"
}]
}
```
Beispiel für eine Antwort
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I'll search for the appropriate tools to help with this task."
},
{
"type": "server_tool_use",
"id": "srvtoolu_01ABC123",
"name": "tool_search_tool_regex",
"input": {
"pattern": "weather"
}
},
{
"type": "tool_search_tool_result",
"tool_use_id": "srvtoolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
},
{
"type": "text",
"text": "Now I can check the weather."
},
{
"type": "tool_use",
"id": "toolu_01XYZ789",
"name": "get_weather",
"input": {
"location": "Seattle",
"unit": "fahrenheit"
}
}
],
"stop_reason": "tool_use"
}
```
Beispiel für ein Streaming
```
# Event 1: content_block_start(with complete server_tool_use block) {
"type": "content_block_start",
"index": 0,
"content_block": {
"type": "server_tool_use",
"id": "srvtoolu_01ABC123",
"name": "tool_search_tool_regex"
}
}
# Event 2: content_block_delta(input JSON streamed) {
"type": "content_block_delta",
"index": 0,
"delta": {
"type": "input_json_delta",
"partial_json": "{\"regex\": \".*weather.*\"}"
}
}
# Event 3: content_block_stop(tool_use complete) {
"type": "content_block_stop",
"index": 0
}
# Event 4: content_block_start(COMPLETE result in single chunk) {
"type": "content_block_start",
"index": 1,
"content_block": {
"type": "tool_search_tool_result",
"tool_use_id": "srvtoolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
}
}
# Event 5: content_block_stop(result complete) {
"type": "content_block_stop",
"index": 1
}
```
**Suchwerkzeuge für benutzerdefinierte Tools**
Sie können benutzerdefinierte Tools für die Werkzeugsuche implementieren (z. B. mithilfe von Einbettungen), indem Sie ein Tool definieren, das Blöcke zurückgibt`tool_reference`. Das benutzerdefinierte Tool muss dies haben, `defer_loading: false` während andere Tools dies tun sollten. `defer_loading: true` Wenn Sie Ihr eigenes Tool für die Werkzeugsuche definieren, sollte es ein Werkzeugergebnis mit `tool_reference` Inhaltsblöcken zurückgeben, die auf die Tools verweisen, die Sie verwenden Claude möchten.
Das erwartete, vom Kunden definierte Antwortformat für das Ergebnis des Tool Search Tools:
```
{
"type": "tool_result",
"tool_use_id": "toolu_01ABC123",
"content": [{
"type": "tool_reference",
"tool_name": "get_weather"
},
{
"type": "tool_reference",
"tool_name": "weather_forecast"
}
]
}
```
Das `tool_name` muss mit einem in der Anfrage definierten Tool übereinstimmen. `defer_loading: true` Claude hat dann Zugriff auf die vollständigen Schemas dieser Tools.
**Benutzerdefinierte Suchwerkzeuge — Detailliertes Beispiel**
Sie können benutzerdefinierte Tools zur Werkzeugsuche implementieren (z. B. mithilfe von Einbettungen oder semantischer Suche), indem Sie ein Tool definieren, das Blöcke zurückgibt. `tool_reference` Dies ermöglicht ausgeklügelte Mechanismen zur Werkzeugerkennung, die über den Regex-Abgleich hinausgehen.
Beispiel mit benutzerdefiniertem TST anfordern:
```
{
"model": "claude-sonnet-4-5-20250929",
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["tool-search-tool-2025-10-19"],
"max_tokens": 4096,
"tools": [{
"name": "semantic_tool_search",
"description": "Search for available tools using semantic similarity. Returns the most relevant tools for the given query.",
"input_schema": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Natural language description of what kind of tool is needed"
},
"top_k": {
"type": "integer",
"description": "Number of tools to return (default: 5)"
}
},
"required": ["query"]
},
"defer_loading": false
},
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": ["location"]
},
"defer_loading": true
},
{
"name": "search_flights",
"description": "Search for available flights between locations",
"input_schema": {
"type": "object",
"properties": {
"origin": {
"type": "string"
},
"destination": {
"type": "string"
},
"date": {
"type": "string"
}
},
"required": ["origin", "destination", "date"]
},
"defer_loading": true
}
],
"messages": [{
"role": "user",
"content": "What's the weather forecast in Seattle for the next 3 days?"
}]
}
```
ClaudeAntwort (Aufruf von benutzerdefiniertem TST):
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I'll search for the appropriate tools to help with weather information."
},
{
"type": "tool_use",
"id": "toolu_01ABC123",
"name": "semantic_tool_search",
"input": {
"query": "weather forecast multiple days",
"top_k": 3
}
}
],
"stop_reason": "tool_use"
}
```
**Vom Kunden bereitgestelltes Werkzeugergebnis**
Nach der Durchführung einer semantischen Suche in der Werkzeugbibliothek gibt der Kunde passende Werkzeugreferenzen zurück:
```
{
"role": "user",
"content": [{
"type": "tool_search_tool_result",
"tool_use_id": "toolu_01ABC123",
"content": {
"type": "tool_search_tool_search_result",
"tool_references": [{
"type": "tool_reference",
"tool_name": "get_weather"
}]
}
}]
}
```
ClaudeNachverfolgung (unter Verwendung des entdeckten Tools)
```
{
"role": "assistant",
"content": [{
"type": "text",
"text": "I found the forecast tool. Let me get the weather forecast for Seattle."
},
{
"type": "tool_use",
"id": "toolu_01DEF456",
"name": "get_weather",
"input": {
"location": "Seattle, WA"
}
}
],
"stop_reason": "tool_use"
}
```
**Fehlerbehandlung**
+ Die Einstellung `defer_loading: true` für alle Tools (einschließlich des Tool Search Tools) führt zu einem 400-Fehler.
+ Die Übergabe von a `tool_reference` ohne entsprechende Werkzeugdefinition führt zu einem 400-Fehler
## Beispiele für die Verwendung von Tools (Beta)
Claude Opus4.5 unterstützt vom Benutzer bereitgestellte Beispiele in Werkzeugdefinitionen, um die Leistung Claude der Werkzeugnutzung zu erhöhen. Sie können Beispiele als vollständige Funktionsaufrufe bereitstellen, die genau so formatiert sind, wie es bei echten LLM-Ausgaben der Fall wäre, ohne dass eine Übersetzung in ein anderes Format erforderlich ist. Um diese Funktion nutzen zu können, müssen Sie den Beta-Header übergeben. `tool-examples-2025-10-29`
Beispiel für eine Werkzeugdefinition:
```
{
"name": "get_weather",
"description": "Get the current weather in a given location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "Temperature unit"
}
},
"required": ["location"]
},
"input_examples": [{
"location": "San Francisco, CA",
"unit": "fahrenheit"
},
{
"location": "Tokyo, Japan",
"unit": "celsius"
},
{
"location": "New York, NY"
}
]
}
```
**Regeln für die Validierung**
+ Schemakonformität: Jedes Beispiel in `input_examples` muss gemäß den Angaben des `input_schema` Tools gültig sein.
+ Erforderliche Felder müssen in mindestens einem Beispiel vorhanden sein.
+ Feldtypen müssen dem Schema entsprechen.
+ Aufzählungswerte müssen aus dem zulässigen Satz stammen.
+ Wenn die Überprüfung fehlschlägt, geben Sie einen 400-Fehler mit Details darüber zurück, in welchem Beispiel die Überprüfung fehlgeschlagen ist.
+ Array-Anforderungen: `input_examples` muss ein Array sein (kann leer sein).
+ Ein leeres Array `[]` ist gültig und entspricht dem Auslassen des Felds.
+ Ein einzelnes Beispiel muss immer noch in ein Array eingeschlossen werden: `[{...}]`
+ Längenbeschränkung: Beginnen Sie mit einem Limit von 20 Beispielen pro Werkzeugdefinition.
Beispiele für Fehler:
```
// Invalid: Example doesn't match schema (missing required field)
{
"type": "invalid_request_error",
"message": "Tool 'get_weather' input_examples[0] is invalid: Missing required property 'location'"
}
// Invalid: Example has wrong type for field
{
"type": "invalid_request_error",
"message": "Tool 'search_products' input_examples[1] is invalid: Property 'filters.price_range.min' must be a number, got string"
}
// Invalid: input_examples on server-side tool
{
"type": "invalid_request_error",
"message": "input_examples is not supported for server-side tool"
}
```
# Erweitertes Denken
Erweitertes Denken ermöglicht Claude bessere Argumentationsfähigkeiten für komplexe Aufgaben und sorgt gleichzeitig für ein unterschiedliches Maß an Transparenz in Bezug auf den step-by-step Denkprozess, bevor eine endgültige Antwort gefunden wird. Wenn Sie den Denkmodus von Claude aktivieren, müssen Sie ein Budget für die maximale Anzahl von Token festlegen, die für den internen Argumentationsprozess von Claude verwenden werden dürfen.
Es werde folgende Modelle unterstützt:
| Modell | Modell-ID |
| --- | --- |
| Claude Opus4.5 | `anthropic.claude-opus-4-5-20251101-v1:0` |
| Claude Opus 4 | `anthropic.claude-opus-4-20250514-v1:0` |
| Claude Sonnet 4 | `anthropic.claude-sonnet-4-20250514-v1:0` |
| Claude Sonnet 4.5 | `anthropic.claude-sonnet-4-5-20250929-v1:0` |
| Claude Haiku 4.5 | `anthropic.claude-haiku-4-5-20251001-v1:0` |
| Claude 3.7 Sonnet | `anthropic.claude-3-7-sonnet-20250219-v1:0` |
| Claude Sonnet 4.5 | `anthropic.claude-opus-4-5-20251101-v1:0` |
**Anmerkung**
Das API-Verhalten der Modelle Claude 3.7 und Claude 4 unterscheidet sich. Weitere Informationen finden Sie unter [Unterschiede im Denken zwischen den Modellversionen](claude-messages-thinking-differences.md).
**Topics**
+ [Best Practices und Überlegungen für erweitertes Denken](#claude-messages-extended-thinking-bps)
+ [So funktioniert erweitertes Denken](#claude-messages-how-extended-thinking-works)
+ [Verwenden von erweitertem Denken](#claude-messages-use-extended-thinking)
+ [Erweitertes Denken mit der Verwendung des Tools](#claude-messages-extended-thinking-tool-use)
+ [Denken Sie an Block-Clearing (Beta)](#claude-messages-thinking-block-clearing)
+ [Erweitertes Denken mit Prompt-Caching](#claude-messages-extended-thinking-prompt-caching)
+ [Grundlagen zum Caching-Verhalten von Denkblöcken](#claude-messages-extended-thinking-caching-behavior)
+ [Maximale Anzahl an Token und Größe des Kontextfensters bei erweitertem Denken](#claude-messages-extended-thinking-max-tokens)
+ [Überlegungen zu den Kosten des erweiterten Denkens](#claude-messages-extended-thinking-cost)
## Best Practices und Überlegungen für erweitertes Denken
Richtlinien für die Verwendung
+ **Aufgabenauswahl**: Verwenden Sie erweitertes Denken für besonders komplexe Aufgaben, bei denen logisches step-by-step Denken von Vorteil ist, wie Mathematik, Programmieren und Analysieren.
+ **Umgang mit Kontext**: Sie müssen alte Denkblöcke nicht selbst entfernen. Die Anthropic-API ignoriert Denkblöcke aus früheren Runden automatisch, sodass sie bei der Berechnung der Kontextnutzung nicht berücksichtigt werden.
+ **Prompt-Engineering**: Lesen Sie die [Prompting-Tipps für erweitertes Denken](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/extended-thinking-tips) von Anthropic, wenn Sie die Leistungsfähigkeit von Claude maximieren möchten.
Leistungsaspekte
+ **Reaktionszeiten**: Seien Sie auf potenziell längere Antwortzeiten vorbereitet, da der Argumentationsprozess eine zusätzliche Bearbeitung erfordert. Berücksichtigen Sie, dass das Generieren von Denkblöcken die Gesamtreaktionszeit verlängern kann.
+ **Streaming-Anfragen**: Streaming ist erforderlich, wenn der Wert für `max_tokens` über 21.333 liegt. Seien Sie beim Streamen auf eingehende Inhaltsblöcke vom Typ `thinking` und `text` vorbereitetet.
Feature-Kompatibilität
+ Erweitertes Denken ist nicht kompatibel mit Änderungen der Parameter `temperature`, `top_p` oder `top_k` bzw. der [erzwungenen Verwendung des Tools](https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/implement-tool-use#forcing-tool-use).
+ Wenn erweitertes Denken aktiviert ist, können Antworten nicht vorab ausgefüllt werden.
+ Änderungen am Budget für erweitertes Denken führen dazu, dass zwischengespeicherte Präfixe für Prompts, die Nachrichten enthalten, ungültig werden. Zwischengespeicherte System-Prompts und Tooldefinitionen funktionieren jedoch weiterhin, wenn sich die Denkparameter ändern.
Arbeiten mit Budgets für erweitertes Denken
+ **Budgetoptimierungen**: Das Mindestbudget beträgt 1.024 Token. Anthropic schlägt vor, mit dem Minimum zu beginnen und das Denkbudget schrittweise zu erhöhen, um den optimalen Bereich für Ihren Anwendungsfall zu finden. Eine größere Anzahl von Token ermöglicht vielleicht eine umfassendere und nuanciertere Argumentation, je nach Aufgabe kann dies aber auch die Ergebnisse beeinträchtigen. Das Budget ist eher ein Ziel als ein striktes Limit. Die tatsächliche Tokennutzung kann je nach Aufgabe variieren.
+ **Minimale und optimale Einstellungen**: Das Mindestbudget beträgt 1.024 Token. Wir empfehlen, mit dem Minimum zu beginnen und das Denkbudget schrittweise zu erhöhen, um den optimalen Bereich zu finden, in dem Claude eine gute Leistung für Ihren Anwendungsfall erbringen kann. Eine höhere Anzahl von Token ermöglicht vielleicht eine umfassendere und nuanciertere Argumentation, je nach Aufgabe kann dies aber auch die Ergebnisse beeinträchtigen. Das Budget ist eher ein Ziel als ein striktes Limit. Die tatsächliche Tokennutzung kann je nach Aufgabe variieren.
+ **Experimentieren**: Das Modell kann bei unterschiedlichen Einstellungen für das maximale Denkbudget unterschiedlich abschneiden. Eine Erhöhung des maximalen Budgets für erweitertes Denken kann dazu führen, dass das Modell besser oder schärfer denkt, was allerdings mit einer erhöhten Latenz einhergeht. Bei kritischen Aufgaben sollten Sie erwägen, verschiedene Budgeteinstellungen zu testen, um das optimale Gleichgewicht zwischen Qualität und Leistung zu finden.
+ **Große Budgets**: Bei Budgets über 32 000 Token empfehlen wir die Stapelverarbeitung, um Netzwerkprobleme zu vermeiden. Anfragen, die das Modell dazu drängen, beim Denken die Schwelle von 32 000 Token zu überschreiten, führen zu lang andauernden Anfragen, die zu System-Timeouts und offenen Verbindungslimits führen können. Beachten Sie, dass die Grenzwerte für `max_tokens` je nach Claude-Modell variieren. Weitere Informationen finden Sie unter [Maximale Anzahl an Token und Größe des Kontextfensters bei erweitertem Denken](#claude-messages-extended-thinking-max-tokens).
+ **Nachverfolgung der Tokennutzung**: Überwachen Sie die Nutzung von Token für erweitertes Denken, um Kosten und Leistung zu optimieren.
## So funktioniert erweitertes Denken
Wenn erweitertes Denken aktiviert ist, erstellt Claude `thinking`-Inhaltsblöcke mit interner Argumentation. Claude bezieht Erkenntnisse aus dieser Argumentation mit ein, bevor eine endgültige Antwort verfasst wird. Die API-Antwort wird `thinking`-Inhaltsblöcke enthalten, an die sich `text`-Inhaltsblöcke anschließen.
Das Folgende ist ein Beispiel für das Standardantwortformat:
```
{
"content": [
{
"type": "thinking",
"thinking": "Let me analyze this step by step...",
"signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
},
{
"type": "text",
"text": "Based on my analysis..."
}
]
}
```
Weitere Informationen zum Antwortformat des erweiterten Denkens finden Sie in der Messages API [Anforderung und Antwort](model-parameters-anthropic-claude-messages-request-response.md) von Anthropic.
## Verwenden von erweitertem Denken
Um erweitertes Denken zu aktivieren, fügen Sie ein `thinking`-Objekt hinzu und setzen Sie den Parameter `thinking` auf „aktiviert“ und den Parameter `budget_tokens` auf ein bestimmtes Tokenbudget für erweitertes Denken.
Der Parameter `budget_tokens` bestimmt die maximale Anzahl von Token, die in Claude für den internen Argumentationsprozess verwendet werden dürfen. In Claude-4-Modellen gilt dieser Grenzwert für Token für vollständiges Denken und nicht für die zusammengefasste Ausgabe. Durch höhere Budgets kann die Qualität der Antworten verbessert werden, da sie eine gründlichere Analyse komplexer Probleme ermöglichen, obwohl in Claude möglicherweise nicht das gesamte zugewiesene Budget aufgebraucht wird, insbesondere bei Bereichen über 32 000 Token.
Der Wert des Parameters `budget_tokens` muss kleiner als der Wert für `max_tokens` sein. Bei der Verwendung von [Verschachteltes Denken (Beta)](#claude-messages-extended-thinking-tool-use-interleaved) mit Tools können Sie dieses Limit jedoch überschreiten, da das Tokenlimit für das gesamte Kontextfenster gilt (200 000 Token).
### Zusammengefasstes Denken
Wenn erweitertes Denken aktiviert ist, gibt die Messages API für Claude-4-Modelle eine Zusammenfassung des vollständigen Denkprozesses von Claude zurück. Zusammengefasstes Denken bietet alle Vorteile des erweiterten Denkens und verhindert gleichzeitig Missbrauch.
Im Folgenden finden Sie einige wichtige Überlegungen für zusammengefasstes Denken:
+ Es werden die Token für vollständiges Denken berechnet, die durch die ursprüngliche Anfrage generiert wurden, nicht die Token für zusammengefasstes Denken.
+ Die Anzahl der in Rechnung gestellten Ausgabetoken entspricht nicht der Anzahl der Token, die Sie in der Antwort sehen.
+ Der für das Modell für zusammengefasstes Denken bereitgestellte Prompt kann geändert werden.
+ Die ersten Gedankenzeilen sind ausführlicher und bieten eine detaillierte Argumentation, die vor allem für Prompt-Engineering-Zwecke hilfreich ist.
**Anmerkung**
Claude 3.7 Sonnet gibt trotzdem die vollständige Denkausgabe zurück.
Wenden Sie sich an Ihr Account-Team, um in Claude-4-Modellen auf die Ausgabe für vollständiges Denken zuzugreifen.
### Streaming-Denken
Sie können mithilfe von servergesendeten Ereignissen Antworten aus erweitertem Denken streamen. Wenn Streaming für erweitertes Denken aktiviert ist, erhalten Sie Denkinhalte über `thinking_delta`-Ereignisse. Es kann nicht garantiert werden, dass gestreamte Ereignisse mit konstanter Geschwindigkeit zurückgegeben werden. Zwischen Streaming-Ereignissen kann es zu Verzögerungen kommen. Weitere Informationen zum Streamen über die Messages API finden Sie unter [Streamen von Nachrichten](https://docs.anthropic.com/en/docs/build-with-claude/streaming).
So gehst du mit Streaming und Denken um: **InvokeModelWithResponseStream**
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
Antwort:
```
event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-3-7-sonnet-20250219", "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"}
```
**Informationen über das Verhalten von Streaming-Denken**
Wenn Sie Streaming mit aktiviertem Denken verwenden, stellen Sie möglicherweise fest, dass Text manchmal in größeren Blöcken ankommt und sich mit kleineren Sendungen abwechselt. token-by-token Dies ist ein erwartetes Verhalten, insbesondere bei Denkinhalten. Das Streaming-System muss Inhalte stapelweise verarbeiten, um eine optimale Leistung zu erzielen. Dies kann zu diesem Übertragungsmuster führen.
## Erweitertes Denken mit der Verwendung des Tools
Erweitertes Denken kann zusammen mit [Verwendung des Tools](model-parameters-anthropic-claude-messages-tool-use.md) verwendet werden, sodass die Argumentation in Claude durch Toolauswahl und Ergebnisverarbeitung durchgeführt wird. Beachten Sie die folgenden Einschränkungen, wenn Sie erweitertes Denken mit der Verwendung des Tools verwenden:
+ **Einschränkung der Verwendung des Tools**: Bei der Verwendung des Tools in Verbindung mit Denken wird nur `tool_choice: any` unterstützt. Die Bereitstellung eines bestimmten Tools, von `auto` oder anderen Werten wird nicht unterstützt.
+ **Beibehalten von Denkblöcken**: Während der Verwendung des Tools müssen Sie Denkblöcke für die letzte Assistentennachricht an die API zurückgeben. Fügen Sie den gesamten unveränderten Block wieder in die API ein, um die Kontinuität der Argumentation aufrechtzuerhalten.
So funktioniert die Verwaltung von Kontextfenstern mit Tools:
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
}
]
}
```
Die erste Antwort lautet wie folgt:
```
{
"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"
}
}
]
}
```
Wenn Sie die Konversation unter Verwendung des Tools fortsetzen, wird eine weitere Antwort generiert. Beachten Sie, dass sowohl der Parameter `thinking_block` als auch der Parameter `tool_use_block` übergeben wird. Wenn er nicht übergeben wird, erhalten Sie eine Fehlermeldung.
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
},
{
"role": "assistant",
"content": [
{
"type": "thinking",
"thinking": "The user wants to know the current weather in Paris. I have access to a function `get_weather`…",
"signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxY",
},
{
"type": "tool_use",
"id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
},
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
"content": "Current temperature: 88°F"
}
]
}
]
}
```
Die API-Antwort enthält jetzt nur Text.
```
{
"content": [
{
"type": "text",
"text": "Currently in Paris, the temperature is 88°F (31°C)"
}
]
}
```
### Beibehalten von Denkblöcken
Während der Verwendung des Tools müssen Sie Denkblöcke an die API zurückgeben und den gesamten unveränderten Block wieder in die API aufnehmen. Dies ist entscheidend für die Aufrechterhaltung des Argumentationsflusses und der Konversationsintegrität des Modells.
**Tipp**
Sie können zwar `thinking`-Blöcke aus früheren Runden der `assistant`-Rolle weglassen, wir empfehlen jedoch, bei Konversationen mit mehreren Runden immer alle Denkblöcke an die API zurückzugeben. Die API führt die folgenden Schritte aus:
Filtert automatisch die bereitgestellten Denkblöcke
Verwendet die relevanten Denkblöcke, die erforderlich sind, um die Argumentation des Modells beizubehalten
Berechnet nur die Eingabetoken für die in Claude angezeigten Blöcke
Wenn Claude Tools aufruft, wird die Erstellung einer Antwort pausiert, während auf externe Informationen gewartet wird. Wenn die Ergebnisse des Tools zurückgegeben werden, wird die Erstellung der vorhandenen Antwort in Claude fortgesetzt. Dies erfordert die Beibehaltung von Denkblöcken bei der Verwendung des Tools, und zwar aus den folgenden Gründen:
+ **Kontinuität beim Denken**: Die Denkblöcke erfassen Claude die step-by-step Argumentation, die zu Anfragen nach Tools geführt hat. Wenn Sie die Ergebnisse des Tools veröffentlichen, wird durch Einbeziehung des ursprünglichen Denkvorgangs sichergestellt, dass Claude die Argumentation an der Stelle fortsetzen kann, an der sie angehalten wurde.
+ **Kontextwartung**: Die Ergebnisse der Tools werden in der API-Struktur zwar als Benutzernachrichten angezeigt, sind aber Teil eines kontinuierlichen Argumentationsflusses. Durch die Beibehaltung von Denkblöcken wird dieser konzeptionelle Fluss über mehrere API-Aufrufe hinweg aufrechterhalten.
**Wichtig**
Bei der Bereitstellung von Denkblöcken muss die gesamte Abfolge aufeinanderfolgender Denkblöcke mit den Ergebnissen ü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 (Beta)
**Warnung**
Interleaved Thinking wird Ihnen als „Beta-Service“ gemäß der Definition in den Servicebedingungen zur Verfügung gestellt. AWS Er unterliegt Ihrer Vereinbarung mit AWS und den AWS Servicebedingungen sowie der jeweils geltenden Muster-EULA.
Claude-4-Modelle unterstützen verschachteltes Denken; dieses Feature ermöglicht Claude einen Denkvorgang zwischen den einzelnen Toolaufrufen, sodass nach Erhalt der Ergebnisse differenziertere Schlussfolgerungen möglich sind. Dies ermöglicht komplexere Interaktionen der Kundendienstmitarbeiter, sodass in Claude Folgendes möglich wird:
+ Erläutern der Ergebnisse eines Toolaufrufs vor der Entscheidung, was als Nächstes zu tun ist
+ Verketten mehrerer Toolaufrufe mit dazwischen liegenden Argumentationsschritten
+ Differenziertere Entscheidungen auf der Grundlage von Zwischenergebnissen
Um verschachteltes Denken zu aktivieren, fügen Sie Ihrer API-Anfrage den Beta-Header `interleaved-thinking-2025-05-14` hinzu.
**Anmerkung**
Beim verschachtelten Denken kann der Parameter `budget_tokens` den Parameter `max_tokens` überschreiten, da er das Gesamtbudget aller Denkblöcke innerhalb einer Assistentenrunde darstellt.
## Denken Sie an Block-Clearing (Beta)
**Warnung**
Thinking Block Clearing wird als „Beta-Service“ gemäß der Definition in den AWS Servicebedingungen zur Verfügung gestellt.
**Anmerkung**
Diese Funktion wird derzeit von Claude Sonnet 4/4.5, Claude Haiku 4.5 und Claude Opus 4/4.1/4.5 unterstützt.
Das Löschen von Denkblöcken ist eine Funktion des Anthropic-Claude-Modells (in der Beta-Phase). Mit dieser Funktion kann Claude automatisch ältere Denkblöcke aus früheren Runden löschen. Um das Löschen von Denkblöcken zu verwenden, müssen Sie der Liste der Beta-Header den Anforderungsparameter anthropic\$1beta hinzufügen`context-management-2025-06-27`. Sie müssen außerdem die Verwendung von angeben `clear_thinking_20251015` und aus den folgenden Konfigurationsoptionen auswählen.
Dies sind die verfügbaren Steuerelemente für die Kontextmanagement-Strategie von `clear_thinking_20251015`. Alle sind optional oder haben Standardwerte:
| **Konfigurationsoption** | **Beschreibung** |
| --- | --- |
| `keep` Standard: 1 Denkrunde | Definiert, wie viele kürzliche Runden des Assistenten mit Denkblockaden beibehalten werden sollen. Geben Sie `{"type": "thinking_turns", "value": N}` an, wo N > 0 sein muss, um die letzten N Züge oder `{"type": "all"}` alle Denkblöcke beizubehalten. |
------
#### [ Request ]
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 10000,
"anthropic_beta": [
"context-management-2025-06-27"
],
"thinking": {
"type": "enabled",
"budget_tokens": 4000
},
"tools": [
{
"name": "get_weather",
"description": "Get current weather for a location",
"input_schema": {
"type": "object",
"properties": {
"location": {
"type": "string"
}
},
"required": [
"location"
]
}
}
],
"messages": [
{
"role": "user",
"content": "What's the weather in Paris?"
},
{
"role": "assistant",
"content": [
{
"type": "thinking",
"thinking": "The user is asking for the weather in Paris. I have access to a get_weather function that takes a location as a parameter. I have all the information I need to make this call - the location is \"Paris\".\n\nLet me call the get_weather function with \"Paris\" as the location.",
"signature": "ErgDCkgIChABGAIqQC/Ccv8GC+5VfcMEiq78XmpU2Ef2cT+96pHKMedKcRNuPz1x0kFlo5HBpW0r1NcQFVQUPuj6PDmP7jdHY7GsrUwSDKNBMogjaM7wYkwfPhoMswjlmfF09JLjZfFlIjB03NkghGOxLbr3VCQHIY0lMaV9UBvt7ZwTpJKzlz+mulBysfvAmDfcnvdJ/6CZre4qnQJsTZaiXdEgASwPIc5jOExBguerrtYSWVC/oPjSi7KZM8PfhP/SPXupyLi8hwYxeqomqkeG7AQhD+3487ecerZJcpJSOSsf0I1OaMpmQEE/b7ehnvTV/A4nLhxIjP4msyIBW+dVwHNFRFlpJLBHUJvN99b4run6YmqBSf4y9TyNMfOr+FtfxedGE0HfJMBd4FHXmUFyW5y91jAHMWqwNxDgacaKkFCAMaqce5rm0ShOxXn1uwDUAS3jeRP26Pynihq8fw5DQwlqOpo7vvXtqb5jjiCmqfOe6un5xeIdhhbzWddhEk1Vmtg7I817pM4MZjVaeQN02drPs8QgDxihnP6ZooGhd6FCBP2X3Ymdlj5zMlbVHxmSkA4wcNtg4IAYAQ=="
},
{
"type": "tool_use",
"id": "toolu_bdrk_01U7emCvL5v5z5GT7PDr2vzc",
"name": "get_weather",
"input": {
"location": "Paris"
}
}
]
},
{
"role": "user",
"content": [
{
"type": "tool_result",
"tool_use_id": "toolu_bdrk_01U7emCvL5v5z5GT7PDr2vzc",
"content": "Current temperature: 88°F"
}
]
}
],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 1
}
}
]
}
}
```
------
#### [ Response ]
```
{
"model": "claude-haiku-4-5-20251001",
"id": "msg_bdrk_01KyTbyFbdG2kzPwWMJY1kum",
"type": "message",
"role": "assistant",
"content": [
{
"type": "text",
"text": "The current weather in Paris is **88°F** (approximately 31°C). It's quite warm! If you need more detailed information like humidity, wind conditions, or a forecast, please let me know."
}
],
"stop_reason": "end_turn",
"stop_sequence": null,
"usage": {
"input_tokens": 736,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 0,
"cache_creation": {
"ephemeral_5m_input_tokens": 0,
"ephemeral_1h_input_tokens": 0
},
"output_tokens": 47
},
"context_management": {
"applied_edits": [...]
}
}
```
------
## Erweitertes Denken mit Prompt-Caching
Beim erweiterten Denken mit [Prompt-Caching](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html) sind mehrere wichtige Aspekte zu berücksichtigen:
**Kontextentfernung aus Denkblöcken**
+ Denkblöcke aus früheren Runden werden aus dem Kontext entfernt, was sich auf Cache-Haltepunkte auswirken kann.
+ Wenn Konversationen unter Verwendung des Tools fortgesetzt werden, werden Denkblöcke zwischengespeichert und zählen als Eingabetoken, wenn sie aus dem Cache gelesen werden. Dies führt zu einem Kompromiss, bei dem Denkblöcke zwar visuell keinen Platz im Kontextfenster beanspruchen, aber beim Zwischenspeichern trotzdem auf die Nutzung Ihrer Eingabetoken angerechnet werden.
+ Wenn das Denken deaktiviert wird, schlagen Anfragen fehl, wenn Sie Denkinhalte in der aktuellen Runde mit der Verwendung des Tools übergeben. In anderen Kontexten werden Denkinhalte, die an die API übergeben werden, einfach ignoriert.
**Muster für Cache-Invalidierung**
+ Änderungen an Denkparametern (wie das Aktivieren, Deaktivieren oder Ändern der Budgetzuweisung) machen die Haltepunkte für den Nachrichten-Cache ungültig.
+ [Verschachteltes Denken (Beta)](#claude-messages-extended-thinking-tool-use-interleaved) verstärkt die Cache-Invalidierung, da zwischen mehreren Toolaufrufen Denkblöcke gebildet werden können.
+ System-Prompts und Tools bleiben im Cache, auch bei der Änderung von Denkparametern oder dem Entfernen von Blöcken.
**Anmerkung**
Während Denkblöcke für das Caching und für kontextbezogene Berechnungen beseitigt werden, müssen sie bei der Fortsetzung von Konversationen mit der Verwendung des Tools, insbesondere bei verschachteltem Denken, beibehalten werden.
## Grundlagen zum Caching-Verhalten von Denkblöcken
Bei Einsatz von erweitertem Denken unter Verwendung des Tools zeigen Denkblöcke ein spezifisches Caching-Verhalten, das sich auf das Zählen von Tokens auswirkt. Der folgenden Sequenz können Sie entnehmen, wie das funktioniert.
1. Das Caching erfolgt nur, wenn Sie eine nachfolgende Anfrage, die Ergebnisse des Tools enthält.
1. Wenn die nachfolgende Anfrage gestellt wird, kann der vorherige Konversationsverlauf (einschließlich Denkblöcken) zwischengespeichert werden.
1. Diese zwischengespeicherten Denkblöcke zählen als Eingabetoken in den Nutzungsmetriken, wenn sie aus dem Cache gelesen werden.
1. Wenn ein non-tool-result Benutzerblock enthalten ist, werden alle vorherigen Denkblöcke ignoriert und aus dem Kontext entfernt.
Im Folgenden ist ein 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 mit dem Inhalt der Anfrage (nicht der Antwort). Der Cache enthält die ursprüngliche Benutzernachricht, den ersten Denkblock, die Verwendung des Tool-Blocks 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 non-tool-result Benutzerblock enthalten war, werden alle vorherigen Denkblöcke ignoriert. Diese Anfrage wird genauso bearbeitet wie die folgende Anfrage:
Alternative zu Anfrage 3:
```
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]
```
Dieses Verhalten ist unabhängig davon, ob normales oder verschachteltes Denken angewendet wird, konsistent.
## Maximale Anzahl an Token und Größe des Kontextfensters bei erweitertem Denken
Wenn in älteren Claude-Modellen (früher Claude 3.7 Sonnet) die Summe aus Prompt-Token und „max\$1tokens“ das Kontextfenster des Modells überschritt, passte das System den Wert für „max\$1tokens“ automatisch an, sodass dieser innerhalb des Kontextlimits lag. Das bedeutete, dass Sie einen großen Wert für „max\$1tokens“ festlegen konnten und das System diesen Wert automatisch nach Bedarf reduzierte. Bei den Modellen Claude 3.7 und 4 (worunter auch Ihr Denkbudget fällt, sofern die Denkfunktion aktiviert ist) wird `max_tokens` als strikter Grenzwert durchgesetzt. Das System gibt jetzt einen Validierungsfehler zurück, wenn die Summe aus Prompt-Token und „max\$1tokens“ die Größe des Kontextfensters überschreiten.
### Das Kontextfenster bei erweitertem Denken
Bei der Berechnung der Kontextfensternutzung sind bei aktiviertem Denken einige Aspekte zu beachten:
+ Denkblöcke aus früheren Runden werden entfernt und nicht auf das Kontextfenster angerechnet.
+ Das Denken in der aktuellen Runde wird auf das `max_tokens`-Limit für diese Runde angerechnet.
Das effektive Kontextfenster wird wie folgt berechnet: Kontextfenster = (aktuelle Eingabetoken – Vorherige Denktoken) \$1 (Denktoken \$1 verschlüsselte Denktoken \$1 Textausgabetoken).
### Verwalten von Token mit erweitertem Denken und Verwendung des Tools
Wenn erweitertes Denken zusammen mit der Verwendung des Tools verwendet wird, müssen Denkblöcke explizit beibehalten und zusammen mit den Ergebnissen des Tools zurückgegeben werden. Die effektive Berechnung des Kontextfensters für erweitertes Denken bei Verwendung von Tools sieht wie folgt aus:
`context window = (current input tokens + previous thinking tokens + tool use tokens) + (thinking tokens + encrypted thinking tokens + text output tokens)`
### Verwalten von Token mit erweitertem Denken
Angesichts des Kontextfensters und des Verhaltens von `max_tokens` mit den Claude-Modellen 3.7 und 4 für erweitertes Denken müssen Sie möglicherweise eine der folgenden Aktionen ausführen:
+ Überwachen und verwalten Sie Ihre Tokennutzung aktiver.
+ Passen Sie die Werte für `max_tokens` an, wenn sich die Länge des Prompts ändert.
+ Beachten Sie, dass sich frühere Denkblöcke nicht im Kontextfenster ansammeln. Diese Änderung wurde vorgenommen, um ein vorhersehbareres und transparenteres Verhalten zu ermöglichen, insbesondere da die maximale Grenze für Token erheblich erhöht wurde.
## Überlegungen zu den Kosten des erweiterten Denkens
Beim Denkprozess fallen folgende Gebühren an:
+ Für Token, die beim Denken verwendet werden (Ausgabetoken)
+ Für Denkblöcke aus der letzten Runde des Assistenten, die in nachfolgenden Anfragen enthalten sind (Eingabetoken)
+ Für Standard-Textausgabetoken
**Tipp**
Wenn erweitertes Denken aktiviert ist, wird zur Unterstützung des Features automatisch ein spezieller Prompt mit 28 oder 29 Token hinzugefügt.
Der Parameter `budget_tokens` bestimmt die maximale Anzahl von Token, die in Claude für den internen Argumentationsprozess verwendet werden dürfen. Durch höhere Budgets kann die Qualität der Antworten verbessert werden, da sie eine gründlichere Analyse komplexer Probleme ermöglichen, wobei in Claude möglicherweise nicht das gesamte zugewiesene Budget aufgebraucht wird, insbesondere bei Bereichen über 32 000.
Beim verschachtelten Denken kann der Parameter `budget_tokens` den Parameter `max_tokens` überschreiten, weil er das Gesamtbudget aller Denkblöcke innerhalb einer Assistentenrunde darstellt.
Berücksichtigen Sie bei der Verwendung von zusammengefasstem Denken Folgendes:
+ **Eingabetoken**: Token in der ursprünglichen Anfrage
+ **Ausgabetoken (in Rechnung gestellt)**: Die ursprünglichen Denktoken, die intern in Claude generiert wurden
+ **Ausgabetoken (sichtbar)**: Die zusammengefassten Denktoken, die Sie in der Antwort sehen
+ **Kostenlos**: Token, die zur Generierung der Zusammenfassung verwendet wurden
+ Im Feld `summary_status` wird möglicherweise angegeben, ob das Token die Zusammenfassung der betroffenen Daten einschränkt
+ Die Anzahl der in Rechnung gestellten Ausgabetoken entspricht nicht der Anzahl der Token, die Sie in der Antwort sehen. Ihnen wird der vollständige Denkprozess in Rechnung gestellt, nicht die Zusammenfassung, die Sie sehen.
# Adaptives Denken
Adaptives Denken ist die empfohlene Methode [Erweitertes Denken](claude-messages-extended-thinking.md) für Claude Opus 4.6. Anstatt manuell ein Budget für Denkmuster festzulegen, ermöglicht adaptives Denken anhand der Komplexität der einzelnen Anfragen Claude dynamisch zu entscheiden, wann und wie viel nachgedacht werden soll. Adaptives Denken führt zuverlässig zu einer besseren Leistung als erweitertes Denken mit einer festen Einstellung`budget_tokens`, und wir empfehlen, zu adaptivem Denken überzugehen, um die intelligentesten Antworten aus Claude Opus 4.6 zu erhalten. Es ist kein Beta-Header erforderlich.
Es werde folgende Modelle unterstützt:
| Modell | Modell-ID |
| --- | --- |
| Claude Opus4.6 | `anthropic.claude-opus-4-6-v1` |
| Claude Sonett 4,6 | `anthropic.claude-sonnet-4-6` |
**Anmerkung**
`thinking.type: "enabled"`und `budget_tokens` sind in Version Claude Opus 4.6 veraltet und werden in einer future Modellversion entfernt. Verwenden Sie es `thinking.type: "adaptive"` stattdessen mit dem Effort-Parameter.
Ältere Modelle (Claude Sonnet 4.5, Claude Opus 4.5 usw.) unterstützen adaptives Denken nicht und erfordern `thinking.type: "enabled"` mit`budget_tokens`.
## Wie funktioniert adaptives Denken
Im adaptiven Modus Claude wird die Komplexität jeder Anfrage bewertet und entschieden, ob und wie viel darüber nachgedacht werden soll. Auf der Standardaufwandsebene (`high`) denkt er fast immer nach. Claude Bei niedrigerem Aufwand überspringt er Claude möglicherweise das Denken für einfachere Probleme.
Adaptives Denken ermöglicht dies auch automatisch[Verschachteltes Denken (Beta)](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-interleaved). Das bedeutet, dass es zwischen den einzelnen Toolaufrufen denken Claude kann, was es besonders effektiv für die Arbeitsabläufe von Agenturen macht.
Stellen Sie `"adaptive"` in `thinking.type` Ihrer API-Anfrage auf Folgendes ein:
------
#### [ CLI ]
```
aws bedrock-runtime invoke-model \
--model-id "us.anthropic.claude-opus-4-6-v1" \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"messages": [
{
"role": "user",
"content": "Three players A, B, C play a game. Each has a jar with 100 balls numbered 1-100. Simultaneously, each draws one ball. A beats B if As number > Bs number (mod 100, treating 100 as 0 for comparison). Similarly for B vs C and C vs A. The overall winner is determined by majority of pairwise wins (ties broken randomly). Is there a mixed strategy Nash equilibrium where each player draws uniformly? If not, characterize the equilibrium."
}
]
}' \
--cli-binary-format raw-in-base64-out \
output.json && cat output.json | jq '.content[] | {type, thinking: .thinking[0:200], text}'
```
------
#### [ Python ]
```
import boto3
import json
bedrock_runtime = boto3.client(
service_name='bedrock-runtime',
region_name='us-east-2'
)
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 16000,
"thinking": {
"type": "adaptive"
},
"messages": [{
"role": "user",
"content": "Explain why the sum of two even numbers is always even."
}]
})
)
response_body = json.loads(response["body"].read())
for block in response_body["content"]:
if block["type"] == "thinking":
print(f"\nThinking: {block['thinking']}")
elif block["type"] == "text":
print(f"\nResponse: {block['text']}")
```
------
#### [ TypeScript ]
```
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
async function main() {
const client = new BedrockRuntimeClient({});
const command = new InvokeModelCommand({
modelId: "us.anthropic.claude-opus-4-6-v1",
body: JSON.stringify({
anthropic_version: "bedrock-2023-05-31",
max_tokens: 16000,
thinking: {
type: "adaptive"
},
messages: [{
role: "user",
content: "Explain why the sum of two even numbers is always even."
}]
})
});
const response = await client.send(command);
const responseBody = JSON.parse(new TextDecoder().decode(response.body));
for (const block of responseBody.content) {
if (block.type === "thinking") {
console.log(`\nThinking: ${block.thinking}`);
} else if (block.type === "text") {
console.log(`\nResponse: ${block.text}`);
}
}
}
main().catch(console.error);
```
------
## Adaptives Denken mit dem Parameter Aufwand
Sie können adaptives Denken mit dem Leistungsparameter kombinieren, um zu bestimmen, wie viel Denken Claude bewirkt. Das Aufwandsniveau dient als Orientierungshilfe für die Verteilung Claude des Denkens:
| Aufwand-Ebene | Denkverhalten |
| --- | --- |
| max | Claudedenkt immer ohne Einschränkungen in Bezug auf die Denktiefe. Claude Opusnur 4.6 — Anfragen, die max auf anderen Modellen verwendet werden, geben einen Fehler zurück. |
| high (Standard) | Claudedenkt immer. Bietet fundierte Überlegungen zu komplexen Aufgaben. |
| medium | Claudeverwendet gemäßigtes Denken. Kann bei sehr einfachen Fragen das Nachdenken überspringen. |
| low | Claudeminimiert das Denken. Überspringt das Denken bei einfachen Aufgaben, bei denen Geschwindigkeit am wichtigsten ist. |
## Prompt-Caching
Aufeinanderfolgende Anfragen, bei denen `adaptive` Thinking verwendet wird, behalten die Zwischenspeicher-Haltepunkte bei. Beim Umschalten zwischen den `disabled` Denkmodi `adaptive` und`enabled`/werden jedoch die Cache-Breakpoints für Nachrichten unterbrochen. Systemaufforderungen und Werkzeugdefinitionen bleiben unabhängig von Modusänderungen zwischengespeichert.
## Optimierung des Denkverhaltens
Wenn Claude Sie mehr oder weniger häufig denken, als Sie möchten, können Sie Ihrer Systemaufforderung eine Anleitung hinzufügen:
```
Extended thinking adds latency and should only be used when it
will meaningfully improve answer quality — typically for problems
that require multi-step reasoning. When in doubt, respond directly.
```
**Warnung**
Wenn Sie weniger häufig nachdenken, kann dies Claude zu Qualitätseinbußen bei Aufgaben führen, für die Argumentation von Vorteil ist. Messen Sie die Auswirkungen auf Ihre spezifischen Workloads, bevor Sie das Prompt-basierte Tuning in der Produktion einsetzen. Erwägen Sie, zunächst mit geringerem Aufwand zu testen.
# Verschlüsselung beim Denken
Die vollständigen Denkinhalte werden verschlüsselt und im Signaturfeld zurückgegeben. Dieses Feld wird verwendet, um zu überprüfen, ob bei der Rückgabe an die API Denkblöcke in Claude generiert wurden. Beim Streamen von Antworten wird die Signatur über ein `signature_delta`-Ereignis innerhalb eines `content_block_delta`-Ereignisses direkt vor einem `content_block_stop`-Ereignis hinzugefügt.
**Anmerkung**
Denkblöcke müssen nur dann zurückgeschickt werden, wenn Tools mit erweitertem Denken verwendet werden. Andernfalls können Denkblöcke aus früheren Runden weggelassen oder bei der Rückgabe von der API entfernt werden.
Wenn Sie Denkblöcke zurücksenden, empfehlen wir zur Wahrung der Konsistenz und zur Vermeidung potenzieller Probleme, sie in dem Zustand zu belassen, in dem sie empfangen wurden.
## Überarbeiten von Denkprozessen in Claude 3.7 Sonnet
**Anmerkung**
Die folgenden Informationen gelten speziell für Claude 3.7 Sonnet. In Claude-4-Modellen werden Denkprozesse anders gehandhabt und es werden keine überarbeiteten Denkblöcke erzeugt.
In Claude 3.7 Sonnet gilt Folgendes:
+ Gelegentlich werden die internen Argumentationen von Claude durch unsere Sicherheitssysteme aufgedeckt. In diesem Fall verschlüsseln wir einen Teil oder den gesamten Denkblock und geben ihn als redacted\$1thinking-Block an zurück. redacted\$1thinking-Blöcke werden entschlüsselt, wenn sie an die API zurückgegeben werden, sodass die Antwort von Claude fortgesetzt werden kann, ohne dass dabei Kontext verloren geht.
+ `thinking`- und `redacted_thinking`-Blöcke werden vor den Textblöcken in der Antwort zurückgegeben.
Berücksichtigen Sie bei der Entwicklung kundenorientierter Anwendungen, die erweitertes Denken mit Claude 3.7 Sonnet nutzen, folgende Aspekte:
+ Beachten Sie, dass überarbeitete Denkblöcke verschlüsselte Inhalte enthalten, die für Menschen nicht lesbar sind.
+ Fügen Sie ggf. eine einfache Erklärung hinzu, z. B. „Ein Teil der internen Argumentation von Claude wurde aus Sicherheitsgründen automatisch verschlüsselt. Die Qualität der Antworten wird dadurch nicht beeinträchtigt.“
+ Wenn Sie Benutzern Denkblöcke anzeigen, können Sie überarbeitete Blöcke herausfiltern und dabei normale Denkblöcke beibehalten.
+ Machen Sie deutlich, dass die Verwendung von Features für erweitertes Denken gelegentlich dazu führen kann, dass einige Argumentationen verschlüsselt werden.
+ Implementieren Sie eine angemessene Fehlerbehandlung, um redigiertes Denken ordnungsgemäß und ohne Beeinträchtigung der Benutzeroberfläche zu verwalten.
Hier ist ein Beispiel, das sowohl normale als auch überarbeitete Denkblöcke zeigt:
```
{
"content": [
{
"type": "thinking",
"thinking": "Let me analyze this step by step...",
"signature":"WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...." },
{
"type": "redacted_thinking",
"data":"EmwKAhgBEgy3va3pzix/LafPsn4aDFIT2Xlxh0L5L8rLVyIwxtE3rAFBa8cr3qpP..."
},
{
"type": "text",
"text": "Based on my analysis..."
}
]
}
```
**Tipp**
Es ist normal, dass die Ausgabe redigierte Denkblöcke enthält. Das Modell kann diese überarbeitete Argumentation dennoch als Grundlage für seine Antworten verwenden und gleichzeitig den Integritätsschutz wahren.
Wenn Sie den Umgang mit überarbeitetem Denken in Ihrer Anwendung testen möchten, können Sie als Prompt die folgende Testzeichenfolge verwenden: `ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB`
Wenn Sie in einer Konversation mit mehreren Runden `thinking`- und `redacted_thinking`-Blöcke an die API zurückleiten, müssen Sie den kompletten, unveränderten Block für die letzte Runde des Assistenten wieder in die API aufnehmen. Dies ist entscheidend für die Aufrechterhaltung des Argumentationsflusses des Modells. Wir empfehlen, immer alle Denkblöcke an die API zurückzugeben. Weitere Informationen hierzu finden Sie unter [Erweitertes Denken mit der Verwendung des ToolsBeibehalten von Denkblöcken](claude-messages-extended-thinking.md#claude-messages-extended-thinking-tool-use-thinking-blocks).
Im folgenden Beispiel wird die **InvokeModelWithResponseStream**API verwendet, um die Anfrage- und Antwortstruktur zu demonstrieren, wenn Thinking Tokens mit Schwärzungen verwendet werden.
Wenn Streaming aktiviert ist, erhalten Sie Denkinhalte von thinking\$1delta-Ereignissen. Vorgehensweise beim Streaming-Denken:
**Anforderung**
```
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 24000,
"thinking": {
"type": "enabled",
"budget_tokens": 16000
},
"messages": [
{
"role": "user",
"content": "What is 27 * 453?"
}
]
}
```
**Antwort**
```
event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-3-7-sonnet-20250219", "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"}
```
# Unterschiede im Denken zwischen den Modellversionen
Die Nachrichten-API behandelt die Denkfunktion in Claude-4-Modellen anders als in Claude 3.7 Sonnet-Modellen, insbesondere in Bezug auf das Verhalten bei der Überarbeitung und Zusammenfassung. Diese Unterschiede werden in der folgenden Tabelle zusammengefasst.
| Feature | Claude 3.7 Sonnet | Claude-4-Modelle |
| --- | --- | --- |
| Denkausgabe | Gibt die vollständige Denkausgabe zurück | Gibt zusammengefasstes Denken zurück |
| Umgang mit Überarbeitungen | Verwendet `redacted_thinking`-Blöcke | Überarbeitet und verschlüsselt den vollständigen Denkprozess und gibt in einem `signature`-Feld aus |
| Verschachteltes Denken | Nicht unterstützt | Wird mit einem Beta-Header unterstützt |
# Verdichtung
**Tipp**
Die serverseitige Komprimierung wird für die Verwaltung des Kontextes in lang andauernden Konversationen und Agentenworkflows empfohlen, da sie das Kontextmanagement automatisch und mit minimalem Integrationsaufwand abwickelt.
**Anmerkung**
Die Komprimierung befindet sich derzeit in der Betaphase. Nehmen Sie den Beta-Header `compact-2026-01-12` in Ihre API-Anfragen auf, um diese Funktion zu nutzen. Die Komprimierung wird derzeit von der Converse API nicht unterstützt, sie wird jedoch von unterstützt. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
Durch die Komprimierung wird die effektive Kontextlänge für Konversationen und Aufgaben mit langer Laufzeit verlängert, indem älterer Kontext automatisch zusammengefasst wird, wenn das Kontext-Fensterlimit erreicht wird. Das ist ideal für:
+ Chat-basierte Konversationen mit mehreren Runden, bei denen Sie möchten, dass Benutzer einen Chat über einen längeren Zeitraum verwenden
+ Aufgabenorientierte Eingabeaufforderungen, die viel Nacharbeit erfordern (häufig den Einsatz von Tools) und die das Kontextfenster von 200.000 überschreiten können
Die Komprimierung wird auf den folgenden Modellen unterstützt:
| Modell | Modell-ID |
| --- | --- |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` |
| Claude Opus 4.6 | `anthropic.claude-opus-4-6-v1` |
**Anmerkung**
Die Werte auf oberster Ebene `input_tokens` und `output_tokens` im `usage` Feld enthalten nicht die Verwendung von Verdichtungsiterationen und geben die Summe aller Iterationen ohne Komprimierung wieder. Um die Gesamtzahl der für eine Anfrage verbrauchten und in Rechnung gestellten Token zu berechnen, summieren Sie alle Einträge im Array. `usage.iterations`
Wenn Sie sich bisher `usage.output_tokens` bei der Kostenverfolgung oder -prüfung auf `usage.input_tokens` und verlassen haben, müssen Sie Ihre Nachverfolgungslogik aktualisieren, damit `usage.iterations` sie bei aktivierter Komprimierung aggregiert wird. Das `iterations` Array ist nur vorhanden, wenn während der Anforderung eine neue Komprimierung ausgelöst wird. Das erneute Anwenden eines vorherigen `compaction` Blocks verursacht keine zusätzlichen Verdichtungskosten, und die Verwendungsfelder der obersten Ebene bleiben in diesem Fall korrekt.
## Wie funktioniert die Verdichtung
Wenn die Komprimierung aktiviert ist, fasst Ihre Konversation Claude automatisch zusammen, wenn sie sich dem konfigurierten Token-Schwellenwert nähert. Die API:
1. Erkennt, wenn Eingabe-Tokens den angegebenen Triggerschwellenwert überschreiten.
1. Generiert eine Zusammenfassung der aktuellen Konversation.
1. Erzeugt einen `compaction` Block, der die Zusammenfassung enthält.
1. Setzt die Antwort mit dem komprimierten Kontext fort.
Bei nachfolgenden Anfragen fügen Sie die Antwort an Ihre Nachrichten an. Die API löscht automatisch alle Nachrichtenblöcke vor dem `compaction` Block und setzt die Konversation von der Zusammenfassung aus fort.
## Grundlegende Verwendung
Aktivieren Sie die Komprimierung, indem Sie die `compact_20260112` Strategie zu `context_management.edits` Ihrer Nachrichten-API-Anfrage hinzufügen.
------
#### [ CLI ]
```
aws bedrock-runtime invoke-model \
--model-id "us.anthropic.claude-opus-4-6-v1" \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Help me build a website"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}' \
--cli-binary-format raw-in-base64-out \
/tmp/response.json
echo "Response:"
cat /tmp/response.json | jq '.content[] | {type, text: .text[0:500]}'
```
------
#### [ Python ]
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
messages = [{"role": "user", "content": "Help me build a website"}]
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
})
)
response_body = json.loads(response["body"].read())
# Append the response (including any compaction block) to continue the conversation
messages.append({"role": "assistant", "content": response_body["content"]})
for block in response_body["content"]:
if block.get("type") == "compaction":
print(f"[COMPACTION]: {block['content'][:200]}...")
elif block.get("type") == "text":
print(f"[RESPONSE]: {block['text']}")
```
------
#### [ TypeScript ]
```
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
async function main() {
const client = new BedrockRuntimeClient({});
const messages: Array<{role: string, content: string | object[]}> = [
{ role: "user", content: "Help me build a website" }
];
const command = new InvokeModelCommand({
modelId: "us.anthropic.claude-opus-4-6-v1",
body: JSON.stringify({
anthropic_version: "bedrock-2023-05-31",
anthropic_beta: ["compact-2026-01-12"],
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112"
}
]
}
})
});
const response = await client.send(command);
const responseBody = JSON.parse(new TextDecoder().decode(response.body));
// Append response to continue conversation
messages.push({ role: "assistant", content: responseBody.content });
for (const block of responseBody.content) {
if (block.type === "compaction") {
console.log(`[COMPACTION]: ${block.content.substring(0, 200)}...`);
} else if (block.type === "text") {
console.log(`[RESPONSE]: ${block.text}`);
}
}
}
main().catch(console.error);
```
------
## Parameters
| Parameter | Typ | Standard | Description |
| --- | --- | --- | --- |
| type | Zeichenfolge | Erforderlich | Muss "compact\$120260112" sein. |
| trigger | object | 150.000 Token | Wann muss die Verdichtung ausgelöst werden? Es müssen mindestens 50.000 Tokens sein. |
| pause\$1after\$1compaction | boolesch | false | Ob nach dem Generieren der Zusammenfassung der Komprimierung eine Pause eingelegt werden soll |
| instructions | Zeichenfolge | null | Eingabeaufforderung zur benutzerdefinierten Zusammenfassung. Ersetzt die Standardaufforderung vollständig, sofern sie bereitgestellt wird. |
## Konfiguration des Triggers
Konfigurieren Sie mit dem folgenden `trigger` Parameter, wann die Komprimierung ausgelöst wird:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [{"role": "user", "content": "Help me build a website"}],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"trigger": {
"type": "input_tokens",
"value": 100000
}
}
]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Anweisungen zur benutzerdefinierten Zusammenfassung
Standardmäßig verwendet die Komprimierung die folgende Zusammenfassungsaufforderung:
```
You have written a partial transcript for the initial task above. Please write a summary of the transcript. The purpose of this summary is to provide continuity so you can continue to make progress towards solving the task in a future context, where the raw history above may not be accessible and will be replaced with this summary. Write down anything that would be helpful, including the state, next steps, learnings etc. You must wrap your summary in a block.
```
Sie können über den `instructions` Parameter benutzerdefinierte Anweisungen angeben, um diese Aufforderung vollständig zu ersetzen. Benutzerdefinierte Anweisungen ergänzen die Standardeinstellung nicht, sondern ersetzen sie vollständig:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [{"role": "user", "content": "Help me build a website"}],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"instructions": "Focus on preserving code snippets, variable names, and technical decisions."
}
]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Wird nach der Verdichtung angehalten
Wird verwendet`pause_after_compaction`, um die API nach dem Generieren der Zusammenfassung der Komprimierung anzuhalten. Auf diese Weise können Sie zusätzliche Inhaltsblöcke hinzufügen (z. B. die Beibehaltung aktueller Nachrichten oder bestimmter anweisungsorientierter Nachrichten), bevor die API mit der Antwort fortfährt.
Wenn diese Option aktiviert ist, gibt die API nach der Generierung des Verdichtungsblocks eine Nachricht mit dem Grund für den `compaction` Stopp zurück:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
messages = [{"role": "user", "content": "Help me build a website"}]
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [
{
"type": "compact_20260112",
"pause_after_compaction": True
}
]
}
})
)
response_body = json.loads(response["body"].read())
# Check if compaction triggered a pause
if response_body.get("stop_reason") == "compaction":
# Response contains only the compaction block
messages.append({"role": "assistant", "content": response_body["content"]})
# Continue the request
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [{"type": "compact_20260112"}]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Mit Verdichtungsblöcken arbeiten
Wenn die Komprimierung ausgelöst wird, gibt die API zu Beginn der Assistentenantwort einen `compaction` Block zurück.
Eine lang andauernde Konversation kann zu mehreren Verdichtungen führen. Der letzte Komprimierungsblock spiegelt den endgültigen Status der Aufforderung wider und ersetzt den Inhalt davor durch die generierte Zusammenfassung.
```
{
"content": [
{
"type": "compaction",
"content": "Summary of the conversation: The user requested help building a web scraper..."
},
{
"type": "text",
"text": "Based on our conversation so far..."
}
]
}
```
## Streaming
Wenn Sie Antworten mit aktivierter Komprimierung streamen, erhalten Sie ein `content_block_start` Ereignis, wenn die Komprimierung beginnt. Der Verdichtungsblock streamt anders als Textblöcke. Sie erhalten eine `content_block_start` Veranstaltung, gefolgt von einer Single `content_block_delta` mit dem vollständigen Inhalt der Zusammenfassung (kein Zwischenstreaming) und dann ein `content_block_stop` Ereignis.
## Prompt-Caching
Sie können einen `cache_control` Haltepunkt für Komprimierungsblöcke hinzufügen, der die vollständige Systemaufforderung zusammen mit dem zusammengefassten Inhalt zwischenspeichert. Der komprimierte Originalinhalt wird ignoriert. Beachten Sie, dass, wenn die Komprimierung ausgelöst wird, dies dazu führen kann, dass bei der nachfolgenden Anforderung ein Cache-Fehler auftritt.
```
{
"role": "assistant",
"content": [
{
"type": "compaction",
"content": "[summary text]",
"cache_control": {"type": "ephemeral"}
},
{
"type": "text",
"text": "Based on our conversation..."
}
]
}
```
## Die Verwendung verstehen
Für die Verdichtung ist ein zusätzlicher Probenahmeschritt erforderlich, was zu Preisobergrenzen und Fakturierung beiträgt. Die API gibt in der Antwort detaillierte Nutzungsinformationen zurück:
```
{
"usage": {
"input_tokens": 45000,
"output_tokens": 1234,
"iterations": [
{
"type": "compaction",
"input_tokens": 180000,
"output_tokens": 3500
},
{
"type": "message",
"input_tokens": 23000,
"output_tokens": 1000
}
]
}
}
```
Das `iterations` Array zeigt die Nutzung für jede Sampling-Iteration. Wenn die Komprimierung stattfindet, sehen Sie eine `compaction` Iteration, auf die die Hauptiteration folgt. `message` Die Token-Anzahl der letzten Iteration spiegelt die effektive Kontextgröße nach der Komprimierung wider.
# Holen Sie sich validierte JSON-Ergebnisse aus Modellen
Sie können strukturierte Ausgaben mitClaude Sonnet 4.5, Claude Haiku 4.5Claude Opus 4.5, und Claude Opus 4.6 verwenden. Weitere Informationen hierzu finden Sie unter [Holen Sie sich validierte JSON-Ergebnisse aus Modellen](structured-output.md).
# Anforderung und Antwort
Der Anfragetext wird im `body` Feld einer Anfrage an [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)oder übergeben [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html).
**Anmerkung**
Einschränkungen gelten für die folgenden Operationen: `InvokeModel``InvokeModelWithResponseStream`,`Converse`, und`ConverseStream`. Einzelheiten finden Sie unter [API-Einschränkungen](inference-api-restrictions.md).
**Warnung**
Claude Sonnet 4.5und Claude Haiku 4.5 unterstützt die Angabe entweder des `top_p` Parameters `temperature` oder, aber nicht beider. Dies gilt nicht für ältere Modelle.
------
#### [ Request ]
Anthropic Claude verfügt über die folgenden Inferenzparameter für Nachrichten-Inferenzaufrufe.
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["computer-use-2024-10-22"]
"max_tokens": int,
"system": string,
"messages": [
{
"role": string,
"content": [
{ "type": "image", "source": { "type": "base64", "media_type": "image/jpeg", "data": "content image bytes" } },
{ "type": "text", "text": "content text" }
]
}
],
"temperature": float,
"top_p": float,
"top_k": int,
"tools": [
{
"type": "custom",
"name": string,
"description": string,
"input_schema": json
},
{
"type": "computer_20241022",
"name": "computer",
"display_height_px": int,
"display_width_px": int,
"display_number": 0 int
},
{
"type": "bash_20241022",
"name": "bash"
},
{
"type": "text_editor_20241022",
"name": "str_replace_editor"
}
],
"tool_choice": {
"type" : string,
"name" : string,
},
"stop_sequences": [string]
}
```
Die folgenden Parameter sind erforderlich.
+ **anthropic\$1version** – (erforderlich) Die anthropische Version Der Wert muss sein`bedrock-2023-05-31`.
+ **max\$1tokens** – (erforderlich) Die maximale Anzahl von Token, die vor dem Stoppen generiert werden sollen.
Beachten Sie, dass Anthropic-Claude-Modelle möglicherweise die Generierung von Token einstellen, bevor der Wert von `max_tokens` erreicht ist. Verschiedene Anthropic-Claude-Modelle haben unterschiedliche Maximalwerte für diesen Parameter. Weitere Informationen finden Sie unter [Modellvergleich](https://docs.anthropic.com/claude/docs/models-overview#model-comparison).
+ **messages** – (erforderlich) Die Eingabenachrichten
+ **role** – Die Rolle der Konversationsrunde Gültige Werte sind `user` und `assistant`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **content** – (erforderlich) Der Inhalt der Konversationsrunde als Array von Objekten. Jedes Objekt enthält ein **type**-Feld, in dem Sie einen der folgenden Werte angeben können:
+ `text` – Wenn Sie diesen Typ angeben, müssen Sie ein **text**-Feld einschließen und den Text-Prompt als Wert angeben. Wenn es sich bei einem anderen Objekt im Array um ein Bild handelt, gilt dieser Text-Prompt für die Bilder.
+ `image` – Wenn Sie diesen Typ angeben, müssen Sie ein **source**-Feld angeben, das einem Objekt mit den folgenden Feldern zugeordnet ist:
+ **type** – (erforderlich) Der Kodierungstyp für das Bild. Sie können `base64` angeben.
+ **media\$1type** – (erforderlich) Der Typ des Bildes. Sie können die folgenden Bildformate angeben.
+ `image/jpeg`
+ `image/png`
+ `image/webp`
+ `image/gif`
+ **data** – (erforderlich) Die base64-codierten Bildbytes für das Bild. Die maximale Größe ist 3,75 MB. Die maximale Höhe und Breite eines Bildes beträgt 8 000 Pixel.
Die folgenden Parameter sind optional.
+ **system** – (optional) Der System-Prompt für die Anfrage.
Ein System-Prompt bietet die Möglichkeit, Anthropic Claude mit Kontext und Anweisungen zu versorgen, beispielsweise durch die Angabe eines bestimmten Ziels oder einer bestimmten Rolle. Weitere Informationen finden Sie unter [System-Prompts](https://docs.anthropic.com/en/docs/system-prompts) in der Anthropic-Dokumentation.
**Anmerkung**
Sie können System-Prompts mit Anthropic Claude Version 2.1 oder höher verwenden.
+ **anthropic\$1beta** – (optional) Der anthropische Beta-Parameter ist eine Liste von Zeichenfolgen von Beta-Headern, die verwendet werden, um anzugeben, dass Sie sich für einen bestimmten Satz von Beta-Features entschieden haben.
**Anmerkung**
Die Variante mit einer Länge von 1 Million Token Claude Sonnet 4 steht Ihnen in ausgewählten AWS Regionen als „Beta-Service“ zur Verfügung, wie in den AWS Servicebedingungen definiert. Sie unterliegt Ihrer Vereinbarung mit AWS und den AWS Servicebedingungen sowie der geltenden Muster-EULA. Weitere Informationen zu den Preisen für längere Kontextanfragen finden Sie auf der Seite [Amazon Bedrock – Preise](https://aws.amazon.com/bedrock/pricing/). Es gelten separate Service Quotas (weitere Informationen finden Sie unter **Servicekontingenten** im AWS-Managementkonsole).
Verfügbare Beta-Header sind beispielsweise folgende:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **stop\$1sequences** – (optional) Benutzerdefinierte Textsequenzen, die dazu führen, dass das Modell nicht mehr generiert wird. Anthropic-Claude-Modelle stoppen normalerweise, wenn sie ihre Verarbeitung auf natürliche Weise beendet haben. In diesem Fall ist der Wert des `stop_reason`-Antwortfeldes `end_turn`. Wenn Sie möchten, dass das Modell nicht mehr generiert wird, wenn es auf benutzerdefinierte Textzeichenfolgen trifft, können Sie den `stop_sequences`-Parameter verwenden. Wenn das Modell auf eine der benutzerdefinierten Textzeichenfolgen trifft, lautet der Wert des `stop_reason`-Antwortfeldes `stop_sequence` und der Wert von `stop_sequence` enthält die übereinstimmende Stoppsequenz.
Die maximale Anzahl von Einträgen ist 8 191.
+ **temperature** – (optional) Die Menge an Zufälligkeit, die der Antwort hinzugefügt wurde.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1p** – (optional) Verwenden Sie Nukleus-Sampling.
Beim Nukleus-Sampling berechnet Anthropic Claude die kumulative Verteilung über alle Optionen für jedes nachfolgende Token in absteigender Wahrscheinlichkeitsreihenfolge und beendet den Vorgang, sobald eine bestimmte, durch `top_p` festgelegte Wahrscheinlichkeit erreicht ist. Wenn Sie die Sampling-Parameter anpassen, ändern Sie entweder `temperature` oder `top_p`. Ändern Sie nicht beide gleichzeitig.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **top\$1k** – (optional) Nehmen Sie für jedes nachfolgende Token nur Stichproben aus den Top-K-Optionen vor.
Verwenden Sie `top_k`, um Antworten mit langen Ausläufern und geringer Wahrscheinlichkeit zu entfernen.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ **tools** – (optional) Definitionen von Tools, die das Modell verwenden kann.
**Anmerkung**
Erfordert ein Modell von Anthropic Claude 3.
Wenn Sie `tools` in Ihrer Anforderung angeben, gibt das Modell möglicherweise `tool_use`-Inhaltsblöcke zurück, die die Verwendung dieser Tools durch das Modell darstellt. Sie können diese Tools dann mit der vom Modell generierten Tool-Eingabe ausführen und anschließend optional Ergebnisse mithilfe von `tool_result`-Inhaltsblöcken an das Modell zurückgeben.
Sie können die folgenden Tool-Typen übergeben:
**Benutzerdefiniert**
Definition für ein benutzerdefiniertes Tool.
+ (optional) **type** – Der Typ des Tools. Falls dieser definiert ist, verwenden Sie den Wert `custom`.
+ **name** – Der Name des Tools
+ **Beschreibung** – (optional, aber dringend empfohlen) die Beschreibung des Tools
+ **input\$1schema** – Das JSON-Schema für das Tool.
**Computer**
Definition für das Computer-Tool, das Sie mit der Computer-Use-API verwenden.
+ **type** – Der Wert muss `computer_20241022` sein.
+ **name** – Der Wert muss `computer` sein.
+ (Erforderlich) **display\$1height\$1px** – Die Höhe der Anzeige, die vom Modell gesteuert wird, in Pixeln.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ (Erforderlich) **display\$1width\$1px** – Die Breite der Anzeige, die vom Modell gesteuert wird, in Pixeln.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
+ (Optional) **display\$1number** – Die zu steuernde Anzeigenummer (nur relevant für X11-Umgebungen). Falls angegeben, erhält das Tool eine Anzeigenummer in der Tool-Definition.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/bedrock/latest/userguide/model-parameters-anthropic-claude-messages-request-response.html)
**bash**
Definition für das Bash-Tool, das Sie mit der Computer-Use-API verwenden.
+ (optional) **type** – Der Wert muss `bash_20241022` sein.
+ **name** – Der Wert muss `bash` sein und dem Tool entsprechen.
**Text-Editor**
Definition für das Text-Editor-Tool, das Sie mit der Computer-Use-API verwenden.
+ (optional) **type** – Der Wert muss `text_editor_20241022` sein.
+ **name** – Der Wert muss `str_replace_editor` sein und dem Tool entsprechen.
+ **tool\$1choice** – (optional) Gibt an, wie das Modell die bereitgestellten Tools verwenden soll. Das Modell kann ein bestimmtes Tool bzw. jedes verfügbare Tool verwenden oder selbst entscheiden.
**Anmerkung**
Erfordert ein Modell von Anthropic Claude 3.
+ **type** – Der Typ der Tool-Auswahl. Mögliche Werte sind `any` (jedes verfügbare Werkzeug verwenden), `auto` (das Modell entscheidet) und `tool` (das angegebene Tool verwenden).
+ **name** – (optional) Der Name des zu verwendenden Tools. Erforderlich, wenn Sie `tool` im Feld `type` angeben.
------
#### [ Response ]
Das Anthropic-Claude-Modell gibt die folgenden Felder für einen Inferenzaufruf für Nachrichten zurück.
```
{
"id": string,
"model": string,
"type" : "message",
"role" : "assistant",
"content": [
{
"type": string,
"text": string,
"image" :json,
"id": string,
"name":string,
"input": json
}
],
"stop_reason": string,
"stop_sequence": string,
"usage": {
"input_tokens": integer,
"output_tokens": integer
}
}
```
Beispielantworten mit neuen stop\$1reason-Werten:
```
// Example with refusal
{
"stop_reason": "refusal",
"content": [
{
"type": "text",
"text": "I can't help with that request."
}
]
}
// Example with tool_use
{
"stop_reason": "tool_use",
"content": [
{
"type": "tool_use",
"id": "toolu_123",
"name": "calculator",
"input": {"expression": "2+2"}
}
]
}
// Example with model_context_window_exceeded (Claude Sonnet 4.5)
{
"stop_reason": "model_context_window_exceeded",
"content": [
{
"type": "text",
"text": "The response was truncated due to context window limits..."
}
]
}
```
+ **ID** – Die eindeutige Kennung für die Antwort. Das Format und die Länge der ID können sich im Laufe der Zeit ändern.
+ **model** – Die ID für das Anthropic-Claude-Modell, das die Anfrage gestellt hat.
+ **stop\$1reason** – Der Grund, warum Anthropic Claude keine Antwort mehr generiert hat.
+ **end\$1turn** – Das Modell hat einen natürlichen Haltepunkt erreicht.
+ **max\$1tokens** – Der generierte Text hat den Wert des `max_tokens`-Eingabefeldes oder die maximale Anzahl von Token überschritten, die das Modell unterstützt.
+ **stop\$1sequence** – Das Modell hat eine der Stoppsequenzen generiert, die Sie im `stop_sequences`-Eingabefeld angegeben haben.
+ **Ablehnung** – Claude weigert sich aus Sicherheitsgründen, eine Antwort zu generieren.
+ **tool\$1use** – Claude ruft ein Tool auf und erwartet, dass Sie es ausführen.
+ **model\$1context\$1window\$1exceeded** – Das Modell hat die Generierung gestoppt, weil das Kontextfensterlimit erreicht wurde.
+ Neu mit Claude Sonnet 4.5
+ **stop\$1sequence** – Die Stoppsequenz, mit der die Generierung beendet wurde.
+ **type** – Die Art der Antwort Dieser Wert ist immer `message`.
+ **role** – Die Konversationsrolle der generierten Nachricht Dieser Wert ist immer `assistant`.
+ **Inhalt** – Der vom Modell generierte Inhalt. Als Array zurückgegeben. Es gibt drei Inhaltstypen: *text*, *tool\$1use* und *image*.
+ *text* – Eine Textantwort
+ **type** – Die Art des Inhalts Dieser Wert ist `text`.
+ **text** – Wenn der Wert des Felds `type` „text“ ist, enthält es den Text des Inhalts.
+ *tool use* – Eine Anfrage des Modells zur Verwendung eines Tools
+ **type** – Die Art des Inhalts Dieser Wert ist `tool_use`.
+ **id** – Die ID des Tools, dessen Verwendung das Modell anfordert
+ **name** – Enthält den Namen des angeforderten Tools
+ **input** – Die Eingabeparameter, die an das Tool übergeben werden sollen
+ *Image* – Eine Anfrage des Modells zur Verwendung eines Tools
+ **type** – Die Art des Inhalts Dieser Wert ist `image`.
+ **source** – Enthält das Bild Weitere Informationen finden Sie unter [Multimodale Prompts](model-parameters-anthropic-claude-messages.md#model-parameters-anthropic-claude-messages-multimodal-prompts).
+ **usage** – Container für die Anzahl der Token, die Sie in der Anfrage angegeben haben, und für die Anzahl der Token, die das Modell in der Antwort generiert hat
+ **input\$1tokens** – Die Anzahl der Eingabe-Token in der Anfrage
+ **output\$1tokens** – Die Anzahl der Token, die das Modell in der Antwort generiert hat
+ **stop\$1sequence** – Das Modell hat eine der Stoppsequenzen generiert, die Sie im `stop_sequences`-Eingabefeld angegeben haben.
------
## Aufwandsparameter (Beta)
Der `effort` Parameter ist eine Alternative zu denkenden Token-Budgets für Claude Opus 4.5. Dieser Parameter gibt an, Claude wie großzügig es Tokens ausgeben sollte, um das beste Ergebnis zu erzielen, und passt die Token-Nutzung je nach Denkweise, Toolaufrufen und Benutzerkommunikation an. Er kann mit oder ohne erweiterten Denkmodus verwendet werden.
Der Aufwandsparameter kann wie folgt eingestellt werden:
+ `high`(Standard) — Claude gibt so viele Token aus, wie für das beste Ergebnis erforderlich sind
+ `medium`— Ausgewogene Token-Nutzung
+ `low`— Konservative Token-Verwendung
Um diese Funktion nutzen zu können, müssen Sie den Beta-Header übergeben`effort-2025-11-24`.
Anfragebeispiel:
```
{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": [
"effort-2025-11-24"
],
"max_tokens": 4096,
"output_config": {
"effort": "medium"
},
"messages": [{
"role": "user",
"content": "Analyze this complex dataset and provide insights"
}]
}
```
# Codebeispiele
Die folgenden Codebeispiele zeigen, wie Sie die Nachrichten-API verwenden.
**Topics**
+ [Beispiel für Nachrichten-Code](#api-inference-examples-claude-messages-code-example)
+ [Multimodale Code-Beispiele](#api-inference-examples-claude-multimodal-code-example)
## Beispiel für Nachrichten-Code
Dieses Beispiel zeigt, wie eine Single-Turn-Benutzernachricht und ein Benutzer-Turn mit einer vorausgefüllten Assistentennachricht an ein Anthropic Claude 3 Sonnet-Modell gesendet werden.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to generate a message with Anthropic Claude (on demand).
"""
import boto3
import json
import logging
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_message(bedrock_runtime, model_id, system_prompt, messages, max_tokens):
body=json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"system": system_prompt,
"messages": messages
}
)
response = bedrock_runtime.invoke_model(body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Anthropic Claude message example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
system_prompt = "Please respond only with emoji."
max_tokens = 1000
# Prompt with user turn only.
user_message = {"role": "user", "content": "Hello World"}
messages = [user_message]
response = generate_message (bedrock_runtime, model_id, system_prompt, messages, max_tokens)
print("User turn only.")
print(json.dumps(response, indent=4))
# Prompt with both user turn and prefilled assistant response.
#Anthropic Claude continues by using the prefilled assistant text.
assistant_message = {"role": "assistant", "content": ""}
messages = [user_message, assistant_message]
response = generate_message(bedrock_runtime, model_id,system_prompt, messages, max_tokens)
print("User turn and prefilled assistant response.")
print(json.dumps(response, indent=4))
except ClientError as err:
message=err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occurred: " +
format(message))
if __name__ == "__main__":
main()
```
## Multimodale Code-Beispiele
Die folgenden Beispiele zeigen, wie ein Bild und ein Prompt in einer multimodalen Nachricht an ein Anthropic Claude 3 Sonnet-Modell weitergegeben werden.
**Topics**
+ [Multimodale Aufforderung mit InvokeModel](#api-inference-examples-claude-multimodal-code-example-invoke-model)
+ [Multimodale Eingabeaufforderung streamen mit InvokeModelWithResponseStream](#api-inference-examples-claude-multimodal-code-example-streaming)
### Multimodale Aufforderung mit InvokeModel
Das folgende Beispiel zeigt, wie eine multimodale Aufforderung an with gesendet wird. Anthropic Claude 3 Sonnet [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to run a multimodal prompt with Anthropic Claude (on demand) and InvokeModel.
"""
import json
import logging
import base64
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def run_multi_modal_prompt(bedrock_runtime, model_id, messages, max_tokens):
"""
Invokes a model with a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
messages (JSON) : The messages to send to the model.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
body = json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"messages": messages
}
)
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id)
response_body = json.loads(response.get('body').read())
return response_body
def main():
"""
Entrypoint for Anthropic Claude multimodal prompt example.
"""
try:
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
model_id = 'anthropic.claude-3-sonnet-20240229-v1:0'
max_tokens = 1000
input_text = "What's in this image?"
input_image = "/path/to/image" # Replace with actual path to image file
# Read reference image from file and encode as base64 strings.
image_ext = input_image.split(".")[-1]
with open(input_image, "rb") as image_file:
content_image = base64.b64encode(image_file.read()).decode('utf8')
message = {
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "base64",
"media_type": f"image/{image_ext}",
"data": content_image
}
},
{
"type": "text",
"text": input_text
}
]
}
messages = [message]
response = run_multi_modal_prompt(
bedrock_runtime, model_id, messages, max_tokens)
print(json.dumps(response, indent=4))
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occurred: " +
format(message))
if __name__ == "__main__":
main()
```
### Multimodale Eingabeaufforderung streamen mit InvokeModelWithResponseStream
Das folgende Beispiel zeigt, wie die Antwort von einer multimodalen Aufforderung gestreamt wird, die an Anthropic Claude 3 Sonnet with gesendet wurde. [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to stream the response from Anthropic Claude Sonnet (on demand) for a
multimodal request.
"""
import json
import base64
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def stream_multi_modal_prompt(bedrock_runtime, model_id, input_text, image, max_tokens):
"""
Streams the response from a multimodal prompt.
Args:
bedrock_runtime: The Amazon Bedrock boto3 client.
model_id (str): The model ID to use.
input_text (str) : The prompt text
image (str) : The path to an image that you want in the prompt.
max_tokens (int) : The maximum number of tokens to generate.
Returns:
None.
"""
with open(image, "rb") as image_file:
encoded_string = base64.b64encode(image_file.read())
body = json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": max_tokens,
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": input_text},
{"type": "image", "source": {"type": "base64",
"media_type": "image/jpeg", "data": encoded_string.decode('utf-8')}}
]
}
]
})
response = bedrock_runtime.invoke_model_with_response_stream(
body=body, modelId=model_id)
for event in response.get("body"):
chunk = json.loads(event["chunk"]["bytes"])
if chunk['type'] == 'message_delta':
print(f"\nStop reason: {chunk['delta']['stop_reason']}")
print(f"Stop sequence: {chunk['delta']['stop_sequence']}")
print(f"Output tokens: {chunk['usage']['output_tokens']}")
if chunk['type'] == 'content_block_delta':
if chunk['delta']['type'] == 'text_delta':
print(chunk['delta']['text'], end="")
def main():
"""
Entrypoint for Anthropic Claude Sonnet multimodal prompt example.
"""
model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
input_text = "What can you tell me about this image?"
image = "/path/to/image"
max_tokens = 100
try:
bedrock_runtime = boto3.client('bedrock-runtime')
stream_multi_modal_prompt(
bedrock_runtime, model_id, input_text, image, max_tokens)
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
if __name__ == "__main__":
main()
```
# Unterstützte Modelle
Sie können die Nachrichten-API mit den folgenden Anthropic-Claude-Modellen verwenden.
+ AnthropicClaude Opus4.5
+ AnthropicClaude Opus4.1
+ AnthropicClaude Opus4
+ Anthropic Claude Sonnet 4.5
+ Anthropic Claude Haiku 4.5
+ Anthropic Claude Sonnet 4
+ Anthropic Claude 3.7 Sonnet
+ Anthropic Claude 3.5 Sonnet v2
+ Anthropic Claude 3.5 Sonnet
+ Anthropic Claude 3 Opus
+ Anthropic Claude 3 Sonnet
+ Anthropic Claude 3 Haiku
+ Anthropic Claude 2 v2.1
+ Anthropic Claude 2 v2
+ Anthropic Claude Instant v1.2