---
title: Komprimierung bei einem Token-Schwellenwert
url: https://platform.claude.com/docs/de/build-with-claude/compaction-threshold
description: Lass die API älteren Kontext automatisch innerhalb einer gewöhnlichen Anfrage zusammenfassen, wenn die Konversation einen von dir festgelegten Token-Schwellenwert erreicht.
featureMetadata:
status: beta
betaHeader: compact-2026-01-12
zdr:
eligibility: eligible
note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements). Ergebnisse der serverseitigen Komprimierung werden zustandslos über die API-Antwort zurückgegeben und zurückgesendet.
supportedModels:
- claude-fable-5-1
- claude-mythos-5-1
- claude-fable-5
- claude-mythos-5
- claude-mythos-preview
- claude-opus-5-5
- claude-opus-5
- claude-sonnet-5-5
- claude-sonnet-5
- claude-haiku-5-5
- claude-opus-4-8
- claude-opus-4-7
- claude-opus-4-6
- claude-sonnet-4-6
supportedPlatforms:
Claude API: beta
Claude Platform on AWS: beta
Amazon Bedrock: beta
Amazon Bedrock (InvokeModel): beta
Claude Models on Google Cloud (Google managed): beta
Microsoft Foundry: beta
---
**API-Unterstützung**: Nutzung unterscheidet sich je nach Produkt.
* **Messages API**: Aktiviere sie mit einer `compact_20260112`-Bearbeitung; die Komprimierung beginnt standardmäßig bei 150.000 Eingabetokens.
* **Managed Agents**: Immer aktiv. Sie komprimiert den Unterhaltungsverlauf der Sitzung, damit er in das Kontextfenster passt.
„Threshold compaction“ (Schwellenwert-Komprimierung) ist die automatische Form der „compaction“ (Komprimierung): Du legst bei deinen gewöhnlichen Anfragen einen „token threshold“ (Token-Schwellenwert) fest, und die API fasst älteren Kontext mitten in einer Anfrage zusammen, sobald der Schwellenwert erreicht ist. Sie wird neben der Komprimierung auf Anfrage unterstützt, bei der du selbst entscheidest, wann die Zusammenfassung geschrieben wird (siehe [Komprimierung auf Anfrage](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand)). Wie du zwischen beiden wählst, erfährst du unter [Wähle, wie komprimiert werden soll](https://platform.claude.com/docs/de/build-with-claude/compaction#choose-how-to-compact).
Die Komprimierung erweitert die effektive Kontextlänge für lang laufende Unterhaltungen und Aufgaben, indem älterer Kontext automatisch zusammengefasst wird, wenn sich die Unterhaltung der Grenze des „context window“ (Kontextfenster) nähert. Außerdem hält sie den aktiven Kontext klein: Wenn eine Unterhaltung wächst, nimmt die Antwortqualität ab, daher ersetzt die Komprimierung älteren Inhalt durch eine prägnante Zusammenfassung.
Einen tieferen Einblick, warum lange Kontexte an Qualität verlieren und wie Komprimierung hilft, findest du unter [Effektives Kontext-Engineering](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents).
Das ist ideal für:
* Chatbasierte Unterhaltungen mit mehreren Turns, bei denen Nutzer einen Chat über einen langen Zeitraum verwenden sollen
* Aufgabenorientierte Prompts, die viel Folgearbeit erfordern (oft „tool use“ (Tool-Nutzung)), die das Kontextfenster überschreiten könnte
## Wie Komprimierung funktioniert
Wenn die Komprimierung aktiviert ist, fasst Claude deine Unterhaltung automatisch zusammen, sobald sie den konfigurierten Token-Schwellenwert erreicht. Die API:
1. Erkennt, wann die Eingabe-Token deinen angegebenen Trigger-Schwellenwert erreichen.
2. Erstellt eine Zusammenfassung der aktuellen Unterhaltung.
3. Erzeugt einen `compaction`-Block, der die Zusammenfassung enthält.
4. Setzt die Antwort mit dem komprimierten Kontext fort.
Hänge bei nachfolgenden Anfragen die Antwort an deine Nachrichten an. Die API verwirft automatisch alle Inhaltsblöcke vor dem `compaction`-Block und setzt die Unterhaltung ab der Zusammenfassung fort.
## Grundlegende Verwendung
Aktiviere die Komprimierung, indem du die Strategie `compact_20260112` zu `context_management.edits` in deiner Messages-API-Anfrage hinzufügst.
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Help me build a website"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta compact-2026-01-12 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Help me build a website
context_management:
edits:
- type: compact_20260112
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Help me build a website"}]
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
# Hänge die Antwort (inklusive eines etwaigen Compaction-Blocks) an, um die Unterhaltung fortzusetzen
messages.append({"role": "assistant", "content": response.content})
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Help me build a website" }
];
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112"
}
]
}
});
// Hänge die Antwort (inkl. eines etwaigen Compaction-Blocks) an, um die Unterhaltung fortzusetzen
messages.push({
role: "assistant",
content: response.content
});
```
```csharp C#
AnthropicClient client = new();
var messages = new List
{
new BetaUserMessageParam { Content = "Help me build a website" }
};
var parameters = new MessageCreateParams
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
};
var response = await client.Beta.Messages.Create(parameters);
// Hänge die Antwort (inkl. eines etwaigen Compaction-Blocks) an, um die Unterhaltung fortzusetzen
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Help me build a website")),
}
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
// Hänge die Antwort (inkl. eines etwaigen Compaction-Blocks) an, um die Unterhaltung fortzusetzen
messages = append(messages, response.ToParam())
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Help me build a website")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
// Hänge die Antwort (inkl. eines etwaigen Compaction-Blocks) an, um die Unterhaltung fortzusetzen,
// indem du sie in die messages der nächsten Anfrage aufnimmst
System.out.println(response);
```
```php PHP
$client = new Client();
$messages = [
['role' => 'user', 'content' => 'Help me build a website']
];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: Model::CLAUDE_OPUS_5_5,
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
['type' => 'compact_20260112']
]
]
);
// Hänge die Antwort (inklusive eines etwaigen Compaction-Blocks) an, um die Unterhaltung fortzusetzen
$messages[] = ['role' => 'assistant', 'content' => $response->content];
echo json_encode($response, JSON_PRETTY_PRINT), PHP_EOL;
```
```ruby Ruby
client = Anthropic::Client.new
messages = [
{ role: "user", content: "Help me build a website" }
]
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
# Hänge die Antwort (inklusive eines etwaigen Compaction-Blocks) an, um die Unterhaltung fortzusetzen
messages << { role: "assistant", content: response.content }
puts response
```
## Parameter
| Parameter | Typ | Standardwert | Beschreibung |
| ------------------------ | ------- | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | string | Erforderlich | Muss `"compact_20260112"` sein |
| `trigger` | object | `{"type": "input_tokens", "value": 150000}` | Wann die Komprimierung ausgelöst wird. `input_tokens` ist der einzige unterstützte Trigger-Typ. `value` muss mindestens 50.000 Token betragen. |
| `pause_after_compaction` | boolean | `false` | Ob nach dem Erstellen der Komprimierungszusammenfassung pausiert werden soll |
| `instructions` | string | `null` | Benutzerdefinierter Zusammenfassungs-Prompt. Ersetzt den Standard-Prompt vollständig, wenn angegeben. |
### Trigger-Konfiguration
Lege mit dem Parameter `trigger` fest, wann die Komprimierung ausgelöst wird:
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Hello, Claude"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"trigger": {
"type": "input_tokens",
"value": 150000
}
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta compact-2026-01-12 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
trigger:
type: input_tokens
value: 150000
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={
"edits": [
{
"type": "compact_20260112",
"trigger": {"type": "input_tokens", "value": 150000},
}
]
},
)
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: {
type: "input_tokens",
value: 150000
}
}
]
}
});
```
```csharp C#
AnthropicClient client = new();
List messages = [new BetaUserMessageParam { Content = "Hello" }];
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Betas = ["compact-2026-01-12"],
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit
{
Trigger = new BetaInputTokensTrigger(150000)
}]
}
};
var message = await client.Beta.Messages.Create(parameters);
Console.WriteLine(message);
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
Trigger: anthropic.BetaInputTokensTriggerParam{Value: 150000},
}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addBeta("compact-2026-01-12")
.addUserMessage("Hello, Claude")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(150000L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
System.out.println(response);
```
```php PHP
$client = new Client();
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];
$message = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: Model::CLAUDE_OPUS_5_5,
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
[
'type' => 'compact_20260112',
'trigger' => [
'type' => 'input_tokens',
'value' => 150000
]
]
]
]
);
echo $message;
```
```ruby Ruby
client = Anthropic::Client.new
messages = [{ role: "user", content: "Hello, Claude" }]
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: {
type: "input_tokens",
value: 150000
}
}
]
}
)
puts response
```
### Benutzerdefinierte Zusammenfassungsanweisungen
Der Standard-Zusammenfassungs-Prompt variiert je nach Modell. Jeder Standard-Prompt weist Claude an, eine Zusammenfassung innerhalb von ``-Tags zu schreiben, die die Informationen enthält, die zum Fortsetzen der Aufgabe in einem zukünftigen Kontextfenster benötigt werden. Einige Modelle verwenden beispielsweise den folgenden Prompt:
```text wrap
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.
```
Du kannst über den Parameter `instructions` benutzerdefinierte Anweisungen angeben. Benutzerdefinierte Anweisungen ergänzen den Standard-Prompt nicht. Sie ersetzen ihn vollständig:
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Hello, Claude"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"instructions": "Focus on preserving code snippets, variable names, and technical decisions."
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta compact-2026-01-12 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
instructions: >-
Focus on preserving code snippets, variable names, and
technical decisions.
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={
"edits": [
{
"type": "compact_20260112",
"instructions": "Focus on preserving code snippets, variable names, and technical decisions.",
}
]
},
)
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112",
instructions:
"Focus on preserving code snippets, variable names, and technical decisions."
}
]
}
});
```
```csharp C#
AnthropicClient client = new();
var parameters = new MessageCreateParams
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages =
[
new BetaUserMessageParam { Content = "Help me build a Python web scraper" },
new BetaAssistantMessageParam { Content = "I'll help you build a web scraper..." },
new BetaUserMessageParam { Content = "Add support for JavaScript-rendered pages" }
],
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit
{
Instructions = "Focus on preserving code snippets, variable names, and technical decisions."
}]
}
};
var message = await client.Beta.Messages.Create(parameters);
Console.WriteLine(message);
```
```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("Help me build a Python web scraper")),
{OfAssistant: &anthropic.BetaAssistantMessageParam{Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("I'll help you build a web scraper...")}}},
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Add support for JavaScript-rendered pages")),
},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
Instructions: anthropic.String("Focus on preserving code snippets, variable names, and technical decisions."),
}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Help me build a Python web scraper")
.addAssistantMessage("I'll help you build a web scraper...")
.addUserMessage("Add support for JavaScript-rendered pages")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder()
.instructions("Focus on preserving code snippets, variable names, and technical decisions.")
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
System.out.println(response);
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
['role' => 'user', 'content' => 'Help me build a Python web scraper'],
['role' => 'assistant', 'content' => "I'll help you build a web scraper..."],
['role' => 'user', 'content' => 'Add support for JavaScript-rendered pages']
],
model: Model::CLAUDE_OPUS_5_5,
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
[
'type' => 'compact_20260112',
'instructions' => 'Focus on preserving code snippets, variable names, and technical decisions.'
]
]
]
);
echo json_encode($response, JSON_PRETTY_PRINT), PHP_EOL;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: [
{ role: "user", content: "Help me build a Python web scraper" },
{ role: "assistant", content: "I'll help you build a web scraper..." },
{ role: "user", content: "Add support for JavaScript-rendered pages" }
],
context_management: {
edits: [
{
type: "compact_20260112",
instructions:
"Focus on preserving code snippets, variable names, and technical decisions."
}
]
}
)
puts response
```
Bei Claude 5.1 und neueren Modellen fasst eine Anfrage mit benutzerdefinierten `instructions` nur die sichtbare Unterhaltung zusammen: Frühere Thinking-Blöcke sind nicht Teil der Eingabe für die Zusammenfassung.
### Pausieren nach der Komprimierung
Verwende `pause_after_compaction`, um die API nach dem Erstellen der Komprimierungszusammenfassung zu pausieren. So kannst du zusätzliche Inhaltsblöcke hinzufügen (etwa um aktuelle Nachrichten oder bestimmte anweisungsorientierte Nachrichten zu erhalten), bevor die API mit der Antwort fortfährt.
Wenn diese Option aktiviert ist, gibt die API nach dem Erstellen des Komprimierungsblocks eine Nachricht mit dem Stop-Grund `compaction` zurück:
```bash cURL
# pause_after_compaction stoppt die Antwort direkt nach der Compaction-
# Zusammenfassung, damit du die Nachrichten vor dem Fortsetzen anpassen kannst. Der Fortsetzungs-
# schritt lässt sich schlecht als einmaliger Shell-Befehl abbilden; siehe die SDK-Tabs
# für den vollständigen Pause-und-Fortsetzen-Ablauf. Einzelne pausierte Anfrage:
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Hello, Claude"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"pause_after_compaction": true
}
]
}
}'
```
```bash CLI
# pause_after_compaction stoppt die Antwort direkt nach der Compaction-
# Zusammenfassung, damit du die Nachrichten vor dem Fortsetzen anpassen kannst. Der Fortsetzungs-
# schritt lässt sich schlecht als einmaliger CLI-Befehl abbilden; siehe die SDK-Tabs
# für den vollständigen Pause-und-Fortsetzen-Ablauf. Einzelne pausierte Anfrage:
ant beta:messages create --beta compact-2026-01-12 --format jsonl <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
pause_after_compaction: true
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={
"edits": [{"type": "compact_20260112", "pause_after_compaction": True}]
},
)
# Prüfe, ob die Compaction eine Pause ausgelöst hat
if response.stop_reason == "compaction":
# Antwort enthält nur den Compaction-Block
messages.append({"role": "assistant", "content": response.content})
# Setze die Anfrage fort
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
let response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112",
pause_after_compaction: true
}
]
}
});
// Prüfe, ob die Compaction eine Pause ausgelöst hat
if (response.stop_reason === "compaction") {
// Die Antwort enthält nur den Compaction-Block
messages.push({
role: "assistant",
content: response.content
});
// Setze die Anfrage fort
response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
}
```
```csharp C#
var client = new AnthropicClient();
var messages = new List
{
new BetaUserMessageParam { Content = "Hello, Claude" }
};
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Betas = ["compact-2026-01-12"],
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit
{
PauseAfterCompaction = true
}]
}
};
var response = await client.Beta.Messages.Create(parameters);
if (response.StopReason == BetaStopReason.Compaction)
{
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
parameters = new()
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Betas = ["compact-2026-01-12"],
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
};
response = await client.Beta.Messages.Create(parameters);
}
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}
compactEdit := anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
PauseAfterCompaction: anthropic.Bool(true),
}},
},
}
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: compactEdit,
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
if response.StopReason == "compaction" {
messages = append(messages, response.ToParam())
response, err = client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaStopReason;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addBeta("compact-2026-01-12")
.addUserMessage("Help me build a website")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder()
.pauseAfterCompaction(true)
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
// Prüfe, ob die Compaction eine Pause ausgelöst hat
if (response.stopReason().isPresent()
&& response.stopReason().get().equals(BetaStopReason.COMPACTION)) {
// Hänge den Compaction-Block an und setze die Anfrage fort
// indem du eine neue Anfrage mit dem komprimierten Kontext erstellst
MessageCreateParams continueParams = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addBeta("compact-2026-01-12")
.addUserMessage("Help me build a website")
.addMessage(response)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build();
response = client.beta().messages().create(continueParams);
}
System.out.println(response);
```
```php PHP
$client = new Client();
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
[
'type' => 'compact_20260112',
'pause_after_compaction' => true
]
]
]
);
if ($response->stopReason === 'compaction') {
$messages[] = [
'role' => 'assistant',
'content' => $response->content
];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
['type' => 'compact_20260112']
]
]
);
}
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
messages = [{ role: "user", content: "Hello, Claude" }]
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [
{
type: "compact_20260112",
pause_after_compaction: true
}
]
}
)
if response.stop_reason == :compaction
messages << { role: "assistant", content: response.content }
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
end
puts response
```
Die API pausiert auch dann, wenn keine Zusammenfassung erstellt wird. Der `content` des `compaction`-Blocks ist dann `null`, behalte also die ursprünglichen Nachrichten bei, wenn du fortfährst. Wenn Schutzmaßnahmen die Zusammenfassung blockieren, ist `content` ebenfalls `null` und der Stop-Grund ist `refusal` statt `compaction`. [`stop_details`](https://platform.claude.com/docs/de/build-with-claude/handling-stop-reasons#refusal) gibt die Richtlinienkategorie an, falls es eine gibt. Fahre in beiden Fällen auf die gleiche Weise fort: Suche nach dem `compaction`-Block, statt `stop_reason` zu prüfen, wie es das [Beispiel, das aktuelle Nachrichten erhält](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold#examples), tut.
#### Ein Gesamt-Token-Budget durchsetzen
Wenn ein Modell an langen Aufgaben mit vielen Iterationen der Tool-Nutzung arbeitet, kann der gesamte Token-Verbrauch erheblich wachsen. Du kannst `pause_after_compaction` mit einem Komprimierungszähler kombinieren, um die kumulierte Nutzung abzuschätzen und die Aufgabe geordnet abzuschließen, sobald ein Budget erreicht ist.
Dieses Beispiel erscheint nur in den SDK-Sprachen: Sein Nutzen liegt in der Logik zur Budgetverfolgung rund um die Anfrage. Die reine Anfrage kombiniert den `trigger` aus [Trigger-Konfiguration](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold#trigger-configuration) mit `pause_after_compaction` aus [Pausieren nach der Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold#pausing-after-compaction).
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
TRIGGER_THRESHOLD = 100_000
TOTAL_TOKEN_BUDGET = 3_000_000
n_compactions = 0
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={
"edits": [
{
"type": "compact_20260112",
"trigger": {"type": "input_tokens", "value": TRIGGER_THRESHOLD},
"pause_after_compaction": True,
}
]
},
)
if response.stop_reason == "compaction":
n_compactions += 1
messages.append({"role": "assistant", "content": response.content})
# Schätze die insgesamt verbrauchten Tokens; fordere bei Budgetüberschreitung zum Abschluss auf
if n_compactions * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET:
messages.append(
{
"role": "user",
"content": "Please wrap up your current work and summarize the final state.",
}
)
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
const TRIGGER_THRESHOLD = 100_000;
const TOTAL_TOKEN_BUDGET = 3_000_000;
let compactionCount = 0;
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: { type: "input_tokens", value: TRIGGER_THRESHOLD },
pause_after_compaction: true
}
]
}
});
if (response.stop_reason === "compaction") {
compactionCount += 1;
messages.push({ role: "assistant", content: response.content });
// Schätze die insgesamt verbrauchten Token; fordere bei Budgetüberschreitung zum Abschluss auf
if (compactionCount * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET) {
messages.push({
role: "user",
content: "Please wrap up your current work and summarize the final state."
});
}
}
```
```csharp C#
AnthropicClient client = new();
List messages = [new BetaUserMessageParam { Content = "Hello, Claude" }];
const int TriggerThreshold = 100_000;
const int TotalTokenBudget = 3_000_000;
int compactionCount = 0;
var response = await client.Beta.Messages.Create(new()
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit
{
Trigger = new BetaInputTokensTrigger(TriggerThreshold),
PauseAfterCompaction = true
}]
}
});
if (response.StopReason == BetaStopReason.Compaction)
{
compactionCount += 1;
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
// Schätze die insgesamt verbrauchten Token; fordere bei Budgetüberschreitung zum Abschluss auf
if (compactionCount * TriggerThreshold >= TotalTokenBudget)
{
messages.Add(new BetaUserMessageParam
{
Content = "Please wrap up your current work and summarize the final state."
});
}
}
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}
const triggerThreshold = 100_000
const totalTokenBudget = 3_000_000
compactionCount := 0
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
Trigger: anthropic.BetaInputTokensTriggerParam{Value: triggerThreshold},
PauseAfterCompaction: anthropic.Bool(true),
}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
if response.StopReason == "compaction" {
compactionCount++
messages = append(messages, response.ToParam())
// Schätze die insgesamt verbrauchten Token; fordere bei Budgetüberschreitung zum Abschluss auf
if compactionCount*triggerThreshold >= totalTokenBudget {
messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Please wrap up your current work and summarize the final state.")))
}
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
import com.anthropic.models.beta.messages.BetaStopReason;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
long triggerThreshold = 100_000;
long totalTokenBudget = 3_000_000;
int compactionCount = 0;
List messages = new ArrayList<>();
messages.add(BetaMessageParam.ofUser("Hello, Claude"));
MessageCreateParams params = MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.messages(messages)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(triggerThreshold)
.build())
.pauseAfterCompaction(true)
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
if (response.stopReason().isPresent()
&& response.stopReason().get().equals(BetaStopReason.COMPACTION)) {
compactionCount += 1;
messages.add(response.toParam());
// Schätze die insgesamt verbrauchten Token; fordere bei Budgetüberschreitung zum Abschluss auf
if (compactionCount * triggerThreshold >= totalTokenBudget) {
messages.add(BetaMessageParam.ofUser(
"Please wrap up your current work and summarize the final state."));
}
}
System.out.println(response);
```
```php PHP
$client = new Client();
$triggerThreshold = 100_000;
$totalTokenBudget = 3_000_000;
$compactionCount = 0;
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
[
'type' => 'compact_20260112',
'trigger' => ['type' => 'input_tokens', 'value' => $triggerThreshold],
'pause_after_compaction' => true
]
]
]
);
if ($response->stopReason === 'compaction') {
$compactionCount += 1;
$messages[] = ['role' => 'assistant', 'content' => $response->content];
// Schätze die insgesamt verbrauchten Token; fordere bei Budgetüberschreitung zum Abschluss auf
if ($compactionCount * $triggerThreshold >= $totalTokenBudget) {
$messages[] = [
'role' => 'user',
'content' => 'Please wrap up your current work and summarize the final state.'
];
}
}
```
```ruby Ruby
client = Anthropic::Client.new
messages = [{ role: "user", content: "Hello, Claude" }]
TRIGGER_THRESHOLD = 100_000
TOTAL_TOKEN_BUDGET = 3_000_000
compaction_count = 0
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: { type: "input_tokens", value: TRIGGER_THRESHOLD },
pause_after_compaction: true
}
]
}
)
if response.stop_reason == :compaction
compaction_count += 1
messages << { role: "assistant", content: response.content }
# Schätze die insgesamt verbrauchten Tokens; fordere bei Budgetüberschreitung zum Abschluss auf
if compaction_count * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET
messages << {
role: "user",
content: "Please wrap up your current work and summarize the final state."
}
end
end
```
## Arbeiten mit Komprimierungsblöcken
Wenn die Komprimierung ausgelöst wird, gibt die API am Anfang der Assistant-Antwort einen `compaction`-Block zurück.
Eine lang laufende Unterhaltung kann zu mehreren Komprimierungen führen. Der letzte Komprimierungsblock spiegelt den endgültigen Zustand des Prompts wider und ersetzt den Inhalt davor durch die erstellte Zusammenfassung.
```json Output
{
"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..."
}
]
}
```
### Komprimierungsblöcke zurückgeben
Du musst den `compaction`-Block bei nachfolgenden Anfragen an die API zurückgeben, um die Unterhaltung mit dem verkürzten Prompt fortzusetzen. Am einfachsten ist es, den gesamten Antwortinhalt an deine Nachrichten anzuhängen:
Dieser Workflow erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das [Claude SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen.
Dieser Workflow erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das [Claude SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen.
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
# Nach Erhalt einer Antwort mit einem Compaction-Block
messages.append({"role": "assistant", "content": response.content})
# Setze die Unterhaltung fort
messages.append({"role": "user", "content": "Now add error handling"})
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
// Nach Erhalt einer Antwort mit einem Compaction-Block
messages.push({
role: "assistant",
content: response.content
});
// Setze die Unterhaltung fort
messages.push({ role: "user", content: "Now add error handling" });
const nextResponse = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
```
```csharp C#
AnthropicClient client = new();
var messages = new List
{
new BetaUserMessageParam { Content = "Help me build a web scraper" }
};
var response = await client.Beta.Messages.Create(new()
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
});
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
messages.Add(new BetaUserMessageParam { Content = "Now add error handling" });
var nextResponse = await client.Beta.Messages.Create(new()
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
});
Console.WriteLine(nextResponse);
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Help me build a web scraper")),
}
compactEdit := anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
}
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: compactEdit,
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
messages = append(messages, response.ToParam())
messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Now add error handling")))
nextResponse, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: compactEdit,
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(nextResponse)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
// Erste Anfrage
BetaMessage response = client.beta().messages().create(
MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Help me build a web scraper")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build());
// Nachdem du eine Antwort mit einem Compaction-Block erhalten hast, hänge den vollständigen
// Inhalt (einschließlich Compaction-Blöcken) an und setze die Unterhaltung fort
BetaMessage nextResponse = client.beta().messages().create(
MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addUserMessage("Help me build a web scraper")
.addMessage(response)
.addUserMessage("Now add error handling")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build());
System.out.println(nextResponse);
```
```php PHP
$client = new Client();
$messages = [
['role' => 'user', 'content' => 'Help me build a web scraper']
];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [['type' => 'compact_20260112']]
]
);
$messages[] = ['role' => 'assistant', 'content' => $response->content];
$messages[] = ['role' => 'user', 'content' => 'Now add error handling'];
$nextResponse = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [['type' => 'compact_20260112']]
]
);
echo json_encode($nextResponse, JSON_PRETTY_PRINT), PHP_EOL;
```
```ruby Ruby
client = Anthropic::Client.new
messages = [
{ role: "user", content: "Help me build a web scraper" }
]
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
messages << { role: "assistant", content: response.content }
messages << { role: "user", content: "Now add error handling" }
next_response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
puts next_response.content
```
Verwende in Python `client.beta.messages`, wie es die Beispiele auf dieser Seite tun. Wenn du `client.messages` aufrufst und Blöcke selbst serialisierst, fügt ein einfaches `model_dump()` dem `compaction`-Block `text: null` und `citations: null` hinzu. Die API lehnt die Anfrage dann mit einem 400-Fehler ab (`Extra inputs are not permitted`). Verwende stattdessen `to_dict()` oder `model_dump(exclude_none=True)`. [Ab der Zusammenfassung fortfahren](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand#continue-from-the-summary) gibt denselben Hinweis für die Komprimierung auf Anfrage.
Wenn die API einen `compaction`-Block empfängt, werden alle Inhaltsblöcke davor ignoriert. Du kannst entweder:
* Die ursprünglichen Nachrichten in deiner Liste behalten und die API das Entfernen des komprimierten Inhalts übernehmen lassen
* Die komprimierten Nachrichten manuell verwerfen und nur den Komprimierungsblock und alles danach einschließen
Wenn keine Zusammenfassung erstellt wird, ist der `content` des Blocks `null` und die API ignoriert den Block. Es wird nichts komprimiert, behalte also die ursprünglichen Nachrichten bei.
Bei Claude 5.1 und neueren Modellen werden Thinking-Blöcke von vor einem `compaction`-Block nicht übernommen, sodass die Zusammenfassung alles ist, was das Modell von dieser früheren Arbeit hat. Wenn du eigene `instructions` schreibst, sag dem Modell, was die Zusammenfassung beibehalten muss; siehe [Dem Modell sagen, was es in Compaction-Zusammenfassungen bewahren soll](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#tell-the-model-what-to-preserve-in-compaction-summaries).
### Streaming
Der Komprimierungsblock wird anders gestreamt als Textblöcke. Du erhältst ein `content_block_start`-Event, gefolgt von einem einzelnen `content_block_delta` mit dem vollständigen Inhalt der Zusammenfassung (kein zwischenzeitliches Streaming) und anschließend ein `content_block_stop`-Event.
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"stream": true,
"messages": [
{
"role": "user",
"content": "Hello, Claude"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}'
```
```bash CLI
ant beta:messages create \
--stream \
--beta compact-2026-01-12 \
--format jsonl <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
with client.beta.messages.stream(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
) as stream:
for event in stream:
match event.type:
case "content_block_start":
block = event.content_block
match block.type:
case "compaction":
print("Compaction started...")
case "text":
print("Text response started...")
case "content_block_delta":
delta = event.delta
match delta.type:
case "compaction_delta":
print(f"Compaction complete: {len(delta.content or '')} chars")
case "text_delta":
print(delta.text, end="", flush=True)
# Hole die endgültige akkumulierte Nachricht
message = stream.get_final_message()
messages.append({"role": "assistant", "content": message.content})
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
const stream = await client.beta.messages.stream({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
for await (const event of stream) {
switch (event.type) {
case "content_block_start":
switch (event.content_block.type) {
case "compaction":
console.log("Compaction started...");
break;
case "text":
console.log("Text response started...");
break;
}
break;
case "content_block_delta":
switch (event.delta.type) {
case "compaction_delta":
console.log(`Compaction complete: ${event.delta.content?.length ?? 0} chars`);
break;
case "text_delta":
process.stdout.write(event.delta.text);
break;
}
break;
}
}
// Hole die finale, akkumulierte Nachricht
const message = await stream.finalMessage();
messages.push({
role: "assistant",
content: message.content
});
```
```csharp C#
var client = new AnthropicClient();
List messages = [new BetaUserMessageParam { Content = "Hello" }];
var parameters = new MessageCreateParams
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
};
await foreach (var streamEvent in client.Beta.Messages.CreateStreaming(parameters))
{
if (streamEvent.TryPickContentBlockStart(out var startEvent))
{
if (startEvent.ContentBlock.TryPickBetaCompaction(out _))
{
Console.WriteLine("Compaction started...");
}
else if (startEvent.ContentBlock.TryPickBetaText(out _))
{
Console.WriteLine("Text response started...");
}
}
else if (streamEvent.TryPickContentBlockDelta(out var deltaEvent))
{
if (deltaEvent.Delta.TryPickCompaction(out var compactionDelta))
{
Console.WriteLine($"Compaction complete: {compactionDelta.Content?.Length ?? 0} chars");
}
else if (deltaEvent.Delta.TryPickText(out var textDelta))
{
Console.Write(textDelta.Text);
}
}
}
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}
stream := client.Beta.Messages.NewStreaming(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
for stream.Next() {
event := stream.Current()
switch eventVariant := event.AsAny().(type) {
case anthropic.BetaRawContentBlockStartEvent:
switch eventVariant.ContentBlock.AsAny().(type) {
case anthropic.BetaCompactionBlock:
fmt.Println("Compaction started...")
case anthropic.BetaTextBlock:
fmt.Println("Text response started...")
}
case anthropic.BetaRawContentBlockDeltaEvent:
switch deltaVariant := eventVariant.Delta.AsAny().(type) {
case anthropic.BetaCompactionContentBlockDelta:
fmt.Printf("Compaction complete: %d chars\n", len(deltaVariant.Content))
case anthropic.BetaTextDelta:
fmt.Print(deltaVariant.Text)
}
}
}
if err := stream.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addBeta("compact-2026-01-12")
.addUserMessage("Hello, Claude")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build();
try (var streamResponse = client.beta().messages().createStreaming(params)) {
streamResponse.stream().forEach(event -> {
event.contentBlockStart().ifPresent(startEvent -> {
startEvent.contentBlock().compaction().ifPresent(compactionBlock ->
System.out.println("Compaction started...")
);
startEvent.contentBlock().text().ifPresent(textBlock ->
System.out.println("Text response started...")
);
});
event.contentBlockDelta().ifPresent(deltaEvent -> {
deltaEvent.delta().compaction().ifPresent(compactionDelta ->
System.out.println("Compaction complete: " + compactionDelta.content().map(String::length).orElse(0) + " chars")
);
deltaEvent.delta().text().ifPresent(textDelta ->
System.out.print(textDelta.text())
);
});
});
}
```
```php PHP
use Anthropic\Beta\Messages\BetaCompactionBlock;
use Anthropic\Beta\Messages\BetaCompactionContentBlockDelta;
use Anthropic\Beta\Messages\BetaRawContentBlockDeltaEvent;
use Anthropic\Beta\Messages\BetaRawContentBlockStartEvent;
use Anthropic\Beta\Messages\BetaTextBlock;
use Anthropic\Beta\Messages\BetaTextDelta;
use Anthropic\Messages\Model;
$client = new Client();
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];
$stream = $client->beta->messages->createStream(
maxTokens: 4096,
messages: $messages,
model: Model::CLAUDE_OPUS_5_5,
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
['type' => 'compact_20260112']
]
]
);
foreach ($stream as $event) {
switch (true) {
case $event instanceof BetaRawContentBlockStartEvent:
switch (true) {
case $event->contentBlock instanceof BetaCompactionBlock:
echo "Compaction started...\n";
break;
case $event->contentBlock instanceof BetaTextBlock:
echo "Text response started...\n";
break;
}
break;
case $event instanceof BetaRawContentBlockDeltaEvent:
switch (true) {
case $event->delta instanceof BetaCompactionContentBlockDelta:
echo 'Compaction complete: ' . strlen($event->delta->content ?? '') . " chars\n";
break;
case $event->delta instanceof BetaTextDelta:
echo $event->delta->text;
break;
}
break;
}
}
```
```ruby Ruby
client = Anthropic::Client.new
messages = [{ role: "user", content: "Hello, Claude" }]
stream = client.beta.messages.stream(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
stream.each do |event|
case event
when Anthropic::Models::BetaRawContentBlockStartEvent
case event.content_block
when Anthropic::Models::BetaCompactionBlock
puts "Compaction started..."
when Anthropic::Models::BetaTextBlock
puts "Text response started..."
end
when Anthropic::Models::BetaRawContentBlockDeltaEvent
delta = event.delta
case delta
when Anthropic::Models::BetaCompactionContentBlockDelta
puts "Compaction complete: #{(delta.content || "").length} chars"
when Anthropic::Models::BetaTextDelta
print delta.text
end
end
end
```
### Prompt-Caching
Die Komprimierung funktioniert gut mit [„prompt caching“ (Prompt-Caching)](https://platform.claude.com/docs/de/build-with-claude/prompt-caching). Du kannst einen `cache_control`-Breakpoint auf Komprimierungsblöcke setzen, um den zusammengefassten Inhalt zu cachen.
```json
{
"role": "assistant",
"content": [
{
"type": "compaction",
"content": "[summary text]",
"cache_control": { "type": "ephemeral" }
},
{
"type": "text",
"text": "Based on our conversation..."
}
]
}
```
#### Cache-Treffer mit System-Prompts maximieren
Wenn eine Komprimierung stattfindet, wird die Zusammenfassung zu neuem Inhalt, der in den Cache geschrieben werden muss. Ohne zusätzliche Cache-Breakpoints würde dies auch jeden gecachten „system prompt“ (System-Prompt) ungültig machen, sodass er zusammen mit der Komprimierungszusammenfassung erneut gecacht werden müsste.
Um die Cache-Trefferquote zu maximieren, füge am Ende deines System-Prompts einen `cache_control`-Breakpoint hinzu. Dadurch bleibt der System-Prompt getrennt von der Unterhaltung gecacht, sodass bei einer Komprimierung:
* Der Cache des System-Prompts gültig bleibt und aus dem Cache gelesen wird
* Nur die Komprimierungszusammenfassung als neuer Cache-Eintrag geschrieben werden muss
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"system": [
{
"type": "text",
"text": "You are a helpful coding assistant...",
"cache_control": {
"type": "ephemeral"
}
}
],
"messages": [
{
"role": "user",
"content": "Hello, Claude"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}'
```
```bash CLI
ant beta:messages create --beta compact-2026-01-12 <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
system:
- type: text
text: You are a helpful coding assistant...
cache_control:
type: ephemeral
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
system=[
{
"type": "text",
"text": "You are a helpful coding assistant...",
"cache_control": {
"type": "ephemeral"
}, # Cache the system prompt separately
}
],
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Hello, Claude" }
];
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
system: [
{
type: "text",
text: "You are a helpful coding assistant...",
cache_control: { type: "ephemeral" } // Cache the system prompt separately
}
],
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
```
```csharp C#
var client = new AnthropicClient();
var parameters = new MessageCreateParams
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
System = new List
{
new()
{
Text = "You are a helpful coding assistant...",
CacheControl = new BetaCacheControlEphemeral()
}
},
Messages = [new BetaUserMessageParam { Content = "Hello, Claude" }],
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
};
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,
System: []anthropic.BetaTextBlockParam{
{
Text: "You are a helpful coding assistant...",
CacheControl: anthropic.NewBetaCacheControlEphemeralParam(),
},
},
Messages: []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))},
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaCacheControlEphemeral;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.addBeta("compact-2026-01-12")
.systemOfBetaTextBlockParams(List.of(
BetaTextBlockParam.builder()
.text("You are a helpful coding assistant...")
.cacheControl(BetaCacheControlEphemeral.builder().build())
.build()
))
.addUserMessage("Hello, Claude")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
System.out.println(response);
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [['role' => 'user', 'content' => 'Hello, Claude']],
model: Model::CLAUDE_OPUS_5_5,
betas: ['compact-2026-01-12'],
system: [
[
'type' => 'text',
'text' => 'You are a helpful coding assistant...',
'cache_control' => [
'type' => 'ephemeral'
]
]
],
contextManagement: [
'edits' => [
['type' => 'compact_20260112']
]
]
);
echo json_encode($response, JSON_PRETTY_PRINT), PHP_EOL;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
system: [
{
type: "text",
text: "You are a helpful coding assistant...",
cache_control: {
type: "ephemeral"
}
}
],
messages: [{ role: "user", content: "Hello, Claude" }],
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
puts response
```
So bleiben lange System-Prompts über mehrere Komprimierungsereignisse hinweg während einer Unterhaltung gecacht.
## Nutzung verstehen
Die Komprimierung erfordert einen zusätzlichen Sampling-Schritt, der zu den „rate limits“ (Ratenlimits) und zur Abrechnung beiträgt. Die API gibt in der Antwort detaillierte Nutzungsinformationen zurück:
```json Output
{
"usage": {
"input_tokens": 23000,
"output_tokens": 1000,
"iterations": [
{
"type": "compaction",
"input_tokens": 180000,
"output_tokens": 3500
},
{
"type": "message",
"input_tokens": 23000,
"output_tokens": 1000
}
]
}
}
```
Das Array `iterations` zeigt die Nutzung für jede Sampling-Iteration. Wenn eine Komprimierung stattfindet, siehst du eine `compaction`-Iteration, gefolgt von der Haupt-Iteration `message`. Die Top-Level-Werte `input_tokens` und `output_tokens` stimmen in diesem Beispiel genau mit der `message`-Iteration überein, da es nur eine Iteration ohne Komprimierung gibt. Die Token-Zahlen der letzten Iteration spiegeln die effektive Kontextgröße nach der Komprimierung wider.
Die Top-Level-Werte `input_tokens` und `output_tokens` enthalten nicht die Nutzung der Komprimierungsiteration. Sie spiegeln die Summe aller Iterationen ohne Komprimierung wider. Um die insgesamt verbrauchten und abgerechneten Token für eine Anfrage zu berechnen, summiere über alle Einträge im Array `usage.iterations`.
Wenn du dich bisher für Kostenverfolgung oder Audits auf `usage.input_tokens` und `usage.output_tokens` verlassen hast, musst du deine Tracking-Logik so anpassen, dass sie bei aktivierter Komprimierung über `usage.iterations` aggregiert. Bei aktivierter Komprimierungs-Beta enthält jede Antwort `usage.iterations`, auch wenn keine Komprimierung stattgefunden hat. Ein `compaction`-Eintrag erscheint nur, wenn während der Anfrage eine neue Komprimierung ausgelöst wird. Das erneute Anwenden eines vorherigen `compaction`-Blocks verursacht keine zusätzlichen Komprimierungskosten, und die Top-Level-Nutzungsfelder bleiben in diesem Fall korrekt.
## Kombination mit anderen Funktionen
### Server-Tools
Bei der Verwendung von Server-Tools (wie der Websuche) wird der Komprimierungs-Trigger zu Beginn jeder Sampling-Iteration geprüft. Je nach deinem Trigger-Schwellenwert und der Menge der erzeugten Ausgabe kann die Komprimierung innerhalb einer einzelnen Anfrage mehrmals stattfinden.
### Token-Zählung
Der Endpunkt zur Token-Zählung (`/v1/messages/count_tokens`) wendet vorhandene `compaction`-Blöcke in deinem Prompt an, löst aber keine neuen Komprimierungen aus. Verwende ihn, um deine effektive Token-Anzahl nach vorherigen Komprimierungen zu prüfen:
```bash cURL
curl https://api.anthropic.com/v1/messages/count_tokens \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-H "anthropic-beta: compact-2026-01-12" \
-H "content-type: application/json" \
-d '{
"model": "claude-opus-5-5",
"messages": [
{
"role": "user",
"content": "Hello, Claude"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}'
```
```bash CLI
ant beta:messages count-tokens --beta compact-2026-01-12 <<'YAML'
model: claude-opus-5-5
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
YAML
```
```python Python
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Hello, Claude"}]
count_response = client.beta.messages.count_tokens(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
print(f"Current tokens: {count_response.input_tokens}")
print(f"Original tokens: {count_response.context_management.original_input_tokens}")
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "user", content: "Summarize the key points of our conversation so far." }
];
const countResponse = await client.beta.messages.countTokens({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
console.log(`Current tokens: ${countResponse.input_tokens}`);
console.log(`Original tokens: ${countResponse.context_management!.original_input_tokens}`);
```
```csharp C#
AnthropicClient client = new();
List messages = [new BetaUserMessageParam { Content = "Hello" }];
var countParams = new MessageCountTokensParams
{
Model = Model.ClaudeOpus5_5,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
},
Betas = ["compact-2026-01-12"]
};
var countResponse = await client.Beta.Messages.CountTokens(countParams);
Console.WriteLine($"Current tokens: {countResponse.InputTokens}");
Console.WriteLine($"Original tokens: {countResponse.ContextManagement?.OriginalInputTokens}");
```
```go Go
client := anthropic.NewClient()
messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}
countResponse, err := client.Beta.Messages.CountTokens(context.TODO(), anthropic.BetaMessageCountTokensParams{
Model: anthropic.ModelClaudeOpus5_5,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Current tokens: %d\n", countResponse.InputTokens)
fmt.Printf("Original tokens: %d\n", countResponse.ContextManagement.OriginalInputTokens)
```
```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.BetaCompact20260112Edit;
// ...
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCountTokensParams params = MessageCountTokensParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.addUserMessage("Hello, Claude")
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.addBeta("compact-2026-01-12")
.build();
BetaMessageTokensCount countResponse = client.beta().messages().countTokens(params);
System.out.println("Current tokens: " + countResponse.inputTokens());
System.out.println("Original tokens: " + countResponse.contextManagement().get().originalInputTokens());
```
```php PHP
$client = new Client();
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];
$countResponse = $client->beta->messages->countTokens(
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
['type' => 'compact_20260112']
]
]
);
echo 'Current tokens: ' . $countResponse->inputTokens . "\n";
echo 'Original tokens: ' . $countResponse->contextManagement->originalInputTokens . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
messages = [{ role: "user", content: "Hello, Claude" }]
count_response = client.beta.messages.count_tokens(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
puts "Current tokens: #{count_response.input_tokens}"
puts "Original tokens: #{count_response.context_management.original_input_tokens}"
```
## Beispiele
Hier ist ein vollständiges Beispiel einer lang laufenden Unterhaltung mit Komprimierung:
Dieser Workflow erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das [Claude SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen.
Dieser Workflow erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das [Claude SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen.
```python Python
client = anthropic.Anthropic()
messages: list[dict] = []
def chat(user_message: str) -> str:
messages.append({"role": "user", "content": user_message})
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={
"edits": [
{
"type": "compact_20260112",
"trigger": {"type": "input_tokens", "value": 100000},
}
]
},
)
# Hänge die Antwort an (Compaction-Blöcke werden automatisch einbezogen)
messages.append({"role": "assistant", "content": response.content})
# Gib den Textinhalt zurück
return next((block.text for block in response.content if block.type == "text"), "")
# Führe eine lange Unterhaltung
print(chat("Briefly, help me build a Python web scraper"))
print(chat("Briefly, add support for JavaScript-rendered pages"))
print(chat("Briefly, add rate limiting and error handling"))
# Rufe chat() so lange auf, wie die Unterhaltung es erfordert
```
```typescript TypeScript
const client = new Anthropic();
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [];
async function chat(userMessage: string): Promise {
messages.push({ role: "user", content: userMessage });
const response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: { type: "input_tokens", value: 100000 }
}
]
}
});
// Hänge die Antwort an (Compaction-Blöcke werden automatisch einbezogen)
messages.push({ role: "assistant", content: response.content });
// Gib den Textinhalt zurück
const textBlock = response.content.find((block) => block.type === "text");
return textBlock?.text ?? "";
}
// Führe eine lange Unterhaltung
console.log(await chat("Briefly, help me build a Python web scraper"));
console.log(await chat("Briefly, add support for JavaScript-rendered pages"));
console.log(await chat("Briefly, add rate limiting and error handling"));
// Rufe chat() so lange auf, wie die Unterhaltung es erfordert
```
```csharp C#
AnthropicClient client = new();
List messages = new();
Console.WriteLine(await Chat(client, messages, "Briefly, help me build a Python web scraper"));
Console.WriteLine(await Chat(client, messages, "Briefly, add support for JavaScript-rendered pages"));
Console.WriteLine(await Chat(client, messages, "Briefly, add rate limiting and error handling"));
static async Task Chat(AnthropicClient client, List messages, string userMessage)
{
messages.Add(new BetaUserMessageParam { Content = userMessage });
var parameters = new MessageCreateParams
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit
{
Trigger = new BetaInputTokensTrigger(100000)
}]
}
};
var response = await client.Beta.Messages.Create(parameters);
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
return response.Content
.Select(block => block.Value)
.OfType()
.Select(textBlock => textBlock.Text)
.FirstOrDefault() ?? "";
}
```
```go Go
package main
import (
"context"
"fmt"
"log"
"github.com/anthropics/anthropic-sdk-go/v2"
)
var (
client = anthropic.NewClient()
messages []anthropic.BetaMessageParam
)
func chat(userMessage string) string {
messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(userMessage)))
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
Trigger: anthropic.BetaInputTokensTriggerParam{Value: 100000},
}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
messages = append(messages, response.ToParam())
for _, block := range response.Content {
if variant, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
return variant.Text
}
}
return ""
}
func main() {
fmt.Println(chat("Briefly, help me build a Python web scraper"))
fmt.Println(chat("Briefly, add support for JavaScript-rendered pages"))
fmt.Println(chat("Briefly, add rate limiting and error handling"))
}
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
// ...
private static final AnthropicClient client = AnthropicOkHttpClient.fromEnv();
private static final List messages = new ArrayList<>();
public static void main(String[] args) {
System.out.println(chat("Briefly, help me build a Python web scraper"));
System.out.println(chat("Briefly, add support for JavaScript-rendered pages"));
System.out.println(chat("Briefly, add rate limiting and error handling"));
}
private static String chat(String userMessage) {
messages.add(BetaMessageParam.ofUser(userMessage));
MessageCreateParams params = MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.messages(messages)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(100000L)
.build())
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
// Antwort anhängen (Compaction-Blöcke werden automatisch einbezogen)
messages.add(response.toParam());
return response.content().stream()
.filter(block -> block.text().isPresent())
.map(block -> block.text().get().text())
.findFirst()
.orElse("");
}
```
```php PHP
$client = new Client();
$messages = [];
function chat($client, &$messages, $userMessage)
{
$messages[] = ['role' => 'user', 'content' => $userMessage];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
[
'type' => 'compact_20260112',
'trigger' => ['type' => 'input_tokens', 'value' => 100000]
]
]
]
);
$messages[] = ['role' => 'assistant', 'content' => $response->content];
foreach ($response->content as $block) {
if ($block->type === 'text') {
return $block->text;
}
}
return '';
}
echo chat($client, $messages, 'Briefly, help me build a Python web scraper') . "\n";
echo chat($client, $messages, 'Briefly, add support for JavaScript-rendered pages') . "\n";
echo chat($client, $messages, 'Briefly, add rate limiting and error handling') . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
messages = []
def chat(client, messages, user_message)
messages << { role: "user", content: user_message }
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: { type: "input_tokens", value: 100000 }
}
]
}
)
messages << { role: "assistant", content: response.content }
response.content.find { |block| block.type == :text }&.text || ""
end
puts chat(client, messages, "Briefly, help me build a Python web scraper")
puts chat(client, messages, "Briefly, add support for JavaScript-rendered pages")
puts chat(client, messages, "Briefly, add rate limiting and error handling")
```
Bei Claude 5.1 und neueren Modellen bestehen Thinking-Blöcke in jedem Assistenten-Turn, den du nach dem Compaction-Block erneut einfügst, die [Präfixprüfung](https://platform.claude.com/docs/de/build-with-claude/thinking#preserved-in-conversation) nicht, da sie erzeugt wurden, als der vollständige Verlauf vorhanden war. Entferne die `thinking`- und `redacted_thinking`-Blöcke aus diesen Turns. Alternativ kannst du `thinking.block_binding.prefix_mismatch_behavior: "drop_block"` zusammen mit dem `thinking-binding-controls-2026-08-01` [Beta-Header](https://platform.claude.com/docs/de/api/beta-headers) senden. Die beibehaltenen Text- und Tool-Blöcke können unverändert bleiben. Wenn du die API alles zusammenfassen lässt, ohne frühere Turns erneut einzufügen, vermeidest du dieses Problem. Bei Claude Sonnet 5.5 und Claude Haiku 5.5 funktioniert `block_binding` nur mit `thinking: {"type": "adaptive"}`. Bei jeder anderen Nachdenken-Einstellung auf diesen Modellen musst du die Blöcke entfernen.
Hier ist ein Beispiel, das `pause_after_compaction` verwendet, um den vorherigen Austausch und die aktuelle Nutzernachricht (insgesamt drei Nachrichten) zu erhalten, statt sie zusammenzufassen. Es lässt deren Text- und Tool-Blöcke unverändert, entfernt die `thinking`- und `redacted_thinking`-Blöcke aus dem erhaltenen Assistant-Turn und verwirft diesen Turn, wenn sonst nichts übrig bleibt:
Dieser Workflow erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das [Claude SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen.
Dieser Workflow erfordert mehr Logik als ein einzelner Shell-Befehl. Verwende das [Claude SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview), um ihn auszuführen.
```python Python
from typing import Any
client = anthropic.Anthropic()
messages: list[dict[str, Any]] = []
def chat(user_message: str) -> str:
messages.append({"role": "user", "content": user_message})
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={
"edits": [
{
"type": "compact_20260112",
"trigger": {"type": "input_tokens", "value": 100000},
"pause_after_compaction": True,
}
]
},
)
# Suche nach dem Komprimierungsblock, nicht nach dem Stop-Grund:
# stop_reason ist "refusal", nicht "compaction", wenn die Zusammenfassung blockiert wurde
compaction_block = next(
(block for block in response.content if block.type == "compaction"), None
)
# Ersetze den Verlauf nur, wenn eine Zusammenfassung erstellt wurde
if compaction_block is not None and compaction_block.content is not None:
# Behalte den vorherigen Austausch + aktuelle Nutzernachricht bei (3 Nachrichten)
# indem du sie nach dem Komprimierungsblock einfügst, ohne Thinking-
# Blöcke; ein Assistant-Turn ohne Inhalt wird verworfen
preserved_messages = [
{
**message,
"content": [
block
for block in message["content"]
if block.type not in ("thinking", "redacted_thinking")
],
}
if message["role"] == "assistant"
else message
for message in messages[-3:]
]
preserved_messages = [m for m in preserved_messages if m["content"]]
# Erstelle neue Nachrichtenliste: Komprimierung + beibehaltene Nachrichten
new_assistant_content = [compaction_block]
messages_after_compaction = [
{"role": "assistant", "content": new_assistant_content}
] + preserved_messages
# Aktualisiere die Nachrichtenliste entsprechend der Komprimierung
messages.clear()
messages.extend(messages_after_compaction)
if compaction_block is not None:
# Setze die Anfrage fort, mit vollem Verlauf, falls keine Zusammenfassung existiert
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages,
context_management={"edits": [{"type": "compact_20260112"}]},
)
# Hänge die finale Antwort an
messages.append({"role": "assistant", "content": response.content})
# Gib den Textinhalt zurück
return next((block.text for block in response.content if block.type == "text"), "")
# Führe eine lange Konversation
print(chat("Briefly, help me build a Python web scraper"))
print(chat("Briefly, add support for JavaScript-rendered pages"))
print(chat("Briefly, add rate limiting and error handling"))
# Rufe chat() so lange auf, wie die Konversation es erfordert
```
```typescript TypeScript
const client = new Anthropic();
let messages: Anthropic.Beta.Messages.BetaMessageParam[] = [];
async function chat(userMessage: string): Promise {
messages.push({ role: "user", content: userMessage });
let response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: { type: "input_tokens", value: 100000 },
pause_after_compaction: true
}
]
}
});
// Suche nach dem Compaction-Block, nicht nach dem Stop-Grund:
// stop_reason ist "refusal", nicht "compaction", wenn die Zusammenfassung blockiert wurde
const compactionBlock = response.content.find((block) => block.type === "compaction");
// Ersetze den Verlauf nur, wenn eine Zusammenfassung erstellt wurde
if (compactionBlock && compactionBlock.content !== null) {
// Behalte den vorherigen Austausch + aktuelle Nutzernachricht (3 Nachrichten)
// indem du sie nach dem Compaction-Block einfügst, ohne Thinking-
// Blöcke; ein Assistant-Turn ohne verbleibenden Inhalt wird verworfen
const preservedMessages = messages
.slice(-3)
.map((message) =>
message.role === "assistant" && Array.isArray(message.content)
? {
...message,
content: message.content.filter(
(block) => block.type !== "thinking" && block.type !== "redacted_thinking"
)
}
: message
)
.filter((message) => message.role !== "assistant" || message.content.length > 0);
// Erstelle neue Nachrichtenliste: Compaction + beibehaltene Nachrichten
const messagesAfterCompaction: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "assistant", content: [compactionBlock] },
...preservedMessages
];
// Aktualisiere die Nachrichtenliste entsprechend der Compaction
messages = messagesAfterCompaction;
}
if (compactionBlock) {
// Setze die Anfrage fort, mit vollem Verlauf, falls keine Zusammenfassung existiert
response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
}
// Hänge die finale Antwort an
messages.push({ role: "assistant", content: response.content });
// Gib den Textinhalt zurück
const textBlock = response.content.find((block) => block.type === "text");
return textBlock?.text ?? "";
}
// Führe eine lange Konversation
console.log(await chat("Briefly, help me build a Python web scraper"));
console.log(await chat("Briefly, add support for JavaScript-rendered pages"));
console.log(await chat("Briefly, add rate limiting and error handling"));
// Rufe chat() so lange auf, wie die Konversation es erfordert
```
```csharp C#
AnthropicClient client = new();
List messages = new();
Console.WriteLine(await Chat("Briefly, help me build a Python web scraper"));
Console.WriteLine(await Chat("Briefly, add support for JavaScript-rendered pages"));
Console.WriteLine(await Chat("Briefly, add rate limiting and error handling"));
async Task Chat(string userMessage)
{
messages.Add(new BetaUserMessageParam { Content = userMessage });
var response = await client.Beta.Messages.Create(new()
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit
{
Trigger = new BetaInputTokensTrigger(100000),
PauseAfterCompaction = true
}]
}
});
// Suche nach dem Komprimierungsblock, nicht nach dem Stop-Grund:
// StopReason ist Refusal, nicht Compaction, wenn die Zusammenfassung blockiert wurde
var compactionBlock = response.Content.FirstOrDefault(block => block.Value is BetaCompactionBlock);
// Ersetze den Verlauf nur, wenn eine Zusammenfassung erstellt wurde
if (compactionBlock?.Value is BetaCompactionBlock { Content: not null })
{
// Behalte den vorherigen Austausch + aktuelle Nutzernachricht (3 Nachrichten) bei,
// ohne Thinking-Blöcke; ein leer gebliebener Assistant-Turn wird verworfen
var preserved = new List();
foreach (var message in messages.Skip(Math.Max(0, messages.Count - 3)))
{
if (!message.TryPickAssistant(out var assistant)
|| !assistant.Content.TryPickBetaContentBlockParams(out var blocks))
{
preserved.Add(message);
continue;
}
var kept = blocks
.Where(block => block.Type.Raw() is not ("thinking" or "redacted_thinking"))
.ToList();
if (kept.Count > 0)
{
preserved.Add(assistant with { Content = kept });
}
}
var messagesAfterCompaction = new List
{
new BetaAssistantMessageParam
{
Content = new List { new BetaContentBlockParam(compactionBlock.Json) }
}
};
messagesAfterCompaction.AddRange(preserved);
messages = messagesAfterCompaction;
}
if (compactionBlock is not null)
{
// Setze die Anfrage fort, mit vollem Verlauf, falls keine Zusammenfassung existiert
response = await client.Beta.Messages.Create(new()
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messages,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
});
}
messages.Add(new BetaAssistantMessageParam
{
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
return response.Content
.Select(block => block.Value)
.OfType()
.Select(textBlock => textBlock.Text)
.FirstOrDefault() ?? "";
}
```
```go Go
package main
import (
"context"
"fmt"
"log"
"slices"
"github.com/anthropics/anthropic-sdk-go/v2"
)
var (
client = anthropic.NewClient()
messages []anthropic.BetaMessageParam
)
func chat(userMessage string) string {
messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(userMessage)))
compactEdit := anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{
Trigger: anthropic.BetaInputTokensTriggerParam{Value: 100000},
PauseAfterCompaction: anthropic.Bool(true),
}},
},
}
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: compactEdit,
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
// Suche nach dem Komprimierungsblock, nicht nach dem Stop-Grund:
// StopReason ist "refusal", nicht "compaction", wenn die Zusammenfassung blockiert wurde
compactionIndex := slices.IndexFunc(response.Content, func(block anthropic.BetaContentBlockUnion) bool {
return block.Type == "compaction"
})
// Ersetze den Verlauf nur, wenn eine Zusammenfassung erstellt wurde (content ist nicht null)
if compactionIndex >= 0 && response.Content[compactionIndex].JSON.Content.Valid() {
compactionParam := response.Content[compactionIndex].ToParam()
// Behalte den vorherigen Austausch + aktuelle User-Nachricht (3 Nachrichten),
// ohne Thinking-Blöcke; ein leer gebliebener Assistant-Turn wird verworfen
var preserved []anthropic.BetaMessageParam
for _, message := range messages[max(0, len(messages)-3):] {
if message.OfAssistant == nil {
preserved = append(preserved, message)
continue
}
var content []anthropic.BetaContentBlockParamUnion
for _, block := range message.OfAssistant.Content {
if block.OfThinking == nil && block.OfRedactedThinking == nil {
content = append(content, block)
}
}
if len(content) == 0 {
continue
}
preserved = append(preserved, anthropic.BetaMessageParam{OfAssistant: &anthropic.BetaAssistantMessageParam{Content: content}})
}
messagesAfterCompaction := []anthropic.BetaMessageParam{
{OfAssistant: &anthropic.BetaAssistantMessageParam{Content: []anthropic.BetaContentBlockParamUnion{compactionParam}}},
}
messagesAfterCompaction = append(messagesAfterCompaction, preserved...)
messages = messagesAfterCompaction
}
if compactionIndex >= 0 {
// Setze die Anfrage fort, mit vollem Verlauf, falls keine Zusammenfassung existiert
response, err = client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messages,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
}
messages = append(messages, response.ToParam())
for _, block := range response.Content {
if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
return textBlock.Text
}
}
return ""
}
func main() {
fmt.Println(chat("Briefly, help me build a Python web scraper"))
fmt.Println(chat("Briefly, add support for JavaScript-rendered pages"))
fmt.Println(chat("Briefly, add rate limiting and error handling"))
}
```
```java Java
import com.anthropic.models.beta.messages.BetaContextManagementConfig;
import com.anthropic.models.beta.messages.BetaCompact20260112Edit;
import com.anthropic.models.beta.messages.BetaInputTokensTrigger;
// ...
private static final AnthropicClient client = AnthropicOkHttpClient.fromEnv();
private static final List messages = new ArrayList<>();
public static String chat(String userMessage) {
messages.add(BetaMessageParam.ofUser(userMessage));
MessageCreateParams params = MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.messages(messages)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder()
.trigger(BetaInputTokensTrigger.builder()
.value(100000L)
.build())
.pauseAfterCompaction(true)
.build())
.build())
.build();
BetaMessage response = client.beta().messages().create(params);
// Suche nach dem Compaction-Block, nicht nach dem Stop-Grund:
// stopReason() ist REFUSAL, nicht COMPACTION, wenn die Zusammenfassung blockiert wurde
var compactionBlock = response.content().stream()
.flatMap(block -> block.compaction().stream())
.findFirst();
// Ersetze den Verlauf nur, wenn eine Zusammenfassung erstellt wurde
if (compactionBlock.flatMap(block -> block.content()).isPresent()) {
// Behalte den vorherigen Austausch + aktuelle Nutzernachricht (3 Nachrichten),
// ohne Thinking-Blöcke; ein leer gebliebener Assistant-Turn wird verworfen
List preservedMessages = new ArrayList<>();
for (BetaMessageParam message : messages.subList(Math.max(0, messages.size() - 3), messages.size())) {
if (message.isAssistant() && message.asAssistant().content().isContentBlockParams()) {
var keptBlocks = message.asAssistant().content().asContentBlockParams().stream()
.filter(block -> !block.isThinking() && !block.isRedactedThinking())
.toList();
if (keptBlocks.isEmpty()) {
continue;
}
message = BetaMessageParam.ofAssistantOfContentBlockParams(keptBlocks);
}
preservedMessages.add(message);
}
// Erstelle neue Nachrichtenliste: Compaction + beibehaltene Nachrichten
List messagesAfterCompaction = new ArrayList<>();
messagesAfterCompaction.add(response.toParam());
messagesAfterCompaction.addAll(preservedMessages);
// Aktualisiere die Nachrichtenliste entsprechend der Compaction
messages.clear();
messages.addAll(messagesAfterCompaction);
}
if (compactionBlock.isPresent()) {
// Setze die Anfrage fort, mit vollem Verlauf, falls keine Zusammenfassung existiert
MessageCreateParams continueParams = MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.messages(messages)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build();
response = client.beta().messages().create(continueParams);
}
// Hänge die finale Antwort an
messages.add(response.toParam());
return response.content().stream()
.filter(block -> block.text().isPresent())
.map(block -> block.text().get().text())
.findFirst()
.orElse("");
}
public static void main(String[] args) {
System.out.println(chat("Briefly, help me build a Python web scraper"));
System.out.println(chat("Briefly, add support for JavaScript-rendered pages"));
System.out.println(chat("Briefly, add rate limiting and error handling"));
}
```
```php PHP
$client = new Client();
$messages = [];
function chat($client, &$messages, $userMessage)
{
$messages[] = ['role' => 'user', 'content' => $userMessage];
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [
[
'type' => 'compact_20260112',
'trigger' => ['type' => 'input_tokens', 'value' => 100000],
'pause_after_compaction' => true
]
]
]
);
// Suche nach dem Komprimierungsblock, nicht nach dem Stop-Grund:
// stopReason ist 'refusal', nicht 'compaction', wenn die Zusammenfassung blockiert wurde
$compactionBlock = null;
foreach ($response->content as $block) {
if ($block instanceof \Anthropic\Beta\Messages\BetaCompactionBlock) {
$compactionBlock = $block;
break;
}
}
// Ersetze den Verlauf nur, wenn eine Zusammenfassung erstellt wurde
if ($compactionBlock?->content !== null) {
// Behalte den vorherigen Austausch + aktuelle Nutzernachricht (3 Nachrichten) bei,
// ohne Thinking-Blöcke; ein leer gebliebener Assistant-Turn wird verworfen
$preserved = array_values(array_filter(array_map(
fn($message) => $message['role'] === 'assistant'
? array_merge($message, ['content' => array_values(array_filter(
$message['content'],
fn($block) => !in_array($block->type, ['thinking', 'redacted_thinking'], true)
))])
: $message,
array_slice($messages, -3)
), fn($message) => $message['content'] !== []));
$messagesAfterCompaction = array_merge(
[['role' => 'assistant', 'content' => [$compactionBlock]]],
$preserved
);
$messages = $messagesAfterCompaction;
}
if ($compactionBlock !== null) {
// Setze die Anfrage fort, mit vollem Verlauf, falls keine Zusammenfassung existiert
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [['type' => 'compact_20260112']]
]
);
}
$messages[] = ['role' => 'assistant', 'content' => $response->content];
foreach ($response->content as $block) {
if ($block->type === 'text') {
return $block->text;
}
}
return '';
}
echo chat($client, $messages, 'Briefly, help me build a Python web scraper') . "\n";
echo chat($client, $messages, 'Briefly, add support for JavaScript-rendered pages') . "\n";
echo chat($client, $messages, 'Briefly, add rate limiting and error handling') . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
messages = []
def chat(client, messages, user_message)
messages << { role: "user", content: user_message }
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [
{
type: "compact_20260112",
trigger: { type: "input_tokens", value: 100000 },
pause_after_compaction: true
}
]
}
)
# Suche nach dem Komprimierungsblock, nicht nach dem Stop-Grund:
# stop_reason ist :refusal, nicht :compaction, wenn die Zusammenfassung blockiert wurde
compaction_block = response.content.find { |block| block.type == :compaction }
# Ersetze den Verlauf nur, wenn eine Zusammenfassung erstellt wurde
if compaction_block&.content
# Behalte den vorherigen Austausch + aktuelle Nutzernachricht (3 Nachrichten),
# ohne Thinking-Blöcke; ein leer gebliebener Assistant-Turn wird verworfen
preserved = messages.last(3).map do |message|
next message unless message[:role] == "assistant"
message.merge(content: message[:content].reject { |block| %i[thinking redacted_thinking].include?(block.type) })
end.reject { |message| message[:content].empty? }
messages_after_compaction = [
{ role: "assistant", content: [compaction_block] }
] + preserved
messages.clear
messages.concat(messages_after_compaction)
end
if compaction_block
# Setze die Anfrage fort, mit vollem Verlauf, falls keine Zusammenfassung existiert
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 4096,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
end
messages << { role: "assistant", content: response.content }
response.content.find { |block| block.type == :text }&.text || ""
end
puts chat(client, messages, "Briefly, help me build a Python web scraper")
puts chat(client, messages, "Briefly, add support for JavaScript-rendered pages")
puts chat(client, messages, "Briefly, add rate limiting and error handling")
```
## Aktuelle Einschränkungen
* **Dasselbe Modell für die Zusammenfassung:** Das in deiner Anfrage angegebene Modell wird für die Zusammenfassung verwendet. Es gibt keine Option, ein anderes (zum Beispiel günstigeres) Modell für die Zusammenfassung zu verwenden.
* **Die Komprimierung kann fehlschlagen, wenn Tools definiert sind:** Wenn deine Anfrage `tools` enthält, ruft das Modell während des internen Zusammenfassungsschritts gelegentlich ein Tool auf, anstatt eine Zusammenfassung zu schreiben. In diesem Fall enthält die Antwort einen `compaction`-Block mit `content: null`. Um dies zu verhindern, setze [`instructions`](https://platform.claude.com/docs/de/build-with-claude/compaction-threshold#custom-summarization-instructions) auf einen Prompt, der dem Modell ausdrücklich sagt, keine Tools aufzurufen, zum Beispiel:
```text wrap
Summarize the transcript inside tags. Include relevant information in the summary for continuing the task in the next context window. Do not call any tools while writing this summary; respond with text only.
```
## Nächste Schritte
Verwalte den Unterhaltungskontext automatisch, während er wächst, mit Kontextbearbeitung.
Erfahre mehr über Kontextfenstergrößen und Verwaltungsstrategien.
Entdecke eine praktische Implementierung, die lang laufende Unterhaltungen mit sofortiger Komprimierung des Sitzungsspeichers mithilfe von Hintergrund-Threading und Prompt-Caching verwaltet.
## Verfügbarkeit
Schwellenwert-Komprimierung ist auf ausgewählten Modellen in der Beta und für Zero Data Retention berechtigt.
### API-Unterstützung
#### [Messages API](https://platform.claude.com/docs/de/build-with-claude/working-with-messages)
* Verfügbarkeit: Verfügbar
* Nutzung: Aktiviere sie mit einer `compact_20260112`-Bearbeitung in `context_management.edits`. Die Komprimierung beginnt, wenn die Eingabetokens den Auslöser erreichen, standardmäßig 150.000 und mindestens 50.000.
| Status | Cloud-Plattformen | Modelle |
| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Beta | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws), [Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock), [Amazon Bedrock (InvokeModel)](https://platform.claude.com/docs/de/build-with-claude/claude-on-amazon-bedrock-legacy), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/google-managed), [Microsoft Foundry](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry) | [Claude Fable 5.1](https://platform.claude.com/docs/de/models/fable-5-1/overview), [Claude Mythos 5.1](https://platform.claude.com/docs/de/models/mythos-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/de/models/fable-5/overview), [Claude Mythos 5](https://platform.claude.com/docs/de/models/mythos-5/overview), Claude Mythos Preview, [Claude Opus 5.5](https://platform.claude.com/docs/de/models/opus-5-5/overview), [Claude Opus 5](https://platform.claude.com/docs/de/models/opus-5/overview), [Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/overview), [Claude Sonnet 5](https://platform.claude.com/docs/de/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/de/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/de/models/opus-4-8/overview), [Claude Opus 4.7](https://platform.claude.com/docs/de/models/opus-4-7/overview), [Claude Opus 4.6](https://platform.claude.com/docs/de/models/opus-4-6/overview), [Claude Sonnet 4.6](https://platform.claude.com/docs/de/models/sonnet-4-6/overview) |
#### [Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview)
* Verfügbarkeit: Immer aktiv
* Nutzung: Sie komprimiert den Unterhaltungsverlauf der Sitzung, damit er in das Kontextfenster passt, und jede Komprimierung gibt ein Event `agent.thread_context_compacted` aus.
| Status | Cloud-Plattformen | Modelle |
| ------ | ------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Beta | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws) | [Claude Fable 5.1](https://platform.claude.com/docs/de/models/fable-5-1/overview), [Claude Mythos 5.1](https://platform.claude.com/docs/de/models/mythos-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/de/models/fable-5/overview), [Claude Mythos 5](https://platform.claude.com/docs/de/models/mythos-5/overview), Claude Mythos Preview, [Claude Opus 5.5](https://platform.claude.com/docs/de/models/opus-5-5/overview), [Claude Opus 5](https://platform.claude.com/docs/de/models/opus-5/overview), [Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/overview), [Claude Sonnet 5](https://platform.claude.com/docs/de/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/de/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/de/models/opus-4-8/overview), [Claude Opus 4.7](https://platform.claude.com/docs/de/models/opus-4-7/overview), [Claude Opus 4.6](https://platform.claude.com/docs/de/models/opus-4-6/overview), [Claude Sonnet 4.6](https://platform.claude.com/docs/de/models/sonnet-4-6/overview) |
### Erforderliche Beta-Header
[Übersicht über Beta-Header](https://platform.claude.com/docs/de/api/beta-headers)
Mit Beta-Headern kannst du auf experimentelle Funktionen und neue Modellfähigkeiten zugreifen, bevor sie Teil der Standard-API werden.
| Header | APIs |
| -------------------- | ------------------------------------------------------------------------------------------- |
| `compact-2026-01-12` | [Messages API](https://platform.claude.com/docs/de/build-with-claude/working-with-messages) |
### Datenverarbeitung
[Übersicht über die Datenverarbeitung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention#feature-eligibility)
| Element | Zero Data Retention | HIPAA |
| ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- |
| Status | Berechtigt (ausgenommen: [Abgedeckte Modelle](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention#model-specific-data-retention-requirements)) | Nicht berechtigt |
| Details | Ergebnisse der serverseitigen Komprimierung werden zustandslos über die API-Antwort zurückgegeben und zurückgesendet. | — |
Zutreffende Endpunkte:
* `/v1/messages` mit `context_management`