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**
Server-side Die Komprimierung wird für die Verwaltung von Kontexten in lang andauernden Konversationen und Agentenabläufen empfohlen, da sie das Kontextmanagement automatisch und mit minimalem Integrationsaufwand übernimmt.
**Anmerkung**
Compaction 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-based, Multi-Turn-Konversationen, bei denen Sie möchten, dass Benutzer einen Chat über einen längeren Zeitraum verwenden
+ Task-oriented 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. Re-applying Für einen vorherigen `compaction` Block fallen keine zusätzlichen Verdichtungskosten an, 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. Erstellt 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 Token sein. |
| pause\_after\_compaction | boolesch | false | Ob nach dem Generieren der Zusammenfassung der Komprimierung eine Pause eingelegt werden soll |
| instructions | Zeichenfolge | null | Aufforderung zur benutzerdefinierten Zusammenfassung. Ersetzt die Standardaufforderung vollständig, sofern sie bereitgestellt wird. |
## Konfiguration auslösen
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 den Standard nicht, sondern ersetzen ihn 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, wird eine `compaction` Iteration gefolgt von der Hauptiteration angezeigt. `message` Die Token-Anzahl der letzten Iteration spiegelt die effektive Kontextgröße nach der Komprimierung wider.