---
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).
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-opus-4-8
- claude-opus-4-7
- claude-opus-4-6
- claude-sonnet-5-5
- claude-sonnet-5
- claude-sonnet-4-6
- claude-haiku-5-5
supportedPlatforms:
Claude API: beta
Claude Platform on AWS: beta
Amazon Bedrock: beta
Google Cloud: beta
Microsoft Foundry: beta
---
„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 [Effective context 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: 2023-06-01" \
-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() { Role = Role.User, 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 BetaMessageParam
{
Role = Role.Assistant,
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: '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: "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: 2023-06-01" \
-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() { Role = Role.User, 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: '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: "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: 2023-06-01" \
-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 BetaMessageParam { Role = Role.User, Content = "Help me build a Python web scraper" },
new BetaMessageParam { Role = Role.Assistant, Content = "I'll help you build a web scraper..." },
new BetaMessageParam { Role = Role.User, 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")),
{Role: anthropic.BetaMessageParamRoleAssistant, 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: '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: "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: 2023-06-01" \
-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() { Role = Role.User, 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 BetaMessageParam
{
Role = Role.Assistant,
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: "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: "claude-opus-5-5",
max_tokens: 4096,
messages: messages,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
end
puts response
```
#### Ein Gesamt-Token-Budget durchsetzen
Wenn ein Modell an langen Aufgaben mit vielen Iterationen der Tool-Nutzung arbeitet, kann der gesamte Token-Verbrauch erheblich ansteigen. 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})
# Verbrauchte Tokens schätzen; bei Budgetüberschreitung zum Abschluss auffordern
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() { Role = Role.User, 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()
{
Role = Role.Assistant,
Content = response.Content.Select(b => new BetaContentBlockParam(b.Json)).ToList()
});
// Schätze die insgesamt verbrauchten Token; fordere bei Budgetüberschreitung zum Abschluss auf
if (compactionCount * TriggerThreshold >= TotalTokenBudget)
{
messages.Add(new()
{
Role = Role.User,
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.builder()
.role(BetaMessageParam.Role.USER)
.content("Hello, Claude")
.build());
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.builder()
.role(BetaMessageParam.Role.USER)
.content("Please wrap up your current work and summarize the final state.")
.build());
}
}
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: "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 }
# Verbrauchte Tokens schätzen; bei Budgetüberschreitung zum Abschluss auffordern
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:
```bash cURL
# Der Antwortinhalt, einschließlich des Compaction-Blocks, muss an die
# API als Assistant-Turn der nächsten Anfrage zurückgehen. Diese Nachrichtenliste zu verwalten,
# lässt sich schlecht als einmaliger Shell-Befehl umsetzen; siehe die CLI- und SDK-
# Tabs für den vollständigen Ablauf. Erste Anfrage:
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-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"
}
]
}
}'
```
```bash CLI
ant beta:messages create \
--beta compact-2026-01-12 \
--transform content \
--format jsonl <<'YAML' > content.json
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
YAML
# Nachdem du eine Antwort mit einem Compaction-Block erhalten hast, hänge sie als
# Assistant-Turn an und setze die Unterhaltung fort
ant beta:messages create --beta compact-2026-01-12 <
{
new() { Role = Role.User, 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 BetaMessageParam
{
Role = Role.Assistant,
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
messages.Add(new BetaMessageParam { Role = Role.User, 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: "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: "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 entfernen und nur den Komprimierungsblock und alles danach einschließen
Bei Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Sonnet 5.5 und Claude Haiku 5.5 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: 2023-06-01" \
-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 final 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() { Role = Role.User, 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(c ->
System.out.println("Compaction started...")
);
startEvent.contentBlock().text().ifPresent(t ->
System.out.println("Text response started...")
);
});
event.contentBlockDelta().ifPresent(deltaEvent -> {
deltaEvent.delta().compaction().ifPresent(cd ->
System.out.println("Compaction complete: " + cd.content().map(String::length).orElse(0) + " chars")
);
deltaEvent.delta().text().ifPresent(td ->
System.out.print(td.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;
$client = new Client();
$messages = [['role' => 'user', 'content' => 'Hello, Claude']];
$stream = $client->beta->messages->createStream(
maxTokens: 4096,
messages: $messages,
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: "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: 2023-06-01" \
-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() { Role = Role.User, 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: '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: "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: 2023-06-01" \
-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
CURRENT=$(ant beta:messages count-tokens \
--beta compact-2026-01-12 \
--transform input_tokens \
--raw-output <<'YAML'
model: claude-opus-5-5
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
YAML
)
ORIGINAL=$(ant beta:messages count-tokens \
--beta compact-2026-01-12 \
--transform context_management.original_input_tokens \
--raw-output <<'YAML'
model: claude-opus-5-5
messages:
- role: user
content: Hello, Claude
context_management:
edits:
- type: compact_20260112
YAML
)
printf 'Current tokens: %s\n' "$CURRENT"
printf 'Original tokens: %s\n' "$ORIGINAL"
```
```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() { Role = Role.User, 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: "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:
```bash cURL
# curl sendet einzelne Requests; verwalte das messages-Array im
# aufrufenden Skript. Die vollständige chat()-Schleife findest du in den SDK-Tabs. Aufbau
# eines Single-Turn-Requests:
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-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 Python web scraper"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"trigger": {
"type": "input_tokens",
"value": 100000
}
}
]
}
}'
```
```bash CLI
# Die CLI verarbeitet einzelne Turns; pflege das messages-Array im
# aufrufenden Skript. Die vollständige chat()-Schleife findest du in den SDK-Tabs. Aufbau
# einer Single-Turn-Anfrage:
ant beta:messages create \
--beta compact-2026-01-12 \
--transform 'content.#(type=="text").text' \
--raw-output <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Help me build a Python web scraper
context_management:
edits:
- type: compact_20260112
trigger:
type: input_tokens
value: 100000
YAML
```
```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},
}
]
},
)
# Antwort anhängen (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("Help me build a Python web scraper"))
print(chat("Add support for JavaScript-rendered pages"))
print(chat("Now 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 }
}
]
}
});
// Antwort anhängen (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("Help me build a Python web scraper"));
console.log(await chat("Add support for JavaScript-rendered pages"));
console.log(await chat("Now 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, "Help me build a Python web scraper"));
Console.WriteLine(await Chat(client, messages, "Add support for JavaScript-rendered pages"));
Console.WriteLine(await Chat(client, messages, "Now add rate limiting and error handling"));
static async Task Chat(AnthropicClient client, List messages, string userMessage)
{
messages.Add(new() { Role = Role.User, 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()
{
Role = Role.Assistant,
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
return response.Content
.Select(block => block.Value)
.OfType()
.Select(tb => tb.Text)
.FirstOrDefault() ?? "";
}
```
```go Go
package main
import (
"context"
"fmt"
"log"
"github.com/anthropics/anthropic-sdk-go"
)
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("Help me build a Python web scraper"))
fmt.Println(chat("Add support for JavaScript-rendered pages"))
fmt.Println(chat("Now 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("Help me build a Python web scraper"));
System.out.println(chat("Add support for JavaScript-rendered pages"));
System.out.println(chat("Now add rate limiting and error handling"));
}
private static String chat(String userMessage) {
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.USER)
.content(userMessage)
.build());
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, "Help me build a Python web scraper") . "\n";
echo chat($client, $messages, "Add support for JavaScript-rendered pages") . "\n";
echo chat($client, $messages, "Now 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: "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, "Help me build a Python web scraper")
puts chat(client, messages, "Add support for JavaScript-rendered pages")
puts chat(client, messages, "Now add rate limiting and error handling")
```
Entferne bei Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 und Claude Haiku 5.5 die `thinking`- und `redacted_thinking`-Blöcke aus jedem Assistant-Turn, den du nach dem Komprimierungsblock wieder einfügst, oder sende `thinking.block_binding.prefix_mismatch_behavior: "drop_block"` mit dem [Beta-Header](https://platform.claude.com/docs/de/api/beta-headers) `thinking-binding-controls-2026-08-01`. Diese Blöcke wurden erzeugt, als der vollständige Verlauf vorhanden war, daher bestehen sie die [Gesprächsprüfung](https://platform.claude.com/docs/de/build-with-claude/thinking#preserved-in-conversation) nicht mehr. Wo die Prüfung durchgesetzt wird, wird die Fortsetzungsanfrage mit einem 400-Fehler abgelehnt. Die erhaltenen Text- und Tool-Blöcke können unverändert bleiben. Wenn du die API alles zusammenfassen lässt, ohne frühere Turns wieder einzufügen, vermeidest du dies. Bei Claude Sonnet 5.5 funktioniert `block_binding` nur mit `thinking: {"type": "adaptive"}`. Entferne bei `between_tools` stattdessen die Blöcke. Bei Claude Haiku 5.5 funktioniert `block_binding` nur mit `thinking: {"type": "adaptive"}`, entferne also bei `thinking: {"type": "disabled"}` stattdessen die Blöcke.
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:
```bash cURL
# curl sendet einzelne Requests; pflege das messages-Array im
# aufrufenden Skript. Die vollständige chat()-Schleife mit
# Pause-und-Erhalt-Handling findest du in den SDK-Tabs. Form eines Single-Turn-Requests:
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-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 Python web scraper"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"trigger": {
"type": "input_tokens",
"value": 100000
},
"pause_after_compaction": true
}
]
}
}'
```
```bash CLI
# Die CLI verarbeitet einzelne Turns; pflege das messages-Array im
# aufrufenden Skript. Die vollständige chat()-Schleife mit
# Pause-and-Preserve-Handling findest du in den SDK-Tabs. Form einer Single-Turn-Anfrage:
ant beta:messages create \
--beta compact-2026-01-12 \
--transform 'content.#(type=="text").text' \
--raw-output <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
- role: user
content: Help me build a Python web scraper
context_management:
edits:
- type: compact_20260112
trigger:
type: input_tokens
value: 100000
pause_after_compaction: true
YAML
```
```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,
}
]
},
)
# Prüfe, ob eine Komprimierung stattgefunden und pausiert hat
if response.stop_reason == "compaction":
# Hole den Komprimierungsblock aus der Antwort
compaction_block = response.content[0]
# 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
# Setze die Anfrage mit komprimiertem Kontext + beibehaltenen Nachrichten fort
response = client.beta.messages.create(
betas=["compact-2026-01-12"],
model="claude-opus-5-5",
max_tokens=4096,
messages=messages_after_compaction,
context_management={"edits": [{"type": "compact_20260112"}]},
)
# Aktualisiere die Nachrichtenliste entsprechend der Komprimierung
messages.clear()
messages.extend(messages_after_compaction)
# 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("Help me build a Python web scraper"))
print(chat("Add support for JavaScript-rendered pages"))
print(chat("Now 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
}
]
}
});
// Prüfe, ob eine Compaction stattgefunden und pausiert hat
if (response.stop_reason === "compaction") {
// Hole den Compaction-Block aus der Antwort
const compactionBlock = response.content[0];
// 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.content.length > 0);
// Erstelle neue Nachrichtenliste: Compaction + beibehaltene Nachrichten
const messagesAfterCompaction: Anthropic.Beta.Messages.BetaMessageParam[] = [
{ role: "assistant", content: [compactionBlock] },
...preservedMessages
];
// Setze die Anfrage mit kompaktiertem Kontext + beibehaltenen Nachrichten fort
response = await client.beta.messages.create({
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages: messagesAfterCompaction,
context_management: {
edits: [{ type: "compact_20260112" }]
}
});
// Aktualisiere die Nachrichtenliste entsprechend der Compaction
messages = messagesAfterCompaction;
}
// 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("Help me build a Python web scraper"));
console.log(await chat("Add support for JavaScript-rendered pages"));
console.log(await chat("Now 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("Help me build a Python web scraper"));
Console.WriteLine(await Chat("Add support for JavaScript-rendered pages"));
Console.WriteLine(await Chat("Now add rate limiting and error handling"));
async Task Chat(string userMessage)
{
messages.Add(new() { Role = Role.User, 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
}]
}
});
if (response.StopReason == BetaStopReason.Compaction)
{
if (!response.Content[0].TryPickCompaction(out _))
throw new InvalidOperationException("Expected compaction block");
// Behalte den vorherigen Austausch + aktuelle Nutzernachricht (3 Nachrichten) bei,
// ohne Thinking-Blöcke; ein leer gebliebener Assistant-Turn wird verworfen
var preserved = messages
.Skip(Math.Max(0, messages.Count - 3))
.Select(message => message.Content.TryPickBetaContentBlockParams(out var blocks)
? new BetaMessageParam
{
Role = message.Role,
Content = blocks
.Where(block => block.Type.GetString() is not ("thinking" or "redacted_thinking"))
.ToList()
}
: message)
.Where(message => !message.Content.TryPickBetaContentBlockParams(out var blocks) || blocks.Count > 0)
.ToList();
var messagesAfterCompaction = new List
{
new()
{
Role = Role.Assistant,
Content = new List { new BetaContentBlockParam(response.Content[0].Json) }
}
};
messagesAfterCompaction.AddRange(preserved);
response = await client.Beta.Messages.Create(new()
{
Betas = ["compact-2026-01-12"],
Model = Model.ClaudeOpus5_5,
MaxTokens = 4096,
Messages = messagesAfterCompaction,
ContextManagement = new BetaContextManagementConfig
{
Edits = [new BetaCompact20260112Edit()]
}
});
messages = messagesAfterCompaction;
}
messages.Add(new()
{
Role = Role.Assistant,
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
return response.Content
.Select(block => block.Value)
.OfType()
.Select(tb => tb.Text)
.FirstOrDefault() ?? "";
}
```
```go Go
package main
import (
"context"
"fmt"
"log"
"github.com/anthropics/anthropic-sdk-go"
)
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)
}
if response.StopReason == "compaction" {
compactionParam := response.Content[0].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):] {
var content []anthropic.BetaContentBlockParamUnion
for _, block := range message.Content {
if block.OfThinking == nil && block.OfRedactedThinking == nil {
content = append(content, block)
}
}
if len(content) == 0 {
continue
}
message.Content = content
preserved = append(preserved, message)
}
messagesAfterCompaction := []anthropic.BetaMessageParam{
{Role: anthropic.BetaMessageParamRoleAssistant, Content: []anthropic.BetaContentBlockParamUnion{compactionParam}},
}
messagesAfterCompaction = append(messagesAfterCompaction, preserved...)
response, err = client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 4096,
Messages: messagesAfterCompaction,
ContextManagement: anthropic.BetaContextManagementConfigParam{
Edits: []anthropic.BetaContextManagementConfigEditUnionParam{
{OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}},
},
},
Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"},
})
if err != nil {
log.Fatal(err)
}
messages = messagesAfterCompaction
}
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("Help me build a Python web scraper"))
fmt.Println(chat("Add support for JavaScript-rendered pages"))
fmt.Println(chat("Now 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;
import com.anthropic.models.beta.messages.BetaStopReason;
// ...
private static final AnthropicClient client = AnthropicOkHttpClient.fromEnv();
private static final List messages = new ArrayList<>();
public static String chat(String userMessage) {
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.USER)
.content(userMessage)
.build());
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);
// Prüfe, ob eine Compaction stattgefunden und pausiert hat
if (response.stopReason().isPresent()
&& response.stopReason().get().equals(BetaStopReason.COMPACTION)) {
// 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.content().isBetaContentBlockParams()) {
message = message.toBuilder()
.contentOfBetaContentBlockParams(message.content().asBetaContentBlockParams().stream()
.filter(block -> !block.isThinking() && !block.isRedactedThinking())
.toList())
.build();
if (message.content().asBetaContentBlockParams().isEmpty()) {
continue;
}
}
preservedMessages.add(message);
}
// Erstelle neue Nachrichtenliste: Compaction + beibehaltene Nachrichten
List messagesAfterCompaction = new ArrayList<>();
messagesAfterCompaction.add(response.toParam());
messagesAfterCompaction.addAll(preservedMessages);
// Setze die Anfrage mit dem kompaktierten Kontext + beibehaltenen Nachrichten fort
MessageCreateParams continueParams = MessageCreateParams.builder()
.addBeta("compact-2026-01-12")
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(4096L)
.messages(messagesAfterCompaction)
.contextManagement(BetaContextManagementConfig.builder()
.addEdit(BetaCompact20260112Edit.builder().build())
.build())
.build();
response = client.beta().messages().create(continueParams);
// Aktualisiere die Nachrichtenliste entsprechend der Compaction
messages.clear();
messages.addAll(messagesAfterCompaction);
}
// 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("Help me build a Python web scraper"));
System.out.println(chat("Add support for JavaScript-rendered pages"));
System.out.println(chat("Now 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
]
]
]
);
if ($response->stopReason === 'compaction') {
$compactionBlock = $response->content[0];
// 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
);
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messagesAfterCompaction,
model: 'claude-opus-5-5',
betas: ['compact-2026-01-12'],
contextManagement: [
'edits' => [['type' => 'compact_20260112']]
]
);
$messages = $messagesAfterCompaction;
}
$messages[] = ['role' => 'assistant', 'content' => $response->content];
foreach ($response->content as $block) {
if ($block->type === 'text') {
return $block->text;
}
}
return '';
}
echo chat($client, $messages, "Help me build a Python web scraper") . "\n";
echo chat($client, $messages, "Add support for JavaScript-rendered pages") . "\n";
echo chat($client, $messages, "Now 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: "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
}
]
}
)
if response.stop_reason == :compaction
compaction_block = response.content[0]
# 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
response = client.beta.messages.create(
betas: ["compact-2026-01-12"],
model: "claude-opus-5-5",
max_tokens: 4096,
messages: messages_after_compaction,
context_management: {
edits: [{ type: "compact_20260112" }]
}
)
messages.clear
messages.concat(messages_after_compaction)
end
messages << { role: "assistant", content: response.content }
response.content.find { |block| block.type == :text }&.text || ""
end
puts chat(client, messages, "Help me build a Python web scraper")
puts chat(client, messages, "Add support for JavaScript-rendered pages")
puts chat(client, messages, "Now 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.