Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Compattazione **Suggerimento** Server-side la compattazione è consigliata per la gestione del contesto in conversazioni di lunga durata e flussi di lavoro agentici in quanto gestisce automaticamente la gestione del contesto con un lavoro di integrazione minimo. **Nota** La compattazione è attualmente in versione beta. Includi l'intestazione beta `compact-2026-01-12` nelle tue richieste API per utilizzare questa funzionalità. La compattazione non è attualmente supportata dall'ConverseAPI, tuttavia è supportata con. [ InvokeModel ](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) La compattazione estende la lunghezza effettiva del contesto per conversazioni e attività di lunga durata riassumendo automaticamente il contesto precedente quando si avvicina il limite della finestra di contesto. È ideale per: + Chat-based, conversazioni a più turni in cui desideri che gli utenti utilizzino una chat per un lungo periodo di tempo + Task-oriented prompt che richiedono molto lavoro di follow-up (spesso l'uso di strumenti) che possono superare la finestra contestuale di 200.000 La compattazione è supportata nei seguenti modelli: | Modello | ID modello | | --- | --- | | Claude Sonnet 4.6 | `anthropic.claude-sonnet-4-6` | | Claude Opus 4.6 | `anthropic.claude-opus-4-6-v1` | **Nota** Il livello superiore `input_tokens` e `output_tokens` quello `usage` sul campo non includono l'utilizzo delle iterazioni di compattazione e riflettono la somma di tutte le iterazioni non di compattazione. Per calcolare il totale dei token consumati e fatturati per una richiesta, sommate tutte le voci dell'array. `usage.iterations` Se in precedenza facevi affidamento su `usage.input_tokens` e `usage.output_tokens` per il monitoraggio o il controllo dei costi, dovrai aggiornare la logica di tracciamento in `usage.iterations` modo da aggregarla quando la compattazione è abilitata. L'`iterations`array è presente solo quando viene attivata una nuova compattazione durante la richiesta. Re-applying un `compaction` blocco precedente non comporta costi di compattazione aggiuntivi e in tal caso i campi di utilizzo di primo livello rimangono accurati. ## Come funziona la compattazione Quando la compattazione è abilitata, riepiloga Claude automaticamente la conversazione quando si avvicina alla soglia del token configurata. L'API: 1. Rileva quando i token di input superano la soglia di attivazione specificata. 1. Genera un riepilogo della conversazione corrente. 1. Crea un `compaction` blocco contenente il riepilogo. 1. Continua la risposta con il contesto compatto. Nelle richieste successive, aggiungi la risposta ai tuoi messaggi. L'API elimina automaticamente tutti i blocchi di messaggi prima del `compaction` blocco, continuando la conversazione dal riepilogo. ## Utilizzo di base Abilita la compattazione aggiungendo la `compact_20260112` strategia `context_management.edits` nella tua richiesta 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 | Parametro | Tipo | Predefinita | Description | | --- | --- | --- | --- | | type | stringa | Richiesto | Deve essere "compact\_20260112" | | trigger | oggetto | 150.000 token | Quando attivare la compattazione. Devono essere almeno 50.000 token. | | pause\_after\_compaction | booleano | false | Se mettere in pausa dopo aver generato il riepilogo della compattazione | | instructions | stringa | null | Richiesta di riepilogo personalizzata. Sostituisce completamente il prompt predefinito quando fornito. | ## Configurazione del trigger Configura quando si attiva la compattazione utilizzando il `trigger` parametro: ``` 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"]) ``` ## Istruzioni di riepilogo personalizzate Per impostazione predefinita, la compattazione utilizza il seguente prompt di riepilogo: ``` 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. ``` È possibile fornire istruzioni personalizzate tramite il `instructions` parametro per sostituire completamente questo prompt. Le istruzioni personalizzate non integrano l'impostazione predefinita, ma la sostituiscono 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 dopo la compattazione `pause_after_compaction`Usalo per mettere in pausa l'API dopo aver generato il riepilogo della compattazione. Ciò consente di aggiungere blocchi di contenuto aggiuntivi (ad esempio la conservazione dei messaggi recenti o dei messaggi specifici orientati alle istruzioni) prima che l'API continui con la risposta. Se abilitata, l'API restituisce un messaggio con il motivo dell'`compaction`interruzione dopo aver generato il blocco di compattazione: ``` 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"]) ``` ## Utilizzo dei blocchi di compattazione Quando viene attivata la compattazione, l'API restituisce un `compaction` blocco all'inizio della risposta dell'assistente. Una conversazione di lunga durata può comportare compattazioni multiple. L'ultimo blocco di compattazione riflette lo stato finale del prompt, sostituendo il contenuto precedente con il riepilogo generato. ``` { "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 Quando trasmetti in streaming le risposte con la compattazione abilitata, riceverai un `content_block_start` evento all'inizio della compattazione. Lo streaming del blocco di compattazione è diverso dai blocchi di testo. Riceverai un `content_block_start` evento, seguito da un singolo `content_block_delta` con il contenuto riassuntivo completo (senza streaming intermedio) e poi un evento. `content_block_stop` ## Caching dei prompt Puoi aggiungere un `cache_control` punto di interruzione sui blocchi di compattazione, che memorizza nella cache l'intero prompt del sistema insieme al contenuto riepilogato. Il contenuto originale compresso viene ignorato. Tieni presente che quando viene attivata la compattazione, può causare una perdita della cache nella richiesta successiva. ``` { "role": "assistant", "content": [ { "type": "compaction", "content": "[summary text]", "cache_control": {"type": "ephemeral"} }, { "type": "text", "text": "Based on our conversation..." } ] } ``` ## Comprensione dell'utilizzo La compattazione richiede una fase di campionamento aggiuntiva, che contribuisce ai limiti tariffari e alla fatturazione. L'API restituisce informazioni dettagliate sull'utilizzo nella risposta: ``` { "usage": { "input_tokens": 45000, "output_tokens": 1234, "iterations": [ { "type": "compaction", "input_tokens": 180000, "output_tokens": 3500 }, { "type": "message", "input_tokens": 23000, "output_tokens": 1000 } ] } } ``` L'`iterations`array mostra l'utilizzo per ogni iterazione di campionamento. Quando si verifica la compattazione, vedrai un'`compaction`iterazione seguita dall'iterazione principale. `message` Il conteggio dei token dell'iterazione finale riflette la dimensione effettiva del contesto dopo la compattazione.