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

Die Komprimierung verlängert die effektive Kontextlänge für lang andauernde Konversationen und Aufgaben, indem ältere Kontexte automatisch zusammengefasst werden, wenn das Limit des Kontextfensters erreicht wird. Das ist ideal für:

Die Komprimierung wird auf den folgenden Modellen unterstützt:

So funktioniert die Verdichtung

Wenn die Komprimierung aktiviert ist, fasst die Konversation Claude automatisch zusammen, wenn sie sich dem konfigurierten Token-Schwellenwert nähert. Die API:

Hängen Sie bei nachfolgenden Anfragen 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

Aktiviere die Komprimierung, indem du die compact_20260112 Strategie zu context_management.edits deiner Nachrichten-API-Anfrage hinzufügst.

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

Trigger-Konfiguration

Konfigurieren Sie mithilfe des trigger Parameters, 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 Eingabeaufforderung für die Zusammenfassung:

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 <summary></summary> block.

Sie können mithilfe des instructions Parameters benutzerdefinierte Anweisungen angeben, um diese Eingabeaufforderung vollständig zu ersetzen. Benutzerdefinierte Anweisungen ergänzen die Standardeinstellung nicht; sie 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"])

Nach dem Komprimieren wird eine Pause eingelegt

Wird verwendetpause_after_compaction, um die API nach dem Generieren der Komprimierungszusammenfassung anzuhalten. Auf diese Weise können Sie zusätzliche Inhaltsblöcke hinzufügen (z. B. das Speichern 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 Komprimierungsblocks eine Meldung 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 Komprimierungen führen. Der letzte Komprimierungsblock gibt den endgültigen Status der Aufforderung wieder 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 Komprimierungsblock streamt anders als Textblöcke. Sie erhalten ein content_block_start Ereignis, gefolgt von einer Single content_block_delta mit der vollständigen Zusammenfassung (kein Zwischenstreaming) und dann ein content_block_stop Ereignis.

Prompt-Caching

Sie können den Komprimierungsblöcken einen cache_control Haltepunkt hinzufügen, der die gesamte Systemaufforderung zusammen mit dem zusammengefassten Inhalt zwischenspeichert. Der ursprüngliche komprimierte Inhalt wird ignoriert. Beachten Sie, dass das Auslösen der Komprimierung dazu führen kann, dass bei der nachfolgenden Anfrage ein Cache-Fehler auftritt.

{
    "role": "assistant",
    "content": [
        {
            "type": "compaction",
            "content": "[summary text]",
            "cache_control": {"type": "ephemeral"}
        },
        {
            "type": "text",
            "text": "Based on our conversation..."
        }
    ]
}

Grundlegendes zur Verwendung

Für die Komprimierung ist ein zusätzlicher Probenahmeschritt erforderlich, der zu den Tarifgrenzen und zur Abrechnung 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. Bei der Komprimierung wird eine Iteration angezeigt, auf die die compaction Hauptiteration folgt. message Die Anzahl der Tokens der letzten Iteration spiegelt die effektive Kontextgröße nach der Komprimierung wider.