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

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:

Die Komprimierung wird auf den folgenden Modellen unterstützt:

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:

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

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