Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Compactage

Le compactage allonge la longueur effective du contexte pour les conversations et les tâches de longue durée en résumant automatiquement l'ancien contexte à l'approche de la limite de la fenêtre de contexte. C'est idéal pour :

Le compactage est pris en charge sur les modèles suivants :

Comment fonctionne le compactage

Lorsque le compactage est activé, résume Claude automatiquement votre conversation lorsqu'elle approche du seuil de jeton configuré. L'API :

Lors des demandes suivantes, ajoutez la réponse à vos messages. L'API supprime automatiquement tous les blocs de messages avant le compaction blocage, poursuivant ainsi la conversation à partir du résumé.

Utilisation de base

Activez le compactage en ajoutant la compact_20260112 stratégie à context_management.edits dans votre demande d'API Messages.

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

Configuration du déclencheur

Configurez le moment où le compactage se déclenche à l'aide du trigger paramètre :

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"])

Instructions de résumé personnalisées

Par défaut, le compactage utilise l'invite de synthèse suivante :

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.

Vous pouvez fournir des instructions personnalisées via le instructions paramètre pour remplacer complètement cette invite. Les instructions personnalisées ne complètent pas la valeur par défaut ; elles la remplacent complètement :

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"])

Pause après le compactage

Permet pause_after_compaction de suspendre l'API après avoir généré le résumé du compactage. Cela vous permet d'ajouter des blocs de contenu supplémentaires (tels que la préservation des messages récents ou des messages spécifiques orientés vers des instructions) avant que l'API ne poursuive la réponse.

Lorsqu'elle est activée, l'API renvoie un message avec la raison de l'compactionarrêt après avoir généré le bloc de compactage :

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"])

Travailler avec des blocs de compactage

Lorsque le compactage est déclenché, l'API renvoie un compaction bloc au début de la réponse de l'assistant.

Une conversation de longue durée peut entraîner de multiples compactages. Le dernier bloc de compactage reflète l'état final de l'invite, en remplaçant le contenu qui le précède par le résumé généré.

{
  "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

Lorsque vous diffusez des réponses alors que le compactage est activé, vous recevez un content_block_start événement lorsque le compactage commence. Le flux du bloc de compactage diffère de celui des blocs de texte. Vous recevrez un content_block_start événement, suivi d'un single content_block_delta avec le résumé complet du contenu (pas de diffusion intermédiaire), puis d'un content_block_stop événement.

Mise en cache des invites

Vous pouvez ajouter un cache_control point d'arrêt sur les blocs de compactage, qui met en cache l'invite complète du système ainsi que le contenu résumé. Le contenu compressé d'origine est ignoré. Notez que lorsque le compactage est déclenché, cela peut entraîner un échec du cache lors de la demande suivante.

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

Comprendre l'utilisation

Le compactage nécessite une étape d'échantillonnage supplémentaire, ce qui contribue aux limites de débit et à la facturation. L'API renvoie des informations d'utilisation détaillées dans la réponse :

{
  "usage": {
    "input_tokens": 45000,
    "output_tokens": 1234,
    "iterations": [
      {
        "type": "compaction",
        "input_tokens": 180000,
        "output_tokens": 3500
      },
      {
        "type": "message",
        "input_tokens": 23000,
        "output_tokens": 1000
      }
    ]
  }
}

Le iterations tableau indique l'utilisation pour chaque itération d'échantillonnage. En cas de compactage, vous verrez une compaction itération suivie de l'itération principalemessage. Le nombre de jetons de l'itération finale reflète la taille effective du contexte après compactage.