---
title: Kontextbearbeitung
url: https://platform.claude.com/docs/de/build-with-claude/context-editing
description: Verwalte den Gesprächskontext automatisch mit Kontextbearbeitung, während er wächst.
---
Um zu erfahren, wie „zero data retention“ (Null-Datenspeicherung), oder ZDR, auf diese Funktion angewendet wird, siehe [API und Datenspeicherung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention).
## Überblick
Für die meisten Anwendungsfälle ist die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction) die primäre Strategie zur Verwaltung des Kontexts in lang laufenden Gesprächen. Die Strategien auf dieser Seite sind für bestimmte Szenarien nützlich, in denen du eine feinere Kontrolle darüber benötigst, welche Inhalte gelöscht werden.
„Context editing“ (Kontextbearbeitung) ermöglicht es dir, gezielt bestimmte Inhalte aus dem Gesprächsverlauf zu löschen, während dieser wächst. Über die Kostenoptimierung und das Einhalten von Limits hinaus geht es dabei darum, aktiv zu kuratieren, was Claude sieht: Kontext ist eine endliche Ressource mit abnehmendem Grenznutzen, und irrelevante Inhalte verschlechtern den Fokus des Modells. Kontextbearbeitung gibt dir eine feingranulare Laufzeitkontrolle über diese Kuratierung. Die übergeordneten Prinzipien hinter dem Kontextmanagement findest du unter [Effective context engineering](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents). Diese Seite behandelt:
* **Löschen von Tool-Ergebnissen** – Am besten geeignet für agentische Workflows mit intensiver „tool use“ (Tool-Nutzung), bei denen alte Tool-Ergebnisse nicht mehr benötigt werden
* **Löschen von Thinking-Blöcken** – Zur Verwaltung von Thinking-Blöcken aus früheren Turns, mit Optionen zum Beibehalten des jüngsten Nachdenkens für Kontextkontinuität
* **Clientseitige SDK-Komprimierung** – Eine SDK-basierte Alternative für zusammenfassungsbasiertes Kontextmanagement (serverseitige Komprimierung wird im Allgemeinen bevorzugt)
| Ansatz | Wo er ausgeführt wird | Strategien | Funktionsweise |
| ---------------- | --------------------- | ----------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Serverseitig** | API | Löschen von Tool-Ergebnissen (`clear_tool_uses_20250919`)
Löschen von Thinking-Blöcken (`clear_thinking_20251015`) | Wird angewendet, bevor der Prompt Claude erreicht. Löscht bestimmte Inhalte aus dem Gesprächsverlauf. Jede Strategie kann unabhängig konfiguriert werden. |
| **Clientseitig** | SDK | Komprimierung | Verfügbar in den [TypeScript- und Ruby-SDKs](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) bei Verwendung von [`tool_runner`](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-runner). Erzeugt eine Zusammenfassung und ersetzt den vollständigen Gesprächsverlauf. Siehe [Clientseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/context-editing#client-side-compaction-sdk). |
## Serverseitige Strategien
Kontextbearbeitung befindet sich in der Beta-Phase und unterstützt das Löschen von Tool-Ergebnissen und das Löschen von Thinking-Blöcken. Um sie zu aktivieren, verwende den Beta-Header `context-management-2025-06-27` in deinen API-Anfragen.
Teile dein Feedback zu dieser Funktion über das [Feedback-Formular](https://forms.gle/YXC2EKGMhjN1c4L88).
### Löschen von Tool-Ergebnissen
Die Strategie `clear_tool_uses_20250919` löscht Tool-Ergebnisse, wenn der Gesprächskontext über deinen konfigurierten Schwellenwert hinaus wächst. Dies ist besonders nützlich für agentische Workflows mit intensiver Tool-Nutzung. Ältere Tool-Ergebnisse (wie Dateiinhalte oder Suchergebnisse) werden nicht mehr benötigt, sobald Claude sie verarbeitet hat.
Bei Aktivierung löscht die API automatisch die ältesten Tool-Ergebnisse in chronologischer Reihenfolge. Die API ersetzt jedes gelöschte Ergebnis durch einen Platzhaltertext, der Claude anzeigt, dass es entfernt wurde. Standardmäßig werden nur Tool-Ergebnisse gelöscht. Optional kannst du sowohl Tool-Ergebnisse als auch Tool-Aufrufe (die Tool-Nutzungsparameter) löschen, indem du `clear_tool_inputs` auf true setzt.
### Löschen von Thinking-Blöcken
Die Strategie `clear_thinking_20251015` verwaltet `thinking`-Blöcke aus früheren Assistant-Turns. Diese Strategie gibt dir Kontrolle über die Bewahrung des Nachdenkens: Du kannst mehr Thinking-Blöcke behalten, um die Kontinuität der Argumentation zu wahren, oder sie aggressiver löschen, um Kontextplatz zu sparen.
**Standardverhalten:** Der Standard variiert je nach Modellklasse.
| Modellklasse | Gesamtes vorheriges Nachdenken behalten | Nur das Nachdenken des letzten Zugs behalten |
| ---------------- | --------------------------------------- | -------------------------------------------- |
| Opus | Claude Opus 4.5 und neuer | Claude Opus 4.1 und älter |
| Sonnet | Claude Sonnet 4.6 und neuer | Claude Sonnet 4.5 (abgekündigt) und älter |
| Haiku | Claude Haiku 5.5 und neuer | Claude Haiku 4.5 und älter |
| Fable und Mythos | Alle Modelle | (keine) |
Verwende diese Strategie, um den Standard zu überschreiben. Wenn dein Code über mehrere Modellstufen hinweg läuft, setze `keep` explizit, anstatt dich auf den modellspezifischen Standard zu verlassen.
Ein Gesprächszug des Assistenten kann mehrere Inhaltsblöcke (zum Beispiel bei der Verwendung von Tools) und mehrere Thinking-Blöcke (zum Beispiel bei [verschachteltem Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking#interleaved-thinking)) enthalten.
### Kontextbearbeitung erfolgt serverseitig
Kontextbearbeitung wird serverseitig angewendet, bevor der Prompt Claude erreicht. Deine Client-Anwendung behält den vollständigen, unveränderten Gesprächsverlauf. Du musst deinen Client-Zustand nicht mit der bearbeiteten Version synchronisieren. Verwalte deinen vollständigen Gesprächsverlauf weiterhin lokal, wie du es normalerweise tun würdest.
Bei Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 und Claude Haiku 5.5 macht das serverseitige Kontextmanagement Thinking-Blöcke niemals ungültig. Clientseitige Bearbeitungen früherer Turns können die Thinking-Blöcke in jedem späteren Assistant-Turn ungültig machen. Bei neuen Konten, die am oder nach dem 31. August 2026 erstellt wurden, wird eine Anfrage, die einen ungültig gemachten Block erneut sendet, abgelehnt, es sei denn, du entscheidest dich dafür, ihn zu verwerfen. Siehe [Das Präfix unverändert lassen](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking#prefix-check).
### Kontextbearbeitung und Prompt-Caching
Die Wechselwirkung der Kontextbearbeitung mit [„prompt caching“ (Prompt-Caching)](https://platform.claude.com/docs/de/build-with-claude/prompt-caching) variiert je nach Strategie:
* **Löschen von Tool-Ergebnissen:** Macht zwischengespeicherte Prompt-Präfixe ungültig, wenn Inhalte gelöscht werden. Um dies zu berücksichtigen, lösche genügend Token, damit sich die Cache-Invalidierung lohnt. Verwende den Parameter `clear_at_least`, um sicherzustellen, dass jedes Mal eine Mindestanzahl an Token gelöscht wird. Dir entstehen jedes Mal Cache-Schreibkosten, wenn Inhalte gelöscht werden, aber nachfolgende Anfragen können das neu zwischengespeicherte Präfix wiederverwenden.
* **Löschen von Thinking-Blöcken:** Wenn Thinking-Blöcke im Kontext **behalten** (nicht gelöscht) werden, bleibt der Prompt-Cache erhalten, was Cache-Treffer ermöglicht und die Kosten für Eingabe-Token reduziert. Wenn Thinking-Blöcke **gelöscht** werden, wird der Cache an der Stelle ungültig, an der das Löschen erfolgt. Konfiguriere den Parameter `keep` danach, ob du die Cache-Leistung oder die Verfügbarkeit des Kontextfensters priorisieren möchtest.
## Unterstützte Modelle
Kontextbearbeitung ist für alle unterstützten Claude-Modelle verfügbar.
## Verwendung des Löschens von Tool-Ergebnissen
Der einfachste Weg, das Löschen von Tool-Ergebnissen zu aktivieren, besteht darin, nur den Strategietyp anzugeben. Alle anderen [Konfigurationsoptionen](https://platform.claude.com/docs/de/build-with-claude/context-editing#configuration-options-for-tool-result-clearing) verwenden ihre Standardwerte:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Search for recent developments in AI"
}
],
"tools": [
{
"type": "web_search_20250305",
"name": "web_search"
}
],
"context_management": {
"edits": [
{"type": "clear_tool_uses_20250919"}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Search for recent developments in AI
tools:
- type: web_search_20250305
name: web_search
context_management:
edits:
- type: clear_tool_uses_20250919
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=4096,
messages=[{"role": "user", "content": "Search for recent developments in AI"}],
tools=[{"type": "web_search_20250305", "name": "web_search"}],
betas=["context-management-2025-06-27"],
context_management={"edits": [{"type": "clear_tool_uses_20250919"}]},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [
{
role: "user",
content: "Search for recent developments in AI"
}
],
tools: [
{
type: "web_search_20250305",
name: "web_search"
}
],
context_management: {
edits: [{ type: "clear_tool_uses_20250919" }]
},
betas: ["context-management-2025-06-27"]
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = [
new() { Role = Role.User, Content = "Search for recent developments in AI" }
],
Tools = [
new BetaWebSearchTool20250305()
],
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaClearToolUses20250919Edit()]
},
Betas = [AnthropicBeta.ContextManagement2025_06_27]
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Search for recent developments in AI")),
},
Tools: []anthropic.BetaToolUnionParam{
{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{}},
},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{
anthropic.AnthropicBetaContextManagement2025_06_27,
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Search for recent developments in AI")
.addTool(BetaWebSearchTool20250305.builder().build())
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder().build())
.build())
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
['role' => 'user', 'content' => 'Search for recent developments in AI']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
['type' => 'web_search_20250305', 'name' => 'web_search']
],
contextManagement: [
'edits' => [
['type' => 'clear_tool_uses_20250919']
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [
{ role: "user", content: "Search for recent developments in AI" }
],
tools: [
{ type: "web_search_20250305", name: "web_search" }
],
context_management: {
edits: [
{ type: "clear_tool_uses_20250919" }
]
},
betas: ["context-management-2025-06-27"]
)
puts response
```
### Erweiterte Konfiguration
Du kannst das Verhalten beim Löschen von Tool-Ergebnissen mit zusätzlichen Parametern anpassen:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"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
}
],
"context_management": {
"edits": [
{
"type": "clear_tool_uses_20250919",
"trigger": {
"type": "input_tokens",
"value": 30000
},
"keep": {
"type": "tool_uses",
"value": 3
},
"clear_at_least": {
"type": "input_tokens",
"value": 5000
},
"exclude_tools": ["web_search"]
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
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
context_management:
edits:
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 30000
keep:
type: tool_uses
value: 3
clear_at_least:
type: input_tokens
value: 5000
exclude_tools:
- web_search
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
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},
],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_tool_uses_20250919",
# Löse das Leeren aus, wenn der Schwellenwert überschritten wird
"trigger": {"type": "input_tokens", "value": 30000},
# Anzahl der Tool-Aufrufe, die nach dem Leeren erhalten bleiben
"keep": {"type": "tool_uses", "value": 3},
# Optional: Leere mindestens so viele Token
"clear_at_least": {"type": "input_tokens", "value": 5000},
# Schließe diese Tools vom Leeren aus
"exclude_tools": ["web_search"],
}
]
},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
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
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
// Löse das Leeren aus, wenn der Schwellenwert überschritten wird
trigger: {
type: "input_tokens",
value: 30000
},
// Anzahl der Tool-Nutzungen, die nach dem Leeren erhalten bleiben
keep: {
type: "tool_uses",
value: 3
},
// Optional: Leere mindestens so viele Token
clear_at_least: {
type: "input_tokens",
value: 5000
},
// Schließe diese Tools vom Leeren aus
exclude_tools: ["web_search"]
}
]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = [
new() { Role = Role.User, Content = "Create a simple command line calculator app using Python" }
],
Tools = [
new BetaToolTextEditor20250728 { MaxCharacters = 10000 },
new BetaWebSearchTool20250305 { MaxUses = 3 }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearToolUses20250919Edit
{
Trigger = new BetaInputTokensTrigger(30000),
Keep = new BetaToolUsesKeep(3),
ClearAtLeast = new BetaInputTokensClearAtLeast(5000),
ExcludeTools = ["web_search"]
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Create a simple command line calculator app using Python")),
},
Tools: []anthropic.BetaToolUnionParam{
{OfTextEditor20250728: &anthropic.BetaToolTextEditor20250728Param{
MaxCharacters: anthropic.Int(10000),
}},
{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{
MaxUses: anthropic.Int(3),
}},
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
Value: 30000,
},
},
Keep: anthropic.BetaToolUsesKeepParam{
Value: 3,
},
ClearAtLeast: anthropic.BetaInputTokensClearAtLeastParam{
Value: 5000,
},
ExcludeTools: []string{"web_search"},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaToolTextEditor20250728;
import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
import com.anthropic.models.beta.messages.BetaInputTokensClearAtLeast;
import com.anthropic.models.beta.messages.BetaToolUsesKeep;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Create a simple command line calculator app using Python")
.addTool(BetaToolTextEditor20250728.builder()
.maxCharacters(10000L)
.build())
.addTool(BetaWebSearchTool20250305.builder()
.maxUses(3L)
.build())
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(30000L)
.build())
.keep(BetaToolUsesKeep.builder()
.value(3L)
.build())
.clearAtLeast(BetaInputTokensClearAtLeast.builder()
.value(5000L)
.build())
.addExcludeTool("web_search")
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
[
'role' => 'user',
'content' => 'Create a simple command line calculator app using Python'
]
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
[
'type' => 'text_editor_20250728',
'name' => 'str_replace_based_edit_tool',
'max_characters' => 10000
],
[
'type' => 'web_search_20250305',
'name' => 'web_search',
'max_uses' => 3
]
],
contextManagement: [
'edits' => [
[
'type' => 'clear_tool_uses_20250919',
'trigger' => [
'type' => 'input_tokens',
'value' => 30000
],
'keep' => [
'type' => 'tool_uses',
'value' => 3
],
'clear_at_least' => [
'type' => 'input_tokens',
'value' => 5000
],
'exclude_tools' => ['web_search']
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
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
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 30000
},
keep: {
type: "tool_uses",
value: 3
},
clear_at_least: {
type: "input_tokens",
value: 5000
},
exclude_tools: ["web_search"]
}
]
}
)
puts response
```
## Verwendung des Löschens von Thinking-Blöcken
Verwende das Löschen von Thinking-Blöcken, um Kontext und Prompt-Caching in Gesprächen zu verwalten, die Thinking-Blöcke aus früheren Turns mitführen:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"messages": [{"role": "user", "content": "Hello"}],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 2
}
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Hello
context_management:
edits:
- type: clear_thinking_20251015
keep:
type: thinking_turns
value: 2
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
messages=[{"role": "user", "content": "Hello"}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {"type": "thinking_turns", "value": 2},
}
]
},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
}
]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new BetaThinkingTurns(2)
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
Value: 2,
},
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearThinking20251015Edit;
import com.anthropic.models.beta.messages.BetaThinkingTurns;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Hello")
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keep(BetaThinkingTurns.builder()
.value(2L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => [
'type' => 'thinking_turns',
'value' => 2
]
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
}
]
}
)
puts response
```
### Konfigurationsoptionen für das Löschen von Thinking-Blöcken
Die Strategie `clear_thinking_20251015` unterstützt die folgende Konfiguration:
| Konfigurationsoption | Standard | Beschreibung |
| -------------------- | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `keep` | Modellspezifisch | Legt fest, wie viele der letzten Assistentenzüge mit Thinking-Blöcken erhalten bleiben sollen. Verwende `{type: "thinking_turns", value: N}`, wobei N > 0 sein muss, um die letzten N Züge zu behalten, oder `"all"`, um alle Thinking-Blöcke zu behalten. Opus 4.5+, Sonnet 4.6+ und Haiku 5.5+: alle Züge. Fable- und Mythos-Modelle: alle Züge. Frühere Opus-/Sonnet-Modelle und Haiku bis einschließlich Claude Haiku 4.5: nur der letzte Zug. |
**Beispielkonfigurationen:**
Thinking-Blöcke der letzten 3 Assistentenzüge behalten:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"messages": [{"role": "user", "content": "Hello"}],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 3
}
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Hello
context_management:
edits:
- type: clear_thinking_20251015
keep:
type: thinking_turns
value: 3
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
messages=[{"role": "user", "content": "Hello"}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {"type": "thinking_turns", "value": 3},
}
]
},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 3
}
}
]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new BetaThinkingTurns(3)
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
Value: 3,
},
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Hello")
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keep(BetaThinkingTurns.builder()
.value(3L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => [
'type' => 'thinking_turns',
'value' => 3
]
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 3
}
}
]
}
)
puts response
```
Alle Thinking-Blöcke behalten (maximiert Cache-Treffer):
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"messages": [{"role": "user", "content": "Hello"}],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": "all"
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Hello
context_management:
edits:
- type: clear_thinking_20251015
keep: all
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
messages=[{"role": "user", "content": "Hello"}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": "all",
}
]
},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: "all"
}
]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new All()
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
OfAll: constant.ValueOf[constant.All](),
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Hello")
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keepAll()
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => 'all'
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [{ role: "user", content: "Hello" }],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: "all"
}
]
}
)
puts response
```
### Strategien kombinieren
Du kannst das Löschen von Thinking-Blöcken und das Löschen von Tool-Ergebnissen zusammen verwenden:
Bei Verwendung mehrerer Strategien muss die Strategie `clear_thinking_20251015` im Array `edits` an erster Stelle stehen.
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 16000,
"messages": [
{
"role": "user",
"content": "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
}
],
"tools": [
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 5
}
],
"context_management": {
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {
"type": "thinking_turns",
"value": 2
}
},
{
"type": "clear_tool_uses_20250919",
"trigger": {
"type": "input_tokens",
"value": 50000
},
"keep": {
"type": "tool_uses",
"value": 5
}
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 16000
messages:
- role: user
content: Search for the latest developments in quantum error correction and summarize the key breakthroughs.
tools:
- type: web_search_20250305
name: web_search
max_uses: 5
context_management:
edits:
- type: clear_thinking_20251015
keep:
type: thinking_turns
value: 2
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 50000
keep:
type: tool_uses
value: 5
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
messages=[
{
"role": "user",
"content": "Search for the latest developments in quantum error correction and summarize the key breakthroughs.",
}
],
tools=[
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 5,
}
],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_thinking_20251015",
"keep": {"type": "thinking_turns", "value": 2},
},
{
"type": "clear_tool_uses_20250919",
"trigger": {"type": "input_tokens", "value": 50000},
"keep": {"type": "tool_uses", "value": 5},
},
]
},
)
print(response)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [
{
role: "user",
content:
"Search for the latest developments in quantum error correction and summarize the key breakthroughs."
}
],
tools: [
{
type: "web_search_20250305",
name: "web_search",
max_uses: 5
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
},
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 50000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
});
console.log(response);
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 16000,
Messages = [
new() { Role = Role.User, Content = "Search for the latest developments in quantum error correction and summarize the key breakthroughs." }
],
Tools = [
new BetaWebSearchTool20250305 { MaxUses = 5 }
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearThinking20251015Edit
{
Keep = new BetaThinkingTurns(2)
},
new BetaClearToolUses20250919Edit
{
Trigger = new BetaInputTokensTrigger(50000),
Keep = new BetaToolUsesKeep(5)
}
]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Search for the latest developments in quantum error correction and summarize the key breakthroughs.")),
},
Tools: []anthropic.BetaToolUnionParam{
{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{
MaxUses: anthropic.Int(5),
}},
},
Betas: []anthropic.AnthropicBeta{
anthropic.AnthropicBetaContextManagement2025_06_27,
},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearThinking20251015: &anthropic.BetaClearThinking20251015EditParam{
Keep: anthropic.BetaClearThinking20251015EditKeepUnionParam{
OfThinkingTurns: &anthropic.BetaThinkingTurnsParam{
Value: 2,
},
},
}},
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
Value: 50000,
},
},
Keep: anthropic.BetaToolUsesKeepParam{
Value: 5,
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearThinking20251015Edit;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.messages.BetaThinkingTurns;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
import com.anthropic.models.beta.messages.BetaToolUsesKeep;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.addUserMessage("Search for the latest developments in quantum error correction and summarize the key breakthroughs.")
.addTool(BetaWebSearchTool20250305.builder()
.maxUses(5L)
.build())
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearThinking20251015Edit.builder()
.keep(BetaThinkingTurns.builder()
.value(2L)
.build())
.build())
.addEdit(BetaClearToolUses20250919Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(50000L)
.build())
.keep(BetaToolUsesKeep.builder()
.value(5L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 16000,
messages: [
[
'role' => 'user',
'content' => 'Search for the latest developments in quantum error correction and summarize the key breakthroughs.'
]
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
[
'type' => 'web_search_20250305',
'name' => 'web_search',
'max_uses' => 5
]
],
contextManagement: [
'edits' => [
[
'type' => 'clear_thinking_20251015',
'keep' => [
'type' => 'thinking_turns',
'value' => 2
]
],
[
'type' => 'clear_tool_uses_20250919',
'trigger' => [
'type' => 'input_tokens',
'value' => 50000
],
'keep' => [
'type' => 'tool_uses',
'value' => 5
]
]
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
messages: [
{
role: "user",
content: "Search for the latest developments in quantum error correction and summarize the key breakthroughs."
}
],
tools: [
{
type: "web_search_20250305",
name: "web_search",
max_uses: 5
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_thinking_20251015",
keep: {
type: "thinking_turns",
value: 2
}
},
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 50000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
)
puts response
```
## Konfigurationsoptionen für das Löschen von Tool-Ergebnissen
| Konfigurationsoption | Standard | Beschreibung |
| -------------------- | --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `trigger` | 100.000 Eingabe-Token | Legt fest, wann die Kontextbearbeitungsstrategie aktiviert wird. Sobald der Prompt diesen Schwellenwert überschreitet, beginnt das Löschen. Du kannst diesen Wert entweder in `input_tokens` oder `tool_uses` angeben. |
| `keep` | 3 Tool-Nutzungen | Legt fest, wie viele der jüngsten Tool-Nutzungs-/Ergebnispaare nach dem Löschen beibehalten werden. Die API entfernt zuerst die ältesten Tool-Interaktionen und behält die jüngsten bei. |
| `clear_at_least` | Keiner | Stellt sicher, 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 hilft zu bestimmen, ob das Löschen des Kontexts es wert ist, deinen Prompt-Cache zu brechen. |
| `exclude_tools` | Keiner | Liste von Tool-Namen, deren Tool-Nutzungen und Ergebnisse niemals gelöscht werden sollen. Nützlich zum Beibehalten wichtigen Kontexts. |
| `clear_tool_inputs` | `false` | Steuert, ob die Tool-Aufrufparameter zusammen mit den Tool-Ergebnissen gelöscht werden. Standardmäßig werden nur die Tool-Ergebnisse gelöscht, während Claudes ursprüngliche Tool-Aufrufe sichtbar bleiben. |
## Antwort der Kontextbearbeitung
Über das Antwortfeld `context_management` kannst du sehen, welche Kontextbearbeitungen auf deine Anfrage angewendet wurden, zusammen mit hilfreichen Statistiken über die gelöschten Inhalte und Eingabe-Token.
```json Output
{
"id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
"type": "message",
"role": "assistant",
"content": [
// ...
],
"usage": {
// ...
},
"context_management": {
"applied_edits": [
// When using `clear_thinking_20251015`
{
"type": "clear_thinking_20251015",
"cleared_thinking_turns": 3,
"cleared_input_tokens": 15000
},
// When using `clear_tool_uses_20250919`
{
"type": "clear_tool_uses_20250919",
"cleared_tool_uses": 8,
"cleared_input_tokens": 50000
}
]
}
}
```
Bei Streaming-Antworten sind die Kontextbearbeitungen im abschließenden `message_delta`-Event enthalten:
```json Streaming Response
{
"type": "message_delta",
"delta": {
"stop_reason": "end_turn",
"stop_sequence": null
},
"usage": {
"output_tokens": 1024
},
"context_management": {
"applied_edits": [
// ...
]
}
}
```
## Token-Zählung
Der Endpunkt zur [Token-Zählung](https://platform.claude.com/docs/de/build-with-claude/token-counting) unterstützt Kontextmanagement, sodass du vorab sehen kannst, wie viele Token dein Prompt nach Anwendung der Kontextbearbeitung verwenden wird.
```bash cURL
curl https://api.anthropic.com/v1/messages/count_tokens \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"messages": [
{
"role": "user",
"content": "Continue our conversation..."
}
],
"context_management": {
"edits": [
{
"type": "clear_tool_uses_20250919",
"trigger": {
"type": "input_tokens",
"value": 30000
},
"keep": {
"type": "tool_uses",
"value": 5
}
}
]
}
}'
```
```bash CLI
ORIGINAL=$(ant beta:messages count-tokens \
--beta context-management-2025-06-27 \
--transform context_management.original_input_tokens \
--raw-output <<'YAML'
model: claude-opus-5-5
messages:
- role: user
content: Continue our conversation...
context_management:
edits:
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 30000
keep:
type: tool_uses
value: 5
YAML
)
INPUT_TOKENS=$(ant beta:messages count-tokens \
--beta context-management-2025-06-27 \
--transform input_tokens --raw-output <<'YAML'
model: claude-opus-5-5
messages:
- role: user
content: Continue our conversation...
context_management:
edits:
- type: clear_tool_uses_20250919
trigger:
type: input_tokens
value: 30000
keep:
type: tool_uses
value: 5
YAML
)
printf 'Original tokens: %s\n' "$ORIGINAL"
printf 'After clearing: %s\n' "$INPUT_TOKENS"
printf 'Savings: %s tokens\n' "$((ORIGINAL - INPUT_TOKENS))"
```
```python Python
response = client.beta.messages.count_tokens(
model="claude-opus-5-5",
messages=[{"role": "user", "content": "Continue our conversation..."}],
betas=["context-management-2025-06-27"],
context_management={
"edits": [
{
"type": "clear_tool_uses_20250919",
"trigger": {"type": "input_tokens", "value": 30000},
"keep": {"type": "tool_uses", "value": 5},
}
]
},
)
print(f"Original tokens: {response.context_management.original_input_tokens}")
print(f"After clearing: {response.input_tokens}")
print(
f"Savings: {response.context_management.original_input_tokens - response.input_tokens} tokens"
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.countTokens({
model: "claude-opus-5-5",
messages: [
{
role: "user",
content: "Continue our conversation..."
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 30000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
});
console.log(`Original tokens: ${response.context_management?.original_input_tokens}`);
console.log(`After clearing: ${response.input_tokens}`);
console.log(
`Savings: ${
(response.context_management?.original_input_tokens || 0) - response.input_tokens
} tokens`
);
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCountTokensParams
{
Model = Messages::Model.ClaudeOpus5_5,
Messages = [new() { Role = Role.User, Content = "Continue our conversation..." }],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [
new BetaClearToolUses20250919Edit
{
Trigger = new BetaInputTokensTrigger(30000),
Keep = new BetaToolUsesKeep(5)
}
]
}
};
var response = await client.Beta.Messages.CountTokens(parameters);
Console.WriteLine($"Original tokens: {response.ContextManagement?.OriginalInputTokens}");
Console.WriteLine($"After clearing: {response.InputTokens}");
Console.WriteLine($"Savings: {(response.ContextManagement?.OriginalInputTokens ?? 0) - response.InputTokens} tokens");
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.CountTokens(context.TODO(), anthropic.BetaMessageCountTokensParams{
Model: anthropic.ModelClaudeOpus5_5,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Continue our conversation...")),
},
Betas: []anthropic.AnthropicBeta{
anthropic.AnthropicBetaContextManagement2025_06_27,
},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{
Trigger: anthropic.BetaClearToolUses20250919EditTriggerUnionParam{
OfInputTokens: &anthropic.BetaInputTokensTriggerParam{
Value: 30000,
},
},
Keep: anthropic.BetaToolUsesKeepParam{
Value: 5,
},
}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Original tokens: %d\n", response.ContextManagement.OriginalInputTokens)
fmt.Printf("After clearing: %d\n", response.InputTokens)
fmt.Printf("Savings: %d tokens\n", response.ContextManagement.OriginalInputTokens-response.InputTokens)
```
```java Java
import com.anthropic.models.beta.messages.BetaMessageTokensCount;
import com.anthropic.models.beta.messages.MessageCountTokensParams;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
import com.anthropic.models.beta.messages.BetaToolUsesKeep;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCountTokensParams params = MessageCountTokensParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.addUserMessage("Continue our conversation...")
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(30000L)
.build())
.keep(BetaToolUsesKeep.builder()
.value(5L)
.build())
.build())
.build())
.build();
BetaMessageTokensCount response = client.beta().messages().countTokens(params);
IO.println("Original tokens: " + response.contextManagement().get().originalInputTokens());
IO.println("After clearing: " + response.inputTokens());
IO.println("Savings: " + (response.contextManagement().get().originalInputTokens() - response.inputTokens()) + " tokens");
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->countTokens(
messages: [
['role' => 'user', 'content' => 'Continue our conversation...']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
contextManagement: [
'edits' => [
[
'type' => 'clear_tool_uses_20250919',
'trigger' => [
'type' => 'input_tokens',
'value' => 30000
],
'keep' => [
'type' => 'tool_uses',
'value' => 5
]
]
]
],
);
echo "Original tokens: " . $response->contextManagement->originalInputTokens . "\n";
echo "After clearing: " . $response->inputTokens . "\n";
echo "Savings: " . ($response->contextManagement->originalInputTokens - $response->inputTokens) . " tokens\n";
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.count_tokens(
model: "claude-opus-5-5",
messages: [
{ role: "user", content: "Continue our conversation..." }
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{
type: "clear_tool_uses_20250919",
trigger: {
type: "input_tokens",
value: 30000
},
keep: {
type: "tool_uses",
value: 5
}
}
]
}
)
puts "Original tokens: #{response.context_management.original_input_tokens}"
puts "After clearing: #{response.input_tokens}"
puts "Savings: #{response.context_management.original_input_tokens - response.input_tokens} tokens"
```
```json Output
{
"input_tokens": 25000,
"context_management": {
"original_input_tokens": 70000
}
}
```
Die Antwort zeigt sowohl die endgültige Token-Anzahl nach Anwendung des Kontextmanagements (`input_tokens`) als auch die ursprüngliche Token-Anzahl vor jeglichem Löschen (`original_input_tokens`).
## Verwendung mit dem Memory-Tool
Kontextbearbeitung kann mit dem [Memory-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/memory-tool) kombiniert werden. Wenn sich dein Gesprächskontext dem konfigurierten Löschschwellenwert nähert, erhält Claude eine automatische Warnung, wichtige Informationen zu sichern. Dies ermöglicht es Claude, Tool-Ergebnisse oder Kontext in seinen Memory-Dateien zu speichern, bevor sie aus dem Gesprächsverlauf gelöscht werden.
Diese Kombination ermöglicht dir:
* **Wichtigen Kontext bewahren:** Claude kann wesentliche Informationen aus Tool-Ergebnissen in Memory-Dateien schreiben, bevor diese Ergebnisse gelöscht werden
* **Lang laufende Workflows aufrechterhalten:** Ermögliche agentische Workflows, die andernfalls Kontextlimits überschreiten würden, indem Informationen in persistenten Speicher ausgelagert werden
* **Bei Bedarf auf Informationen zugreifen:** Claude kann zuvor gelöschte Informationen bei Bedarf in Memory-Dateien nachschlagen, anstatt alles im aktiven Kontextfenster zu behalten
In einem Dateibearbeitungs-Workflow, in dem Claude viele Operationen durchführt, kann Claude beispielsweise abgeschlossene Änderungen in Memory-Dateien zusammenfassen, während der Kontext wächst. Wenn Tool-Ergebnisse gelöscht werden, behält Claude über sein Memory-System Zugriff auf diese Informationen und kann effektiv weiterarbeiten.
Um beide Funktionen zusammen zu verwenden, aktiviere sie in deiner API-Anfrage:
```bash cURL
curl https://api.anthropic.com/v1/messages \
--header "x-api-key: $ANTHROPIC_API_KEY" \
--header "anthropic-version: 2023-06-01" \
--header "content-type: application/json" \
--header "anthropic-beta: context-management-2025-06-27" \
--data '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Hello"
}
],
"tools": [
{
"type": "memory_20250818",
"name": "memory"
}
],
"context_management": {
"edits": [
{"type": "clear_tool_uses_20250919"}
]
}
}'
```
```bash CLI
ant beta:messages create --beta context-management-2025-06-27 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Hello
tools:
- type: memory_20250818
name: memory
context_management:
edits:
- type: clear_tool_uses_20250919
YAML
```
```python Python
response = client.beta.messages.create(
model="claude-opus-5-5",
max_tokens=4096,
messages=[{"role": "user", "content": "Hello"}],
tools=[{"type": "memory_20250818", "name": "memory"}],
betas=["context-management-2025-06-27"],
context_management={"edits": [{"type": "clear_tool_uses_20250919"}]},
)
```
```typescript TypeScript
const anthropic = new Anthropic({
apiKey: process.env.ANTHROPIC_API_KEY
});
const response = await anthropic.beta.messages.create({
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [{ role: "user", content: "Hello" }],
tools: [
{
type: "memory_20250818",
name: "memory"
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [{ type: "clear_tool_uses_20250919" }]
}
});
```
```csharp C#
using Anthropic;
using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = [
new() { Role = Role.User, Content = "Hello" }
],
Tools = [
new BetaMemoryTool20250818()
],
Betas = [AnthropicBeta.ContextManagement2025_06_27],
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaClearToolUses20250919Edit()]
}
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello")),
},
Tools: []anthropic.BetaToolUnionParam{
{OfMemoryTool20250818: &anthropic.BetaMemoryTool20250818Param{}},
},
Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaContextManagement2025_06_27},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfClearToolUses20250919: &anthropic.BetaClearToolUses20250919EditParam{}},
},
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaMemoryTool20250818;
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaClearToolUses20250919Edit;
import com.anthropic.models.beta.AnthropicBeta;
// ...
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Hello")
.addTool(BetaMemoryTool20250818.builder().build())
.addBeta(AnthropicBeta.CONTEXT_MANAGEMENT_2025_06_27)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaClearToolUses20250919Edit.builder().build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
['role' => 'user', 'content' => 'Hello']
],
model: 'claude-opus-5-5',
betas: ['context-management-2025-06-27'],
tools: [
[
'type' => 'memory_20250818',
'name' => 'memory'
]
],
contextManagement: [
'edits' => [
['type' => 'clear_tool_uses_20250919']
]
],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-opus-5-5",
max_tokens: 4096,
messages: [{ role: "user", content: "Hello" }],
tools: [
{
type: "memory_20250818",
name: "memory"
}
],
betas: ["context-management-2025-06-27"],
context_management: {
edits: [
{ type: "clear_tool_uses_20250919" }
]
}
)
puts response
```
Die vollständige Referenz zum Memory-Tool einschließlich Befehlen und Beispielen findest du unter [Memory-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/memory-tool).
## Clientseitige Komprimierung (SDK)
**Anthropic empfiehlt serverseitige Komprimierung gegenüber SDK-Komprimierung.** Die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction) übernimmt das Kontextmanagement automatisch mit geringerer Integrationskomplexität, besserer Berechnung der Token-Nutzung und ohne clientseitige Einschränkungen. Verwende SDK-Komprimierung nur, wenn du ausdrücklich clientseitige Kontrolle über den Zusammenfassungsprozess benötigst.
Der Parameter `compaction_control` ist in den TypeScript- und Ruby-SDKs abgekündigt und wird in einer zukünftigen Version entfernt. Die SDKs geben eine Abkündigungswarnung aus, wenn er aktiviert ist. Das Python-SDK hat ihn in v1.0 entfernt. Um serverseitige Komprimierung mit einem Tool-Runner zu verwenden, übergib den Edit `compact_20260112` im Parameter `context_management` der Anfrage.
Komprimierung ist in den [TypeScript- und Ruby-SDKs](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) verfügbar, wenn die [`tool_runner`-Methode](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-runner) verwendet wird.
„Compaction“ (Komprimierung) ist eine SDK-Funktion, die den Gesprächskontext automatisch verwaltet, indem sie Zusammenfassungen erzeugt, wenn die Token-Nutzung zu groß wird. Im Gegensatz zu serverseitigen Kontextbearbeitungsstrategien, die Inhalte löschen, weist die Komprimierung Claude an, den Gesprächsverlauf zusammenzufassen, und ersetzt dann den vollständigen Verlauf durch diese Zusammenfassung. Dies ermöglicht es Claude, an lang laufenden Aufgaben weiterzuarbeiten, die andernfalls das [„context window“ (Kontextfenster)](https://platform.claude.com/docs/de/build-with-claude/context-windows) überschreiten würden.
### Wie Komprimierung funktioniert
Wenn Komprimierung aktiviert ist, überwacht das SDK die Token-Nutzung nach jeder Modellantwort:
1. **Schwellenwertprüfung:** Das SDK berechnet die Gesamtzahl der Token als `input_tokens + cache_creation_input_tokens + cache_read_input_tokens + output_tokens` (siehe [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching) für die Cache-Token-Felder).
2. **Erzeugung der Zusammenfassung:** Wenn der Schwellenwert überschritten wird, wird ein Zusammenfassungs-Prompt als Benutzerzug eingefügt, und Claude erzeugt eine strukturierte Zusammenfassung, die in ``-Tags eingeschlossen ist.
3. **Kontextersetzung:** Das SDK extrahiert die Zusammenfassung und ersetzt den gesamten Nachrichtenverlauf durch sie.
4. **Fortsetzung:** Das Gespräch wird von der Zusammenfassung aus fortgesetzt, wobei Claude dort weitermacht, wo es aufgehört hat.
### Komprimierung verwenden
Füge `compaction_control` zu deinem `tool_runner`-Aufruf hinzu, um die automatische Zusammenfassung zu aktivieren, wenn die Token-Nutzung den Schwellenwert überschreitet.
Komprimierung läuft clientseitig in den `tool_runner`-Helfern des SDK und hat daher kein direktes HTTP-Äquivalent. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction), die die Komprimierung auf den Servern von Anthropic übernimmt.
Die CLI enthält keinen `tool_runner`-Helfer. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction), die die Komprimierung auf den Servern von Anthropic ohne SDK-seitige Integration übernimmt.
Ab v1.0 unterstützt der Tool-Runner des Python-SDK kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool-Runner, indem du die Bearbeitung `compact_20260112` im Parameter `context_management` der Anfrage übergibst.
```typescript TypeScript
const client = new Anthropic();
const runner = client.beta.messages.toolRunner({
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [readFile],
messages: [{ role: "user", content: "What's in config.json?" }],
compactionControl: { enabled: true, contextTokenThreshold: 100000 }
});
for await (const message of runner) {
console.log(`Tokens used: ${message.usage.input_tokens}`);
}
```
Das C#-SDK enthält einen Tool-Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool-Runner, indem du die Bearbeitung `compact_20260112` im Parameter `context_management` der Anfrage übergibst.
Das Go-SDK enthält einen Tool-Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool-Runner, indem du die Bearbeitung `compact_20260112` im Parameter `context_management` der Anfrage übergibst.
Das Java-SDK enthält einen Tool-Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool-Runner, indem du die Bearbeitung `compact_20260112` im Parameter `context_management` der Anfrage übergibst.
Das PHP-SDK enthält einen Tool-Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool-Runner, indem du die Bearbeitung `compact_20260112` im Parameter `context_management` der Anfrage übergibst.
```ruby Ruby
client = Anthropic::Client.new
runner = client.beta.messages.tool_runner(
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
compaction_control: { enabled: true, context_token_threshold: 100000 }
)
runner.each_message do |message|
puts "Tokens used: #{message.usage.input_tokens}"
end
```
#### Was während der Komprimierung geschieht
Während das Gespräch wächst, sammelt sich der Nachrichtenverlauf an:
**Vor der Komprimierung (nahe 100k Token):**
```json
[
{ "role": "user", "content": "Analyze all files and write a report..." },
{ "role": "assistant", "content": "I'll help. Let me start by reading..." },
{
"role": "user",
"content": [{ "type": "tool_result", "tool_use_id": "...", "content": "..." }]
},
{ "role": "assistant", "content": "Based on file1.txt, I see..." },
{
"role": "user",
"content": [{ "type": "tool_result", "tool_use_id": "...", "content": "..." }]
},
{ "role": "assistant", "content": "After analyzing file2.txt..." }
// ... 50 more exchanges like this ...
]
```
Wenn die Token den Schwellenwert überschreiten, fügt das SDK eine Zusammenfassungsanfrage ein und Claude erzeugt eine Zusammenfassung. Der gesamte Verlauf wird dann ersetzt:
**Nach der Komprimierung (zurück auf \~2–3k Token):**
```json
[
{
"role": "assistant",
"content": "# Task Overview\nThe user requested analysis of directory files to produce a summary report...\n\n# Current State\nAnalyzed 52 files across 3 subdirectories. Key findings documented in report.md...\n\n# Important Discoveries\n- Configuration files use YAML format\n- Found 3 deprecated dependencies\n- Test coverage at 67%\n\n# Next Steps\n1. Analyze remaining files in /src/legacy\n2. Complete final report sections...\n\n# Context to Preserve\nUser prefers markdown format with executive summary first..."
}
]
```
Claude arbeitet von dieser Zusammenfassung aus weiter, als wäre sie der ursprüngliche Gesprächsverlauf.
### Konfigurationsoptionen
| Parameter | Typ | Erforderlich | Standard | Beschreibung |
| ------------------------- | ------- | ------------ | -------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- |
| `enabled` | boolean | Ja | - | Ob die automatische Komprimierung aktiviert werden soll |
| `context_token_threshold` | number | Nein | 100.000 | Token-Anzahl, bei der die Komprimierung ausgelöst wird |
| `model` | string | Nein | Gleich wie Hauptmodell | Modell, das zur Erzeugung von Zusammenfassungen verwendet wird |
| `summary_prompt` | string | Nein | Siehe [Standard-Zusammenfassungs-Prompt](https://platform.claude.com/docs/de/build-with-claude/context-editing#default-summary-prompt) | Benutzerdefinierter Prompt für die Erzeugung der Zusammenfassung |
#### Einen Token-Schwellenwert wählen
Der Schwellenwert bestimmt, wann die Komprimierung erfolgt. Ein niedrigerer Schwellenwert bedeutet häufigere Komprimierungen mit kleineren Kontextfenstern. Ein höherer Schwellenwert erlaubt mehr Kontext, birgt aber das Risiko, Limits zu erreichen.
Komprimierung läuft clientseitig in den `tool_runner`-Helfern des SDK und hat daher kein direktes HTTP-Äquivalent. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction), die die Komprimierung auf den Servern von Anthropic übernimmt.
Die CLI enthält keinen `tool_runner`-Helfer. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction), die die Komprimierung auf den Servern von Anthropic ohne SDK-seitige Integration übernimmt.
Ab v1.0 unterstützt der Tool Runner des Python SDK kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
```typescript TypeScript
const client = new Anthropic();
const runner = client.beta.messages.toolRunner({
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [readFile],
messages: [{ role: "user", content: "What's in config.json?" }],
// Niedrigere Werte komprimieren öfter; erhöhe auf 150000, wenn die Aufgabe mehr Kontext braucht
compactionControl: { enabled: true, contextTokenThreshold: 50000 }
});
for await (const message of runner) {
console.log(`Tokens used: ${message.usage.input_tokens}`);
}
```
Das C# SDK enthält einen Tool Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
Das Go SDK enthält einen Tool Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
Das Java SDK enthält einen Tool Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
Das PHP SDK enthält einen Tool Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
```ruby Ruby
client = Anthropic::Client.new
runner = client.beta.messages.tool_runner(
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
# Niedrigere Werte komprimieren öfter; erhöhe auf 150000, wenn die Aufgabe mehr Kontext braucht
compaction_control: { enabled: true, context_token_threshold: 50000 }
)
runner.each_message do |message|
puts "Tokens used: #{message.usage.input_tokens}"
end
```
#### Ein anderes Modell für Zusammenfassungen verwenden
Du kannst ein schnelleres oder günstigeres Modell zur Erzeugung von Zusammenfassungen verwenden:
Komprimierung läuft clientseitig in den `tool_runner`-Helfern des SDK und hat daher kein direktes HTTP-Äquivalent. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction), die die Komprimierung auf den Servern von Anthropic übernimmt.
Die CLI enthält keinen `tool_runner`-Helfer. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction), die die Komprimierung auf den Servern von Anthropic ohne SDK-seitige Integration übernimmt.
Ab v1.0 unterstützt der Tool Runner des Python SDK kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
```typescript TypeScript
const client = new Anthropic();
const runner = client.beta.messages.toolRunner({
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [readFile],
messages: [{ role: "user", content: "What's in config.json?" }],
compactionControl: {
enabled: true,
contextTokenThreshold: 100000,
model: "claude-haiku-4-5"
}
});
for await (const message of runner) {
console.log(`Tokens used: ${message.usage.input_tokens}`);
}
```
Das C# SDK enthält einen Tool Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
Das Go SDK enthält einen Tool Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
Das Java SDK enthält einen Tool Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
Das PHP SDK enthält einen Tool Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
```ruby Ruby
client = Anthropic::Client.new
runner = client.beta.messages.tool_runner(
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
compaction_control: {
enabled: true,
context_token_threshold: 100000,
model: "claude-haiku-4-5"
}
)
runner.each_message do |message|
puts "Tokens used: #{message.usage.input_tokens}"
end
```
#### Benutzerdefinierte Zusammenfassungs-Prompts
Du kannst einen benutzerdefinierten Prompt für domänenspezifische Anforderungen bereitstellen. Dein Prompt sollte Claude anweisen, seine Zusammenfassung in ``-Tags einzuschließen.
Komprimierung läuft clientseitig in den `tool_runner`-Helfern des SDK und hat daher kein direktes HTTP-Äquivalent. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction), die die Komprimierung auf den Servern von Anthropic übernimmt.
Die CLI enthält keinen `tool_runner`-Helfer. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction), die die Komprimierung auf den Servern von Anthropic ohne SDK-seitige Integration übernimmt.
Ab v1.0 unterstützt der Tool Runner des Python SDK kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
```typescript TypeScript
const client = new Anthropic();
const runner = client.beta.messages.toolRunner({
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [readFile],
messages: [{ role: "user", content: "What's in config.json?" }],
compactionControl: {
enabled: true,
contextTokenThreshold: 100000,
summaryPrompt: `Summarize the research conducted so far, including:
- Sources consulted and key findings
- Questions answered and remaining unknowns
- Recommended next steps
Wrap your summary in tags.`
}
});
for await (const message of runner) {
console.log(`Tokens used: ${message.usage.input_tokens}`);
}
```
Das C# SDK enthält einen Tool Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
Das Go SDK enthält einen Tool Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
Das Java SDK enthält einen Tool Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
Das PHP SDK enthält einen Tool Runner, unterstützt aber kein clientseitiges `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold): Sie funktioniert mit dem Tool Runner, indem du die `compact_20260112`-Bearbeitung im Parameter `context_management` der Anfrage übergibst.
```ruby Ruby
client = Anthropic::Client.new
runner = client.beta.messages.tool_runner(
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
compaction_control: {
enabled: true,
context_token_threshold: 100000,
summary_prompt: <<~PROMPT
Summarize the research conducted so far, including:
- Sources consulted and key findings
- Questions answered and remaining unknowns
- Recommended next steps
Wrap your summary in tags.
PROMPT
}
)
runner.each_message do |message|
puts "Tokens used: #{message.usage.input_tokens}"
end
```
### Standard-Zusammenfassungs-Prompt
Der integrierte Zusammenfassungs-Prompt weist Claude an, eine strukturierte Fortsetzungszusammenfassung zu erstellen, die Folgendes enthält:
1. **Aufgabenüberblick:** Die Kernanfrage des Benutzers, Erfolgskriterien und Einschränkungen.
2. **Aktueller Stand:** Was abgeschlossen wurde, geänderte Dateien und erzeugte Artefakte.
3. **Wichtige Erkenntnisse:** Technische Einschränkungen, getroffene Entscheidungen, behobene Fehler und gescheiterte Ansätze.
4. **Nächste Schritte:** Konkret erforderliche Aktionen, Blocker und Prioritätsreihenfolge.
5. **Zu bewahrender Kontext:** Benutzerpräferenzen, domänenspezifische Details und eingegangene Verpflichtungen.
Diese Struktur ermöglicht es Claude, die Arbeit effizient wieder aufzunehmen, ohne wichtigen Kontext zu verlieren oder Fehler zu wiederholen.
```text wrap
You have been working on the task described above but have not yet completed it. Write a continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary. Your summary should be structured, concise, and actionable. Include:
1. Task Overview
The user's core request and success criteria
Any clarifications or constraints they specified
2. Current State
What has been completed so far
Files created, modified, or analyzed (with paths if relevant)
Key outputs or artifacts produced
3. Important Discoveries
Technical constraints or requirements uncovered
Decisions made and their rationale
Errors encountered and how they were resolved
What approaches were tried that didn't work (and why)
4. Next Steps
Specific actions needed to complete the task
Any blockers or open questions to resolve
Priority order if multiple steps remain
5. Context to Preserve
User preferences or style requirements
Domain-specific details that aren't obvious
Any promises made to the user
Be concise but complete—err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task.
Wrap your summary in tags.
```
### Einschränkungen
#### Serverseitige Tools
Komprimierung erfordert besondere Beachtung bei der Verwendung serverseitiger Tools wie [Websuche](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool) oder [Web-Fetch](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool).
Bei der Verwendung serverseitiger Tools kann das SDK die Token-Nutzung falsch berechnen, wodurch die Komprimierung zum falschen Zeitpunkt ausgelöst wird.
Nach einer Websuche-Operation könnte die API-Antwort beispielsweise Folgendes zeigen:
```json Output
{
"usage": {
"input_tokens": 63000,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 270000,
"output_tokens": 1400
}
}
```
Das SDK berechnet die Gesamtnutzung als 63.000 + 0 + 270.000 + 1.400 = 334.400 Token. Der Wert `cache_read_input_tokens` enthält jedoch akkumulierte Lesevorgänge aus mehreren internen API-Aufrufen des serverseitigen Tools, nicht deinen tatsächlichen Gesprächskontext. Deine reale Kontextlänge beträgt möglicherweise nur die 63.000 `input_tokens`, aber das SDK sieht 334k und löst die Komprimierung vorzeitig aus.
**Workarounds:**
* Verwende den Endpunkt zur [Token-Zählung](https://platform.claude.com/docs/de/build-with-claude/token-counting), um die genaue Kontextlänge zu erhalten
* Vermeide Komprimierung, wenn du serverseitige Tools intensiv nutzt
#### Sonderfälle bei der Tool-Nutzung
Wenn das SDK die Komprimierung auslöst, während eine Tool-Nutzungsantwort aussteht, entfernt es den Tool-Nutzungsblock aus dem Nachrichtenverlauf, bevor es die Zusammenfassung erzeugt. Claude wird den Tool-Aufruf nach der Fortsetzung von der Zusammenfassung aus erneut ausführen, falls er noch benötigt wird.
### Komprimierung überwachen
Zu verstehen, wann die Komprimierung ausgelöst wird, hilft dir, Schwellenwerte abzustimmen und das erwartete Verhalten zu überprüfen.
Komprimierung läuft clientseitig in den `tool_runner`-Helfern des SDK und hat daher kein direktes HTTP-Äquivalent. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction), die die Komprimierung auf den Servern von Anthropic übernimmt.
Die CLI enthält keinen `tool_runner`-Helfer. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction), die die Komprimierung auf den Servern von Anthropic ohne SDK-seitige Integration übernimmt.
Ab v1.0 unterstützt der Tool-Runner des Python-SDK kein `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction).
Der `toolRunner` des TypeScript-SDK unterstützt Komprimierung, protokolliert aber keine Events. Erkenne die Komprimierung, indem du beobachtest, wie `runner.params.messages.length` zwischen den Zügen schrumpft:
```typescript TypeScript
let prevMsgCount = 0;
for await (const message of runner) {
const currMsgCount = runner.params.messages.length;
if (currMsgCount < prevMsgCount) {
console.log(`Compaction occurred: ${prevMsgCount} -> ${currMsgCount} messages`);
console.log(`Input tokens after compaction: ${message.usage.input_tokens}`);
}
prevMsgCount = currMsgCount;
}
```
Der Tool-Runner des C#-SDK unterstützt kein `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction).
Der Tool-Runner des Go-SDK unterstützt kein `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction).
Der Tool-Runner des Java-SDK unterstützt kein `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction).
Der Tool-Runner des PHP-SDK unterstützt kein `compaction_control`. Verwende stattdessen die [serverseitige Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction).
Das Ruby-SDK unterstützt einen `on_compact:`-Callback, der ausgelöst wird, wenn eine Komprimierung erfolgt. Füge ihn zu deiner `compaction_control`-Konfiguration hinzu:
```ruby Ruby
client = Anthropic::Client.new
runner = client.beta.messages.tool_runner(
model: "claude-opus-5-5",
max_tokens: 1024,
tools: [ReadFile.new],
messages: [{ role: "user", content: "What's in config.json?" }],
compaction_control: {
enabled: true,
context_token_threshold: 100000,
on_compact: ->(tokens_before, tokens_after) do
puts "Compaction occurred: #{tokens_before} -> #{tokens_after} tokens"
end
}
)
runner.each_message do |message|
puts "Tokens: #{message.usage.input_tokens}"
end
```
### Wann Komprimierung verwendet werden sollte
**Gute Anwendungsfälle:**
* Lang laufende Agentenaufgaben, die viele Dateien oder Datenquellen verarbeiten
* Recherche-Workflows, die große Mengen an Informationen ansammeln
* Mehrstufige Aufgaben mit klarem, messbarem Fortschritt
* Aufgaben, die Artefakte (Dateien, Berichte) erzeugen, die außerhalb des Gesprächs bestehen bleiben
**Weniger ideale Anwendungsfälle:**
* Aufgaben, die eine präzise Erinnerung an frühe Gesprächsdetails erfordern
* Workflows, die serverseitige Tools intensiv nutzen
* Aufgaben, die einen exakten Zustand über viele Variablen hinweg aufrechterhalten müssen
## Nächste Schritte
Verwalte lange Gespräche mit serverseitiger Komprimierung, der empfohlenen Strategie für die meisten Anwendungsfälle.
Reduziere Kosten und Latenz durch das Caching von Prompt-Präfixen und erfahre, wie Kontextbearbeitung mit dem Cache interagiert.