As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Compactação **dica** A compactação do lado do servidor é recomendada para gerenciar o contexto em conversas de longa duração e fluxos de trabalho agentes, pois lida com o gerenciamento de contexto automaticamente com o mínimo de trabalho de integração. **nota** A compactação está atualmente na versão beta. Inclua o cabeçalho beta `compact-2026-01-12` em suas solicitações de API para usar esse recurso. Atualmente, a compactação não é suportada pela Converse API, mas é compatível com [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html). A compactação amplia a duração efetiva do contexto para conversas e tarefas de longa duração ao resumir automaticamente o contexto antigo ao se aproximar do limite da janela de contexto. Isso é ideal para: + Conversas de vários turnos baseadas em bate-papo, nas quais você deseja que os usuários usem um bate-papo por um longo período de tempo + Solicitações orientadas a tarefas que exigem muito trabalho de acompanhamento (geralmente uso de ferramentas) que podem exceder a janela de contexto de 200K A compactação é suportada nos seguintes modelos: | Modelo | ID do modelo | | --- | --- | | Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` | | Claude Opus 4.6 | `anthropic.claude-opus-4-6-v1` | **nota** O nível superior `input_tokens` e `output_tokens` o de `usage` campo não incluem o uso da iteração de compactação e refletem a soma de todas as iterações sem compactação. Para calcular o total de tokens consumidos e cobrados por uma solicitação, some todas as entradas na `usage.iterations` matriz. Se você já confiou no `usage.input_tokens` controle `usage.output_tokens` de custos ou na auditoria, precisará atualizar sua lógica de rastreamento para agregar `usage.iterations` quando a compactação estiver ativada. A `iterations` matriz só está presente quando uma nova compactação é acionada durante a solicitação. A reaplicação de um `compaction` bloco anterior não acarreta nenhum custo adicional de compactação, e os campos de uso de nível superior permanecem precisos nesse caso. ## Como funciona a compactação Quando a compactação está ativada, resume Claude automaticamente sua conversa quando ela se aproxima do limite de token configurado. A API: 1. Detecta quando os tokens de entrada excedem o limite de gatilho especificado. 1. Gera um resumo da conversa atual. 1. Cria um `compaction` bloco contendo o resumo. 1. Continua a resposta com o contexto compactado. Nas solicitações subsequentes, anexe a resposta às suas mensagens. A API descarta automaticamente todos os blocos de mensagens antes do `compaction` bloqueio, continuando a conversa a partir do resumo. ## Uso básico Ative a compactação adicionando a `compact_20260112` estratégia à sua solicitação `context_management.edits` da API de mensagens. ------ #### [ 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); ``` ------ ## Parâmetros | Parâmetro | Tipo | Padrão | Description | | --- | --- | --- | --- | | type | string | Obrigatório | Deve ser "compact\$120260112" | | trigger | objeto | 150.000 tokens | Quando acionar a compactação. Deve ter pelo menos 50.000 tokens. | | pause\$1after\$1compaction | booleano | false | Se deve pausar após gerar o resumo da compactação | | instructions | string | null | Solicitação de resumo personalizada. Substitui completamente o prompt padrão quando fornecido. | ## Configurações do gatilho Configure quando a compactação é acionada usando o parâmetro: `trigger` ``` 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"]) ``` ## Instruções de resumo personalizadas Por padrão, a compactação usa o seguinte prompt de resumo: ``` 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. ``` Você pode fornecer instruções personalizadas por meio do `instructions` parâmetro para substituir totalmente esse prompt. As instruções personalizadas não complementam o padrão; elas o substituem completamente: ``` 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 após a compactação Use `pause_after_compaction` para pausar a API depois de gerar o resumo da compactação. Isso permite que você adicione blocos de conteúdo adicionais (como preservar mensagens recentes ou mensagens específicas orientadas a instruções) antes que a API continue com a resposta. Quando ativada, a API retorna uma mensagem com o motivo da `compaction` parada após gerar o bloco de compactação: ``` 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"]) ``` ## Trabalhando com blocos de compactação Quando a compactação é acionada, a API retorna um `compaction` bloco no início da resposta do assistente. Uma conversa de longa duração pode resultar em várias compactações. O último bloco de compactação reflete o estado final do prompt, substituindo o conteúdo anterior pelo resumo gerado. ``` { "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 Ao transmitir respostas com a compactação ativada, você receberá um `content_block_start` evento quando a compactação começar. O bloco de compactação é transmitido de forma diferente dos blocos de texto. Você receberá um `content_block_start` evento, seguido por um single `content_block_delta` com o conteúdo resumido completo (sem streaming intermediário) e, em seguida, um `content_block_stop` evento. ## Armazenamento em cache de prompts Você pode adicionar um `cache_control` ponto de interrupção nos blocos de compactação, que armazena em cache o prompt completo do sistema junto com o conteúdo resumido. O conteúdo original compactado é ignorado. Observe que, quando a compactação é acionada, isso pode resultar em uma perda de cache na solicitação subsequente. ``` { "role": "assistant", "content": [ { "type": "compaction", "content": "[summary text]", "cache_control": {"type": "ephemeral"} }, { "type": "text", "text": "Based on our conversation..." } ] } ``` ## Entendendo o uso A compactação requer uma etapa adicional de amostragem, que contribui para os limites de taxa e o faturamento. A API retorna informações detalhadas de uso na resposta: ``` { "usage": { "input_tokens": 45000, "output_tokens": 1234, "iterations": [ { "type": "compaction", "input_tokens": 180000, "output_tokens": 3500 }, { "type": "message", "input_tokens": 23000, "output_tokens": 1000 } ] } } ``` A `iterations` matriz mostra o uso de cada iteração de amostragem. Quando a compactação ocorrer, você verá uma `compaction` iteração seguida pela iteração principal`message`. As contagens de tokens da iteração final refletem o tamanho efetivo do contexto após a compactação.