Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verdichtung
**Tipp**
Die serverseitige Komprimierung wird für die Verwaltung des Kontextes in lang andauernden Konversationen und Agentenworkflows empfohlen, da sie das Kontextmanagement automatisch und mit minimalem Integrationsaufwand abwickelt.
**Anmerkung**
Die Komprimierung befindet sich derzeit in der Betaphase. Nehmen Sie den Beta-Header `compact-2026-01-12` in Ihre API-Anfragen auf, um diese Funktion zu nutzen. Die Komprimierung wird derzeit von der Converse API nicht unterstützt, sie wird jedoch von unterstützt. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)
Durch die Komprimierung wird die effektive Kontextlänge für Konversationen und Aufgaben mit langer Laufzeit verlängert, indem älterer Kontext automatisch zusammengefasst wird, wenn das Kontext-Fensterlimit erreicht wird. Das ist ideal für:
+ Chat-basierte Konversationen mit mehreren Runden, bei denen Sie möchten, dass Benutzer einen Chat über einen längeren Zeitraum verwenden
+ Aufgabenorientierte Eingabeaufforderungen, die viel Nacharbeit erfordern (häufig den Einsatz von Tools) und die das Kontextfenster von 200.000 überschreiten können
Die Komprimierung wird auf den folgenden Modellen unterstützt:
| Modell | Modell-ID |
| --- | --- |
| Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` |
| Claude Opus 4.6 | `anthropic.claude-opus-4-6-v1` |
**Anmerkung**
Die Werte auf oberster Ebene `input_tokens` und `output_tokens` im `usage` Feld enthalten nicht die Verwendung von Verdichtungsiterationen und geben die Summe aller Iterationen ohne Komprimierung wieder. Um die Gesamtzahl der für eine Anfrage verbrauchten und in Rechnung gestellten Token zu berechnen, summieren Sie alle Einträge im Array. `usage.iterations`
Wenn Sie sich bisher `usage.output_tokens` bei der Kostenverfolgung oder -prüfung auf `usage.input_tokens` und verlassen haben, müssen Sie Ihre Nachverfolgungslogik aktualisieren, damit `usage.iterations` sie bei aktivierter Komprimierung aggregiert wird. Das `iterations` Array ist nur vorhanden, wenn während der Anforderung eine neue Komprimierung ausgelöst wird. Das erneute Anwenden eines vorherigen `compaction` Blocks verursacht keine zusätzlichen Verdichtungskosten, und die Verwendungsfelder der obersten Ebene bleiben in diesem Fall korrekt.
## Wie funktioniert die Verdichtung
Wenn die Komprimierung aktiviert ist, fasst Ihre Konversation Claude automatisch zusammen, wenn sie sich dem konfigurierten Token-Schwellenwert nähert. Die API:
1. Erkennt, wenn Eingabe-Tokens den angegebenen Triggerschwellenwert überschreiten.
1. Generiert eine Zusammenfassung der aktuellen Konversation.
1. Erzeugt einen `compaction` Block, der die Zusammenfassung enthält.
1. Setzt die Antwort mit dem komprimierten Kontext fort.
Bei nachfolgenden Anfragen fügen Sie die Antwort an Ihre Nachrichten an. Die API löscht automatisch alle Nachrichtenblöcke vor dem `compaction` Block und setzt die Konversation von der Zusammenfassung aus fort.
## Grundlegende Verwendung
Aktivieren Sie die Komprimierung, indem Sie die `compact_20260112` Strategie zu `context_management.edits` Ihrer Nachrichten-API-Anfrage hinzufügen.
------
#### [ CLI ]
```
aws bedrock-runtime invoke-model \
--model-id "us.anthropic.claude-opus-4-6-v1" \
--body '{
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [
{
"role": "user",
"content": "Help me build a website"
}
],
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
}' \
--cli-binary-format raw-in-base64-out \
/tmp/response.json
echo "Response:"
cat /tmp/response.json | jq '.content[] | {type, text: .text[0:500]}'
```
------
#### [ Python ]
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
messages = [{"role": "user", "content": "Help me build a website"}]
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [
{
"type": "compact_20260112"
}
]
}
})
)
response_body = json.loads(response["body"].read())
# Append the response (including any compaction block) to continue the conversation
messages.append({"role": "assistant", "content": response_body["content"]})
for block in response_body["content"]:
if block.get("type") == "compaction":
print(f"[COMPACTION]: {block['content'][:200]}...")
elif block.get("type") == "text":
print(f"[RESPONSE]: {block['text']}")
```
------
#### [ TypeScript ]
```
import { BedrockRuntimeClient, InvokeModelCommand } from "@aws-sdk/client-bedrock-runtime";
async function main() {
const client = new BedrockRuntimeClient({});
const messages: Array<{role: string, content: string | object[]}> = [
{ role: "user", content: "Help me build a website" }
];
const command = new InvokeModelCommand({
modelId: "us.anthropic.claude-opus-4-6-v1",
body: JSON.stringify({
anthropic_version: "bedrock-2023-05-31",
anthropic_beta: ["compact-2026-01-12"],
max_tokens: 4096,
messages,
context_management: {
edits: [
{
type: "compact_20260112"
}
]
}
})
});
const response = await client.send(command);
const responseBody = JSON.parse(new TextDecoder().decode(response.body));
// Append response to continue conversation
messages.push({ role: "assistant", content: responseBody.content });
for (const block of responseBody.content) {
if (block.type === "compaction") {
console.log(`[COMPACTION]: ${block.content.substring(0, 200)}...`);
} else if (block.type === "text") {
console.log(`[RESPONSE]: ${block.text}`);
}
}
}
main().catch(console.error);
```
------
## Parameters
| Parameter | Typ | Standard | Description |
| --- | --- | --- | --- |
| type | Zeichenfolge | Erforderlich | Muss "compact\_20260112" sein. |
| trigger | object | 150.000 Token | Wann muss die Verdichtung ausgelöst werden? Es müssen mindestens 50.000 Tokens sein. |
| pause\_after\_compaction | boolesch | false | Ob nach dem Generieren der Zusammenfassung der Komprimierung eine Pause eingelegt werden soll |
| instructions | Zeichenfolge | null | Eingabeaufforderung zur benutzerdefinierten Zusammenfassung. Ersetzt die Standardaufforderung vollständig, sofern sie bereitgestellt wird. |
## Konfiguration des Triggers
Konfigurieren Sie mit dem folgenden `trigger` Parameter, wann die Komprimierung ausgelöst wird:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [{"role": "user", "content": "Help me build a website"}],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"trigger": {
"type": "input_tokens",
"value": 100000
}
}
]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Anweisungen zur benutzerdefinierten Zusammenfassung
Standardmäßig verwendet die Komprimierung die folgende Zusammenfassungsaufforderung:
```
You have written a partial transcript for the initial task above. Please write a summary of the transcript. The purpose of this summary is to provide continuity so you can continue to make progress towards solving the task in a future context, where the raw history above may not be accessible and will be replaced with this summary. Write down anything that would be helpful, including the state, next steps, learnings etc. You must wrap your summary in a block.
```
Sie können über den `instructions` Parameter benutzerdefinierte Anweisungen angeben, um diese Aufforderung vollständig zu ersetzen. Benutzerdefinierte Anweisungen ergänzen die Standardeinstellung nicht, sondern ersetzen sie vollständig:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": [{"role": "user", "content": "Help me build a website"}],
"context_management": {
"edits": [
{
"type": "compact_20260112",
"instructions": "Focus on preserving code snippets, variable names, and technical decisions."
}
]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Wird nach der Verdichtung angehalten
Wird verwendet`pause_after_compaction`, um die API nach dem Generieren der Zusammenfassung der Komprimierung anzuhalten. Auf diese Weise können Sie zusätzliche Inhaltsblöcke hinzufügen (z. B. die Beibehaltung aktueller Nachrichten oder bestimmter anweisungsorientierter Nachrichten), bevor die API mit der Antwort fortfährt.
Wenn diese Option aktiviert ist, gibt die API nach der Generierung des Verdichtungsblocks eine Nachricht mit dem Grund für den `compaction` Stopp zurück:
```
import boto3
import json
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
messages = [{"role": "user", "content": "Help me build a website"}]
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [
{
"type": "compact_20260112",
"pause_after_compaction": True
}
]
}
})
)
response_body = json.loads(response["body"].read())
# Check if compaction triggered a pause
if response_body.get("stop_reason") == "compaction":
# Response contains only the compaction block
messages.append({"role": "assistant", "content": response_body["content"]})
# Continue the request
response = bedrock_runtime.invoke_model(
modelId="us.anthropic.claude-opus-4-6-v1",
body=json.dumps({
"anthropic_version": "bedrock-2023-05-31",
"anthropic_beta": ["compact-2026-01-12"],
"max_tokens": 4096,
"messages": messages,
"context_management": {
"edits": [{"type": "compact_20260112"}]
}
})
)
response_body = json.loads(response["body"].read())
print(response_body["content"][-1]["text"])
```
## Mit Verdichtungsblöcken arbeiten
Wenn die Komprimierung ausgelöst wird, gibt die API zu Beginn der Assistentenantwort einen `compaction` Block zurück.
Eine lang andauernde Konversation kann zu mehreren Verdichtungen führen. Der letzte Komprimierungsblock spiegelt den endgültigen Status der Aufforderung wider und ersetzt den Inhalt davor durch die generierte Zusammenfassung.
```
{
"content": [
{
"type": "compaction",
"content": "Summary of the conversation: The user requested help building a web scraper..."
},
{
"type": "text",
"text": "Based on our conversation so far..."
}
]
}
```
## Streaming
Wenn Sie Antworten mit aktivierter Komprimierung streamen, erhalten Sie ein `content_block_start` Ereignis, wenn die Komprimierung beginnt. Der Verdichtungsblock streamt anders als Textblöcke. Sie erhalten eine `content_block_start` Veranstaltung, gefolgt von einer Single `content_block_delta` mit dem vollständigen Inhalt der Zusammenfassung (kein Zwischenstreaming) und dann ein `content_block_stop` Ereignis.
## Prompt-Caching
Sie können einen `cache_control` Haltepunkt für Komprimierungsblöcke hinzufügen, der die vollständige Systemaufforderung zusammen mit dem zusammengefassten Inhalt zwischenspeichert. Der komprimierte Originalinhalt wird ignoriert. Beachten Sie, dass, wenn die Komprimierung ausgelöst wird, dies dazu führen kann, dass bei der nachfolgenden Anforderung ein Cache-Fehler auftritt.
```
{
"role": "assistant",
"content": [
{
"type": "compaction",
"content": "[summary text]",
"cache_control": {"type": "ephemeral"}
},
{
"type": "text",
"text": "Based on our conversation..."
}
]
}
```
## Die Verwendung verstehen
Für die Verdichtung ist ein zusätzlicher Probenahmeschritt erforderlich, was zu Preisobergrenzen und Fakturierung beiträgt. Die API gibt in der Antwort detaillierte Nutzungsinformationen zurück:
```
{
"usage": {
"input_tokens": 45000,
"output_tokens": 1234,
"iterations": [
{
"type": "compaction",
"input_tokens": 180000,
"output_tokens": 3500
},
{
"type": "message",
"input_tokens": 23000,
"output_tokens": 1000
}
]
}
}
```
Das `iterations` Array zeigt die Nutzung für jede Sampling-Iteration. Wenn die Komprimierung stattfindet, sehen Sie eine `compaction` Iteration, auf die die Hauptiteration folgt. `message` Die Token-Anzahl der letzten Iteration spiegelt die effektive Kontextgröße nach der Komprimierung wider.