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** La compattazione lato server è consigliata per la gestione del contesto nelle conversazioni di lunga durata e nei flussi di lavoro agentici, poiché 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 ci si avvicina al limite della finestra di contesto. È ideale per: + Conversazioni basate su chat a turni in cui si desidera che gli utenti utilizzino una chat per un lungo periodo di tempo + Prompt orientati alle attività che richiedono molto lavoro di follow-up (spesso l'uso di strumenti) e che possono superare la finestra contestuale di 200.000 La compattazione è supportata sui 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 per aggregarla quando la compattazione è abilitata. `usage.iterations` L'`iterations`array è presente solo quando viene attivata una nuova compattazione durante la richiesta. La riapplicazione di 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, riassume 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 precedenti al `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\$120260112" | | trigger | oggetto | 150.000 token | Quando attivare la compattazione. Devono essere almeno 50.000 gettoni. | | pause\$1after\$1compaction | 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 la seguente richiesta 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 quelle predefinite, ma le 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 Consente `pause_after_compaction` di 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 di 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"]) ``` ## Lavorare con 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 e sostituisce 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 risposte in streaming 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 di riepilogo completo (senza streaming intermedio) e poi da un evento. `content_block_stop` ## Caching dei prompt Puoi aggiungere un `cache_control` breakpoint sui blocchi di compattazione, che memorizza nella cache l'intero prompt del sistema insieme al contenuto riepilogato. Il contenuto compattato originale viene ignorato. Tieni presente che quando viene attivata la compattazione, può causare la 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..." } ] } ``` ## Comprendere l'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 numero di token dell'iterazione finale riflette la dimensione effettiva del contesto dopo la compattazione.