Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Compactación

La compactación amplía la longitud efectiva del contexto para conversaciones y tareas prolongadas al resumir automáticamente el contexto anterior cuando se acerca al límite de la ventana de contexto. Esto es ideal para:

La compactación es compatible con los siguientes modelos:

¿Cómo funciona la compactación

Cuando la compactación está habilitada, resume Claude automáticamente la conversación cuando se acerca al umbral de token configurado. La API:

En solicitudes posteriores, añada la respuesta a sus mensajes. La API elimina automáticamente todos los bloques de mensajes anteriores al compaction bloqueo y continúa la conversación desde el resumen.

Uso básico

Activa la compactación añadiendo la compact_20260112 estrategia a tu solicitud context_management.edits de la API de Mensajes.

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

Configuración de desencadenadores

Configure cuándo se desencadena la compactación mediante el trigger parámetro:

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

Instrucciones de resumen personalizadas

De forma predeterminada, la compactación utiliza la siguiente solicitud de resumen:

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.

Puede proporcionar instrucciones personalizadas mediante el instructions parámetro para reemplazar esta solicitud por completo. Las instrucciones personalizadas no complementan la predeterminada, sino que la sustituyen por completo:

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

Pausa después de la compactación

Se utiliza pause_after_compaction para pausar la API después de generar el resumen de compactación. Esto te permite añadir bloques de contenido adicionales (por ejemplo, conservar los mensajes recientes o mensajes específicos orientados a instrucciones) antes de que la API continúe con la respuesta.

Cuando está habilitada, la API devuelve un mensaje con el motivo de la compaction interrupción después de generar el bloque de compactación:

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

Trabajando con bloques de compactación

Cuando se activa la compactación, la API devuelve un compaction bloque al inicio de la respuesta del asistente.

Una conversación prolongada puede provocar varias compactaciones. El último bloque de compactación refleja el estado final del mensaje y reemplaza el contenido anterior por el resumen generado.

{
  "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..."
    }
  ]
}

Transmisión

Cuando transmitas las respuestas con la compactación habilitada, recibirás un content_block_start evento cuando comience la compactación. El flujo del bloque de compactación es diferente al de los bloques de texto. Recibirás un content_block_start evento, seguido de un sencillo content_block_delta con el resumen completo del contenido (sin transmisión intermedia) y, a continuación, un content_block_stop evento.

Almacenamiento en caché de peticiones

Puedes añadir un cache_control punto de interrupción en los bloques de compactación, que almacenará en caché todo el mensaje del sistema junto con el contenido resumido. Se ignora el contenido compactado original. Ten en cuenta que, cuando se activa la compactación, es posible que se pierda la memoria caché en la siguiente solicitud.

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

Entender el uso

La compactación requiere un paso de muestreo adicional, lo que contribuye a los límites de tarifa y a la facturación. La API devuelve información de uso detallada en la respuesta:

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

La iterations matriz muestra el uso de cada iteración de muestreo. Cuando se produce la compactación, verá una compaction iteración seguida de la iteración principal. message Los recuentos de símbolos de la iteración final reflejan el tamaño efectivo del contexto tras la compactación.