--- title: Compattazione a una soglia di token url: https://platform.claude.com/docs/it/build-with-claude/compaction-threshold description: Fai in modo che l'API riassuma automaticamente il contesto meno recente, all'interno di una normale richiesta, quando la conversazione raggiunge una soglia di token da te impostata. featureMetadata: status: beta betaHeader: compact-2026-01-12 zdr: eligibility: eligible note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements). supportedModels: - claude-fable-5-1 - claude-mythos-5-1 - claude-fable-5 - claude-mythos-5 - claude-mythos-preview - claude-opus-5-5 - claude-opus-5 - claude-opus-4-8 - claude-opus-4-7 - claude-opus-4-6 - claude-sonnet-5-5 - claude-sonnet-5 - claude-sonnet-4-6 - claude-haiku-5-5 supportedPlatforms: Claude API: beta Claude Platform on AWS: beta Amazon Bedrock: beta Google Cloud: beta Microsoft Foundry: beta --- La "threshold compaction" (compattazione a soglia) è il tipo automatico di compattazione: imposti una "token threshold" (soglia di token) sulle tue richieste ordinarie e l'API riassume il contesto meno recente durante una richiesta, una volta raggiunta la soglia. È supportata insieme alla compattazione su richiesta, in cui sei tu a decidere quando viene scritto il riepilogo (consulta [Compattazione su richiesta](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand)). Per scegliere tra le due, consulta [Scegli come compattare](https://platform.claude.com/docs/it/build-with-claude/compaction#choose-how-to-compact). La compattazione estende la lunghezza effettiva del contesto per conversazioni e attività di lunga durata, riassumendo automaticamente il contesto meno recente quando ci si avvicina al limite della "context window" (finestra di contesto). Mantiene inoltre ridotto il contesto attivo: man mano che una conversazione cresce, la qualità delle risposte peggiora, quindi la compattazione sostituisce il contenuto meno recente con un riepilogo conciso. Per un approfondimento sul perché i contesti lunghi peggiorano e su come la compattazione aiuta, consulta [Effective context engineering](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents). È ideale per: * Conversazioni multi-turno basate su chat in cui vuoi che gli utenti usino una sola chat per un lungo periodo di tempo * Prompt orientati alle attività che richiedono molto lavoro successivo (spesso uso degli strumenti) che potrebbe superare la finestra di contesto ## Come funziona la compattazione Quando la compattazione è abilitata, Claude riassume automaticamente la tua conversazione quando raggiunge la soglia di token configurata. L'API: 1. Rileva quando i token di input raggiungono la soglia di attivazione specificata. 2. Genera un riepilogo della conversazione corrente. 3. Crea un blocco `compaction` contenente il riepilogo. 4. Continua la risposta con il contesto compattato. Nelle richieste successive, aggiungi la risposta ai tuoi messaggi. L'API elimina automaticamente tutti i blocchi di contenuto precedenti al blocco `compaction`, continuando la conversazione a partire dal riepilogo. ![Compaction flow (flusso di compattazione): quando gli input tokens (token di input) raggiungono il trigger, Claude scrive un riepilogo in un compaction block (blocco di compattazione) e prosegue](https://platform.claude.com/docs/it/images/compaction-flow.svg) ## Utilizzo di base Abilita la compattazione aggiungendo la strategia `compact_20260112` a `context_management.edits` nella tua richiesta alla Messages API. ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Help me build a website" } ], "context_management": { "edits": [ { "type": "compact_20260112" } ] } }' ``` ```bash CLI ant beta:messages create --beta compact-2026-01-12 <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Help me build a website context_management: edits: - type: compact_20260112 YAML ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Help me build a website"}] response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={"edits": [{"type": "compact_20260112"}]}, ) # Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione messages.append({"role": "assistant", "content": response.content}) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Help me build a website" } ]; const response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112" } ] } }); // Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione messages.push({ role: "assistant", content: response.content }); ``` ```csharp C# AnthropicClient client = new(); var messages = new List { new() { Role = Role.User, Content = "Help me build a website" } }; var parameters = new MessageCreateParams { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }; var response = await client.Beta.Messages.Create(parameters); // Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione messages.Add(new BetaMessageParam { Role = Role.Assistant, Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList() }); Console.WriteLine(response); ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{ anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Help me build a website")), } response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } // Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione messages = append(messages, response.ToParam()) fmt.Println(response) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addUserMessage("Help me build a website") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); // Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione // includendola nei messaggi della richiesta successiva System.out.println(response); ``` ```php PHP $client = new Client(); $messages = [ ['role' => 'user', 'content' => 'Help me build a website'] ]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ ['type' => 'compact_20260112'] ] ] ); // Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione $messages[] = ['role' => 'assistant', 'content' => $response->content]; echo json_encode($response, JSON_PRETTY_PRINT), PHP_EOL; ``` ```ruby Ruby client = Anthropic::Client.new messages = [ { role: "user", content: "Help me build a website" } ] response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [{ type: "compact_20260112" }] } ) # Aggiungi la risposta (incluso l'eventuale blocco di compattazione) per continuare la conversazione messages << { role: "assistant", content: response.content } puts response ``` ## Parametri | Parametro | Tipo | Predefinito | Descrizione | | ------------------------ | ------- | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | | `type` | string | Obbligatorio | Deve essere `"compact_20260112"` | | `trigger` | object | `{"type": "input_tokens", "value": 150000}` | Quando attivare la compattazione. `input_tokens` è l'unico tipo di trigger supportato. `value` deve essere di almeno 50.000 token. | | `pause_after_compaction` | boolean | `false` | Se mettere in pausa dopo aver generato il riepilogo di compattazione | | `instructions` | string | `null` | Prompt di riepilogo personalizzato. Quando fornito, sostituisce completamente il prompt predefinito. | ### Configurazione del trigger Configura quando si attiva la compattazione usando il parametro `trigger`: ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112", "trigger": { "type": "input_tokens", "value": 150000 } } ] } }' ``` ```bash CLI ant beta:messages create --beta compact-2026-01-12 <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 trigger: type: input_tokens value: 150000 YAML ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={ "edits": [ { "type": "compact_20260112", "trigger": {"type": "input_tokens", "value": 150000}, } ] }, ) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Hello, Claude" } ]; const response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: 150000 } } ] } }); ``` ```csharp C# AnthropicClient client = new(); List messages = [new() { Role = Role.User, Content = "Hello" }]; var parameters = new MessageCreateParams { Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Betas = ["compact-2026-01-12"], Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit { Trigger = new BetaInputTokensTrigger(150000) }] } }; var message = await client.Beta.Messages.Create(parameters); Console.WriteLine(message); ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))} response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{ Trigger: anthropic.BetaInputTokensTriggerParam{Value: 150000}, }}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } fmt.Println(response) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; import com.anthropic.models.beta.messages.BetaInputTokensTrigger; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addBeta("compact-2026-01-12") .addUserMessage("Hello, Claude") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder() .trigger(BetaInputTokensTrigger.builder() .value(150000L) .build()) .build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); System.out.println(response); ``` ```php PHP $client = new Client(); $messages = [['role' => 'user', 'content' => 'Hello, Claude']]; $message = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ [ 'type' => 'compact_20260112', 'trigger' => [ 'type' => 'input_tokens', 'value' => 150000 ] ] ] ] ); echo $message; ``` ```ruby Ruby client = Anthropic::Client.new messages = [{ role: "user", content: "Hello, Claude" }] response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: 150000 } } ] } ) puts response ``` ### Istruzioni di riepilogo personalizzate Il prompt di riepilogo predefinito varia in base al modello. Ogni prompt predefinito indica a Claude di scrivere un riepilogo all'interno dei tag `

` con le informazioni necessarie per continuare l'attività in una futura finestra di contesto. Ad esempio, alcuni modelli usano il seguente prompt: ```text wrap 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. ``` Puoi fornire istruzioni personalizzate tramite il parametro `instructions`. Le istruzioni personalizzate non integrano il prompt predefinito, ma lo sostituiscono completamente: ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112", "instructions": "Focus on preserving code snippets, variable names, and technical decisions." } ] } }' ``` ```bash CLI ant beta:messages create --beta compact-2026-01-12 <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 instructions: >- Focus on preserving code snippets, variable names, and technical decisions. YAML ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={ "edits": [ { "type": "compact_20260112", "instructions": "Focus on preserving code snippets, variable names, and technical decisions.", } ] }, ) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Hello, Claude" } ]; const response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112", instructions: "Focus on preserving code snippets, variable names, and technical decisions." } ] } }); ``` ```csharp C# AnthropicClient client = new(); var parameters = new MessageCreateParams { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = [ new BetaMessageParam { Role = Role.User, Content = "Help me build a Python web scraper" }, new BetaMessageParam { Role = Role.Assistant, Content = "I'll help you build a web scraper..." }, new BetaMessageParam { Role = Role.User, Content = "Add support for JavaScript-rendered pages" } ], ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit { Instructions = "Focus on preserving code snippets, variable names, and technical decisions." }] } }; var message = await client.Beta.Messages.Create(parameters); Console.WriteLine(message); ``` ```go Go client := anthropic.NewClient() response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: []anthropic.BetaMessageParam{ anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Help me build a Python web scraper")), {Role: anthropic.BetaMessageParamRoleAssistant, Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("I'll help you build a web scraper...")}}, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Add support for JavaScript-rendered pages")), }, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{ Instructions: anthropic.String("Focus on preserving code snippets, variable names, and technical decisions."), }}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } fmt.Println(response) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addUserMessage("Help me build a Python web scraper") .addAssistantMessage("I'll help you build a web scraper...") .addUserMessage("Add support for JavaScript-rendered pages") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder() .instructions("Focus on preserving code snippets, variable names, and technical decisions.") .build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); System.out.println(response); ``` ```php PHP $client = new Client(); $response = $client->beta->messages->create( maxTokens: 4096, messages: [ ['role' => 'user', 'content' => 'Help me build a Python web scraper'], ['role' => 'assistant', 'content' => "I'll help you build a web scraper..."], ['role' => 'user', 'content' => 'Add support for JavaScript-rendered pages'] ], model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ [ 'type' => 'compact_20260112', 'instructions' => 'Focus on preserving code snippets, variable names, and technical decisions.' ] ] ] ); echo json_encode($response, JSON_PRETTY_PRINT), PHP_EOL; ``` ```ruby Ruby client = Anthropic::Client.new response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: [ { role: "user", content: "Help me build a Python web scraper" }, { role: "assistant", content: "I'll help you build a web scraper..." }, { role: "user", content: "Add support for JavaScript-rendered pages" } ], context_management: { edits: [ { type: "compact_20260112", instructions: "Focus on preserving code snippets, variable names, and technical decisions." } ] } ) puts response ``` Sui modelli Claude 5.1 e successivi, una richiesta con `instructions` personalizzate genera il riepilogo solo a partire dalla conversazione visibile: i blocchi di ragionamento precedenti non fanno parte dell'input del processo di riepilogo. ### Pausa dopo la compattazione Usa `pause_after_compaction` per mettere in pausa l'API dopo la generazione del riepilogo di compattazione. Questo ti consente di aggiungere ulteriori blocchi di contenuto (ad esempio per preservare i messaggi recenti o specifici messaggi orientati alle istruzioni) prima che l'API continui con la risposta. Quando è abilitato, l'API restituisce un messaggio con lo stop reason `compaction` dopo aver generato il blocco di compattazione: ```bash cURL # pause_after_compaction interrompe la risposta subito dopo il riepilogo # di compattazione, così puoi modificare i messaggi prima di continuare. Il passo # di continuazione non si adatta bene a un singolo comando shell; vedi le schede SDK # per il flusso completo di pausa e ripresa. Singola richiesta in pausa: curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112", "pause_after_compaction": true } ] } }' ``` ```bash CLI # pause_after_compaction interrompe la risposta subito dopo il riepilogo # di compattazione, così puoi modificare i messaggi prima di continuare. Il passo # di continuazione non si adatta bene a un singolo comando CLI; vedi le schede SDK # per il flusso completo di pausa e ripresa. Singola richiesta in pausa: ant beta:messages create --beta compact-2026-01-12 --format jsonl <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 pause_after_compaction: true YAML ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={ "edits": [{"type": "compact_20260112", "pause_after_compaction": True}] }, ) # Verifica se la compattazione ha attivato una pausa if response.stop_reason == "compaction": # La risposta contiene solo il blocco di compattazione messages.append({"role": "assistant", "content": response.content}) # Continua la richiesta response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={"edits": [{"type": "compact_20260112"}]}, ) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Hello, Claude" } ]; let response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112", pause_after_compaction: true } ] } }); // Verifica se la compattazione ha attivato una pausa if (response.stop_reason === "compaction") { // La risposta contiene solo il blocco di compattazione messages.push({ role: "assistant", content: response.content }); // Continua la richiesta response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [{ type: "compact_20260112" }] } }); } ``` ```csharp C# var client = new AnthropicClient(); var messages = new List { new() { Role = Role.User, Content = "Hello, Claude" } }; var parameters = new MessageCreateParams { Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Betas = ["compact-2026-01-12"], Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit { PauseAfterCompaction = true }] } }; var response = await client.Beta.Messages.Create(parameters); if (response.StopReason == BetaStopReason.Compaction) { messages.Add(new BetaMessageParam { Role = Role.Assistant, Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList() }); parameters = new() { Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Betas = ["compact-2026-01-12"], Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }; response = await client.Beta.Messages.Create(parameters); } Console.WriteLine(response); ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))} compactEdit := anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{ PauseAfterCompaction: anthropic.Bool(true), }}, }, } response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: compactEdit, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } if response.StopReason == "compaction" { messages = append(messages, response.ToParam()) response, err = client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } } fmt.Println(response) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; import com.anthropic.models.beta.messages.BetaStopReason; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addBeta("compact-2026-01-12") .addUserMessage("Help me build a website") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder() .pauseAfterCompaction(true) .build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); // Verifica se la compattazione ha causato una pausa if (response.stopReason().isPresent() && response.stopReason().get().equals(BetaStopReason.COMPACTION)) { // Aggiungi il blocco di compattazione e prosegui la richiesta // creando una nuova richiesta con il contesto compattato MessageCreateParams continueParams = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addBeta("compact-2026-01-12") .addUserMessage("Help me build a website") .addMessage(response) .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build(); response = client.beta().messages().create(continueParams); } System.out.println(response); ``` ```php PHP $client = new Client(); $messages = [['role' => 'user', 'content' => 'Hello, Claude']]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ [ 'type' => 'compact_20260112', 'pause_after_compaction' => true ] ] ] ); if ($response->stopReason === 'compaction') { $messages[] = [ 'role' => 'assistant', 'content' => $response->content ]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ ['type' => 'compact_20260112'] ] ] ); } echo $response; ``` ```ruby Ruby client = Anthropic::Client.new messages = [{ role: "user", content: "Hello, Claude" }] response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [ { type: "compact_20260112", pause_after_compaction: true } ] } ) if response.stop_reason == :compaction messages << { role: "assistant", content: response.content } response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [{ type: "compact_20260112" }] } ) end puts response ``` #### Applicare un budget totale di token Quando un modello lavora su attività lunghe con molte iterazioni di uso degli strumenti, il consumo totale di token può crescere in modo significativo. Puoi combinare `pause_after_compaction` con un contatore di compattazioni per stimare l'utilizzo cumulativo e concludere l'attività in modo ordinato una volta raggiunto un budget. Questo esempio è disponibile solo nei linguaggi degli SDK: il suo valore risiede nella logica di monitoraggio del budget attorno alla richiesta. La richiesta grezza combina il `trigger` di [Configurazione del trigger](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#trigger-configuration) con `pause_after_compaction` di [Pausa dopo la compattazione](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#pausing-after-compaction). ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] TRIGGER_THRESHOLD = 100_000 TOTAL_TOKEN_BUDGET = 3_000_000 n_compactions = 0 response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={ "edits": [ { "type": "compact_20260112", "trigger": {"type": "input_tokens", "value": TRIGGER_THRESHOLD}, "pause_after_compaction": True, } ] }, ) if response.stop_reason == "compaction": n_compactions += 1 messages.append({"role": "assistant", "content": response.content}) # Stima i token totali consumati; sollecita la chiusura se si supera il budget if n_compactions * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET: messages.append( { "role": "user", "content": "Please wrap up your current work and summarize the final state.", } ) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Hello, Claude" } ]; const TRIGGER_THRESHOLD = 100_000; const TOTAL_TOKEN_BUDGET = 3_000_000; let compactionCount = 0; const response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: TRIGGER_THRESHOLD }, pause_after_compaction: true } ] } }); if (response.stop_reason === "compaction") { compactionCount += 1; messages.push({ role: "assistant", content: response.content }); // Stima i token totali consumati; chiedi di concludere se si supera il budget if (compactionCount * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET) { messages.push({ role: "user", content: "Please wrap up your current work and summarize the final state." }); } } ``` ```csharp C# AnthropicClient client = new(); List messages = [new() { Role = Role.User, Content = "Hello, Claude" }]; const int TriggerThreshold = 100_000; const int TotalTokenBudget = 3_000_000; int compactionCount = 0; var response = await client.Beta.Messages.Create(new() { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit { Trigger = new BetaInputTokensTrigger(TriggerThreshold), PauseAfterCompaction = true }] } }); if (response.StopReason == BetaStopReason.Compaction) { compactionCount += 1; messages.Add(new() { Role = Role.Assistant, Content = response.Content.Select(b => new BetaContentBlockParam(b.Json)).ToList() }); // Stima i token totali consumati; sollecita la chiusura se si supera il budget if (compactionCount * TriggerThreshold >= TotalTokenBudget) { messages.Add(new() { Role = Role.User, Content = "Please wrap up your current work and summarize the final state." }); } } Console.WriteLine(response); ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))} const triggerThreshold = 100_000 const totalTokenBudget = 3_000_000 compactionCount := 0 response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{ Trigger: anthropic.BetaInputTokensTriggerParam{Value: triggerThreshold}, PauseAfterCompaction: anthropic.Bool(true), }}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } if response.StopReason == "compaction" { compactionCount++ messages = append(messages, response.ToParam()) // Stima i token totali consumati; chiedi di concludere se si supera il budget if compactionCount*triggerThreshold >= totalTokenBudget { messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Please wrap up your current work and summarize the final state."))) } } fmt.Println(response) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; import com.anthropic.models.beta.messages.BetaInputTokensTrigger; import com.anthropic.models.beta.messages.BetaStopReason; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); long triggerThreshold = 100_000; long totalTokenBudget = 3_000_000; int compactionCount = 0; List messages = new ArrayList<>(); messages.add(BetaMessageParam.builder() .role(BetaMessageParam.Role.USER) .content("Hello, Claude") .build()); MessageCreateParams params = MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .messages(messages) .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder() .trigger(BetaInputTokensTrigger.builder() .value(triggerThreshold) .build()) .pauseAfterCompaction(true) .build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); if (response.stopReason().isPresent() && response.stopReason().get().equals(BetaStopReason.COMPACTION)) { compactionCount += 1; messages.add(response.toParam()); // Stima i token totali consumati; sollecita la chiusura se si supera il budget if (compactionCount * triggerThreshold >= totalTokenBudget) { messages.add(BetaMessageParam.builder() .role(BetaMessageParam.Role.USER) .content("Please wrap up your current work and summarize the final state.") .build()); } } System.out.println(response); ``` ```php PHP $client = new Client(); $triggerThreshold = 100_000; $totalTokenBudget = 3_000_000; $compactionCount = 0; $messages = [['role' => 'user', 'content' => 'Hello, Claude']]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ [ 'type' => 'compact_20260112', 'trigger' => ['type' => 'input_tokens', 'value' => $triggerThreshold], 'pause_after_compaction' => true ] ] ] ); if ($response->stopReason === 'compaction') { $compactionCount += 1; $messages[] = ['role' => 'assistant', 'content' => $response->content]; // Stima i token totali consumati; sollecita la chiusura se oltre il budget if ($compactionCount * $triggerThreshold >= $totalTokenBudget) { $messages[] = [ 'role' => 'user', 'content' => 'Please wrap up your current work and summarize the final state.' ]; } } ``` ```ruby Ruby client = Anthropic::Client.new messages = [{ role: "user", content: "Hello, Claude" }] TRIGGER_THRESHOLD = 100_000 TOTAL_TOKEN_BUDGET = 3_000_000 compaction_count = 0 response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: TRIGGER_THRESHOLD }, pause_after_compaction: true } ] } ) if response.stop_reason == :compaction compaction_count += 1 messages << { role: "assistant", content: response.content } # Stima i token totali consumati; sollecita la chiusura se si supera il budget if compaction_count * TRIGGER_THRESHOLD >= TOTAL_TOKEN_BUDGET messages << { role: "user", content: "Please wrap up your current work and summarize the final state." } end end ``` ## Lavorare con i blocchi di compattazione Quando viene attivata la compattazione, l'API restituisce un blocco `compaction` all'inizio della risposta dell'assistente. Una conversazione di lunga durata potrebbe dare luogo a più compattazioni. L'ultimo blocco di compattazione riflette lo stato finale del prompt, sostituendo il contenuto che lo precede con il riepilogo generato. ```json Output { "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..." } ] } ``` ### Restituire i blocchi di compattazione Devi restituire il blocco `compaction` all'API nelle richieste successive per continuare la conversazione con il prompt abbreviato. L'approccio più semplice è aggiungere l'intero contenuto della risposta ai tuoi messaggi: ```bash cURL # Il contenuto della risposta, incluso il blocco di compattazione, deve tornare all' # API come turno dell'assistente della richiesta successiva. Gestire quell'elenco di messaggi # non si adatta bene a un singolo comando shell; consulta le schede CLI e SDK # per il flusso completo. Prima richiesta: curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112" } ] } }' ``` ```bash CLI ant beta:messages create \ --beta compact-2026-01-12 \ --transform content \ --format jsonl <<'YAML' > content.json model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 YAML # Dopo aver ricevuto una risposta con un blocco di compattazione, aggiungila come # turno dell'assistente e continua la conversazione ant beta:messages create --beta compact-2026-01-12 < { new() { Role = Role.User, Content = "Help me build a web scraper" } }; var response = await client.Beta.Messages.Create(new() { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }); messages.Add(new BetaMessageParam { Role = Role.Assistant, Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList() }); messages.Add(new BetaMessageParam { Role = Role.User, Content = "Now add error handling" }); var nextResponse = await client.Beta.Messages.Create(new() { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }); Console.WriteLine(nextResponse); ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{ anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Help me build a web scraper")), } compactEdit := anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, } response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: compactEdit, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } messages = append(messages, response.ToParam()) messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Now add error handling"))) nextResponse, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: compactEdit, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } fmt.Println(nextResponse) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); // Prima richiesta BetaMessage response = client.beta().messages().create( MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addUserMessage("Help me build a web scraper") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build()); // Dopo aver ricevuto una risposta con un blocco di compattazione, aggiungi l'intero // contenuto (inclusi i blocchi di compattazione) e continua la conversazione BetaMessage nextResponse = client.beta().messages().create( MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addUserMessage("Help me build a web scraper") .addMessage(response) .addUserMessage("Now add error handling") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build()); System.out.println(nextResponse); ``` ```php PHP $client = new Client(); $messages = [ ['role' => 'user', 'content' => 'Help me build a web scraper'] ]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [['type' => 'compact_20260112']] ] ); $messages[] = ['role' => 'assistant', 'content' => $response->content]; $messages[] = ['role' => 'user', 'content' => 'Now add error handling']; $nextResponse = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [['type' => 'compact_20260112']] ] ); echo json_encode($nextResponse, JSON_PRETTY_PRINT), PHP_EOL; ``` ```ruby Ruby client = Anthropic::Client.new messages = [ { role: "user", content: "Help me build a web scraper" } ] response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [{ type: "compact_20260112" }] } ) messages << { role: "assistant", content: response.content } messages << { role: "user", content: "Now add error handling" } next_response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [{ type: "compact_20260112" }] } ) puts next_response.content ``` In Python, usa `client.beta.messages`, come fanno gli esempi in questa pagina. Se chiami `client.messages` e serializzi i blocchi autonomamente, un semplice `model_dump()` aggiunge `text: null` e `citations: null` al blocco `compaction`. L'API rifiuta quindi la richiesta con un errore 400 (`Extra inputs are not permitted`). Usa invece `to_dict()` o `model_dump(exclude_none=True)`. [Continua dal riepilogo](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand#continue-from-the-summary) fornisce lo stesso consiglio per la compattazione su richiesta. Quando l'API riceve un blocco `compaction`, tutti i blocchi di contenuto che lo precedono vengono ignorati. Puoi: * Mantenere i messaggi originali nella tua lista e lasciare che sia l'API a gestire la rimozione del contenuto compattato * Eliminare manualmente i messaggi compattati e includere solo i contenuti a partire dal blocco di compattazione Su Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Sonnet 5.5 e Claude Haiku 5.5, i blocchi di ragionamento precedenti a un blocco `compaction` non vengono riportati, quindi il riepilogo è tutto ciò che il modello conserva di quel lavoro precedente. Se scrivi le tue `instructions`, indica al modello cosa deve conservare il riepilogo; consulta [Indica al modello cosa preservare nei riepiloghi di compattazione](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#tell-the-model-what-to-preserve-in-compaction-summaries). ### Streaming Il blocco di compattazione viene trasmesso in streaming in modo diverso rispetto ai blocchi di testo. Ricevi un evento `content_block_start`, seguito da un singolo `content_block_delta` con il contenuto completo del riepilogo (senza streaming intermedio), e poi un evento `content_block_stop`. ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "stream": true, "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112" } ] } }' ``` ```bash CLI ant beta:messages create \ --stream \ --beta compact-2026-01-12 \ --format jsonl <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 YAML ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] with client.beta.messages.stream( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={"edits": [{"type": "compact_20260112"}]}, ) as stream: for event in stream: match event.type: case "content_block_start": block = event.content_block match block.type: case "compaction": print("Compaction started...") case "text": print("Text response started...") case "content_block_delta": delta = event.delta match delta.type: case "compaction_delta": print(f"Compaction complete: {len(delta.content or '')} chars") case "text_delta": print(delta.text, end="", flush=True) # Ottieni il messaggio finale accumulato message = stream.get_final_message() messages.append({"role": "assistant", "content": message.content}) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Hello, Claude" } ]; const stream = await client.beta.messages.stream({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [{ type: "compact_20260112" }] } }); for await (const event of stream) { switch (event.type) { case "content_block_start": switch (event.content_block.type) { case "compaction": console.log("Compaction started..."); break; case "text": console.log("Text response started..."); break; } break; case "content_block_delta": switch (event.delta.type) { case "compaction_delta": console.log(`Compaction complete: ${event.delta.content?.length ?? 0} chars`); break; case "text_delta": process.stdout.write(event.delta.text); break; } break; } } // Ottieni il messaggio finale accumulato const message = await stream.finalMessage(); messages.push({ role: "assistant", content: message.content }); ``` ```csharp C# var client = new AnthropicClient(); List messages = [new() { Role = Role.User, Content = "Hello" }]; var parameters = new MessageCreateParams { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }; await foreach (var streamEvent in client.Beta.Messages.CreateStreaming(parameters)) { if (streamEvent.TryPickContentBlockStart(out var startEvent)) { if (startEvent.ContentBlock.TryPickBetaCompaction(out _)) { Console.WriteLine("Compaction started..."); } else if (startEvent.ContentBlock.TryPickBetaText(out _)) { Console.WriteLine("Text response started..."); } } else if (streamEvent.TryPickContentBlockDelta(out var deltaEvent)) { if (deltaEvent.Delta.TryPickCompaction(out var compactionDelta)) { Console.WriteLine($"Compaction complete: {compactionDelta.Content?.Length ?? 0} chars"); } else if (deltaEvent.Delta.TryPickText(out var textDelta)) { Console.Write(textDelta.Text); } } } ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))} stream := client.Beta.Messages.NewStreaming(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) for stream.Next() { event := stream.Current() switch eventVariant := event.AsAny().(type) { case anthropic.BetaRawContentBlockStartEvent: switch eventVariant.ContentBlock.AsAny().(type) { case anthropic.BetaCompactionBlock: fmt.Println("Compaction started...") case anthropic.BetaTextBlock: fmt.Println("Text response started...") } case anthropic.BetaRawContentBlockDeltaEvent: switch deltaVariant := eventVariant.Delta.AsAny().(type) { case anthropic.BetaCompactionContentBlockDelta: fmt.Printf("Compaction complete: %d chars\n", len(deltaVariant.Content)) case anthropic.BetaTextDelta: fmt.Print(deltaVariant.Text) } } } if err := stream.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addBeta("compact-2026-01-12") .addUserMessage("Hello, Claude") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build(); try (var streamResponse = client.beta().messages().createStreaming(params)) { streamResponse.stream().forEach(event -> { event.contentBlockStart().ifPresent(startEvent -> { startEvent.contentBlock().compaction().ifPresent(c -> System.out.println("Compaction started...") ); startEvent.contentBlock().text().ifPresent(t -> System.out.println("Text response started...") ); }); event.contentBlockDelta().ifPresent(deltaEvent -> { deltaEvent.delta().compaction().ifPresent(cd -> System.out.println("Compaction complete: " + cd.content().map(String::length).orElse(0) + " chars") ); deltaEvent.delta().text().ifPresent(td -> System.out.print(td.text()) ); }); }); } ``` ```php PHP use Anthropic\Beta\Messages\BetaCompactionBlock; use Anthropic\Beta\Messages\BetaCompactionContentBlockDelta; use Anthropic\Beta\Messages\BetaRawContentBlockDeltaEvent; use Anthropic\Beta\Messages\BetaRawContentBlockStartEvent; use Anthropic\Beta\Messages\BetaTextBlock; use Anthropic\Beta\Messages\BetaTextDelta; $client = new Client(); $messages = [['role' => 'user', 'content' => 'Hello, Claude']]; $stream = $client->beta->messages->createStream( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ ['type' => 'compact_20260112'] ] ] ); foreach ($stream as $event) { switch (true) { case $event instanceof BetaRawContentBlockStartEvent: switch (true) { case $event->contentBlock instanceof BetaCompactionBlock: echo "Compaction started...\n"; break; case $event->contentBlock instanceof BetaTextBlock: echo "Text response started...\n"; break; } break; case $event instanceof BetaRawContentBlockDeltaEvent: switch (true) { case $event->delta instanceof BetaCompactionContentBlockDelta: echo "Compaction complete: " . strlen($event->delta->content ?? '') . " chars\n"; break; case $event->delta instanceof BetaTextDelta: echo $event->delta->text; break; } break; } } ``` ```ruby Ruby client = Anthropic::Client.new messages = [{ role: "user", content: "Hello, Claude" }] stream = client.beta.messages.stream( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [{ type: "compact_20260112" }] } ) stream.each do |event| case event when Anthropic::Models::BetaRawContentBlockStartEvent case event.content_block when Anthropic::Models::BetaCompactionBlock puts "Compaction started..." when Anthropic::Models::BetaTextBlock puts "Text response started..." end when Anthropic::Models::BetaRawContentBlockDeltaEvent delta = event.delta case delta when Anthropic::Models::BetaCompactionContentBlockDelta puts "Compaction complete: #{(delta.content || "").length} chars" when Anthropic::Models::BetaTextDelta print delta.text end end end ``` ### Cache dei prompt La compattazione funziona bene con il "prompt caching" ([cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching)). Puoi aggiungere un breakpoint `cache_control` sui blocchi di compattazione per memorizzare nella cache il contenuto riepilogato. ```json { "role": "assistant", "content": [ { "type": "compaction", "content": "[summary text]", "cache_control": { "type": "ephemeral" } }, { "type": "text", "text": "Based on our conversation..." } ] } ``` #### Massimizzare i cache hit con i prompt di sistema Quando avviene una compattazione, il riepilogo diventa nuovo contenuto che deve essere scritto nella cache. Senza breakpoint di cache aggiuntivi, questo invaliderebbe anche qualsiasi "system prompt" (prompt di sistema) memorizzato nella cache, richiedendo di memorizzarlo nuovamente insieme al riepilogo di compattazione. Per massimizzare il tasso di cache hit, aggiungi un breakpoint `cache_control` alla fine del tuo prompt di sistema. In questo modo il prompt di sistema resta memorizzato nella cache separatamente dalla conversazione, quindi quando avviene una compattazione: * La cache del prompt di sistema rimane valida e viene letta dalla cache * Solo il riepilogo di compattazione deve essere scritto come nuova voce della cache ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "system": [ { "type": "text", "text": "You are a helpful coding assistant...", "cache_control": { "type": "ephemeral" } } ], "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112" } ] } }' ``` ```bash CLI ant beta:messages create --beta compact-2026-01-12 <<'YAML' model: claude-opus-5-5 max_tokens: 4096 system: - type: text text: You are a helpful coding assistant... cache_control: type: ephemeral messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 YAML ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, system=[ { "type": "text", "text": "You are a helpful coding assistant...", "cache_control": { "type": "ephemeral" }, # Cache the system prompt separately } ], messages=messages, context_management={"edits": [{"type": "compact_20260112"}]}, ) ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Hello, Claude" } ]; const response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, system: [ { type: "text", text: "You are a helpful coding assistant...", cache_control: { type: "ephemeral" } // Cache the system prompt separately } ], messages, context_management: { edits: [{ type: "compact_20260112" }] } }); ``` ```csharp C# var client = new AnthropicClient(); var parameters = new MessageCreateParams { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, System = new List { new() { Text = "You are a helpful coding assistant...", CacheControl = new BetaCacheControlEphemeral() } }, Messages = [new() { Role = Role.User, Content = "Hello, Claude" }], ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }; var response = await client.Beta.Messages.Create(parameters); Console.WriteLine(response); ``` ```go Go client := anthropic.NewClient() response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, System: []anthropic.BetaTextBlockParam{ { Text: "You are a helpful coding assistant...", CacheControl: anthropic.NewBetaCacheControlEphemeralParam(), }, }, Messages: []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))}, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } fmt.Println(response) ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; import com.anthropic.models.beta.messages.BetaCacheControlEphemeral; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .addBeta("compact-2026-01-12") .systemOfBetaTextBlockParams(List.of( BetaTextBlockParam.builder() .text("You are a helpful coding assistant...") .cacheControl(BetaCacheControlEphemeral.builder().build()) .build() )) .addUserMessage("Hello, Claude") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); System.out.println(response); ``` ```php PHP $client = new Client(); $response = $client->beta->messages->create( maxTokens: 4096, messages: [['role' => 'user', 'content' => 'Hello, Claude']], model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], system: [ [ 'type' => 'text', 'text' => 'You are a helpful coding assistant...', 'cache_control' => [ 'type' => 'ephemeral' ] ] ], contextManagement: [ 'edits' => [ ['type' => 'compact_20260112'] ] ] ); echo json_encode($response, JSON_PRETTY_PRINT), PHP_EOL; ``` ```ruby Ruby client = Anthropic::Client.new response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, system: [ { type: "text", text: "You are a helpful coding assistant...", cache_control: { type: "ephemeral" } } ], messages: [{ role: "user", content: "Hello, Claude" }], context_management: { edits: [{ type: "compact_20260112" }] } ) puts response ``` In questo modo i prompt di sistema lunghi restano memorizzati nella cache attraverso più eventi di compattazione nel corso di una conversazione. ## Comprendere l'utilizzo La compattazione richiede un passaggio di campionamento aggiuntivo, che incide sui "rate limit" (limiti di velocità) e sulla fatturazione. L'API restituisce informazioni dettagliate sull'utilizzo nella risposta: ```json Output { "usage": { "input_tokens": 23000, "output_tokens": 1000, "iterations": [ { "type": "compaction", "input_tokens": 180000, "output_tokens": 3500 }, { "type": "message", "input_tokens": 23000, "output_tokens": 1000 } ] } } ``` L'array `iterations` mostra l'utilizzo per ogni iterazione di campionamento. Quando avviene una compattazione, vedrai un'iterazione `compaction` seguita dall'iterazione principale `message`. In questo esempio, i valori di primo livello `input_tokens` e `output_tokens` corrispondono esattamente all'iterazione `message` perché c'è una sola iterazione non di compattazione. I conteggi dei token dell'iterazione finale riflettono la dimensione effettiva del contesto dopo la compattazione. I valori di primo livello `input_tokens` e `output_tokens` non includono l'utilizzo dell'iterazione di compattazione. Riflettono la somma di tutte le iterazioni non di compattazione. Per calcolare il totale dei token consumati e fatturati per una richiesta, somma tutte le voci dell'array `usage.iterations`. Se in precedenza ti affidavi a `usage.input_tokens` e `usage.output_tokens` per il monitoraggio dei costi o per l'auditing, dovrai aggiornare la tua logica di monitoraggio per aggregare i valori di `usage.iterations` quando la compattazione è abilitata. Con la beta della compattazione abilitata, ogni risposta include `usage.iterations`, anche se non è avvenuta alcuna compattazione. Una voce `compaction` compare solo quando viene attivata una nuova compattazione durante la richiesta. La riapplicazione di un blocco `compaction` precedente non comporta costi di compattazione aggiuntivi e, in quel caso, i campi di utilizzo di primo livello restano accurati. ## Combinazione con altre funzionalità ### Strumenti server Quando usi strumenti server (come la ricerca web), il trigger di compattazione viene verificato all'inizio di ogni iterazione di campionamento. La compattazione potrebbe avvenire più volte all'interno di una singola richiesta, a seconda della soglia di attivazione e della quantità di output generato. ### Conteggio dei token L'endpoint di conteggio dei token (`/v1/messages/count_tokens`) applica i blocchi `compaction` esistenti nel tuo prompt, ma non attiva nuove compattazioni. Usalo per verificare il conteggio effettivo dei token dopo le compattazioni precedenti: ```bash cURL curl https://api.anthropic.com/v1/messages/count_tokens \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "messages": [ { "role": "user", "content": "Hello, Claude" } ], "context_management": { "edits": [ { "type": "compact_20260112" } ] } }' ``` ```bash CLI CURRENT=$(ant beta:messages count-tokens \ --beta compact-2026-01-12 \ --transform input_tokens \ --raw-output <<'YAML' model: claude-opus-5-5 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 YAML ) ORIGINAL=$(ant beta:messages count-tokens \ --beta compact-2026-01-12 \ --transform context_management.original_input_tokens \ --raw-output <<'YAML' model: claude-opus-5-5 messages: - role: user content: Hello, Claude context_management: edits: - type: compact_20260112 YAML ) printf 'Current tokens: %s\n' "$CURRENT" printf 'Original tokens: %s\n' "$ORIGINAL" ``` ```python Python client = anthropic.Anthropic() messages = [{"role": "user", "content": "Hello, Claude"}] count_response = client.beta.messages.count_tokens( betas=["compact-2026-01-12"], model="claude-opus-5-5", messages=messages, context_management={"edits": [{"type": "compact_20260112"}]}, ) print(f"Current tokens: {count_response.input_tokens}") print(f"Original tokens: {count_response.context_management.original_input_tokens}") ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "user", content: "Summarize the key points of our conversation so far." } ]; const countResponse = await client.beta.messages.countTokens({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", messages, context_management: { edits: [{ type: "compact_20260112" }] } }); console.log(`Current tokens: ${countResponse.input_tokens}`); console.log(`Original tokens: ${countResponse.context_management!.original_input_tokens}`); ``` ```csharp C# AnthropicClient client = new(); List messages = [new() { Role = Role.User, Content = "Hello" }]; var countParams = new MessageCountTokensParams { Model = Model.ClaudeOpus5_5, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] }, Betas = ["compact-2026-01-12"] }; var countResponse = await client.Beta.Messages.CountTokens(countParams); Console.WriteLine($"Current tokens: {countResponse.InputTokens}"); Console.WriteLine($"Original tokens: {countResponse.ContextManagement?.OriginalInputTokens}"); ``` ```go Go client := anthropic.NewClient() messages := []anthropic.BetaMessageParam{anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude"))} countResponse, err := client.Beta.Messages.CountTokens(context.TODO(), anthropic.BetaMessageCountTokensParams{ Model: anthropic.ModelClaudeOpus5_5, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } fmt.Printf("Current tokens: %d\n", countResponse.InputTokens) fmt.Printf("Original tokens: %d\n", countResponse.ContextManagement.OriginalInputTokens) ``` ```java Java import com.anthropic.models.beta.messages.BetaMessageTokensCount; import com.anthropic.models.beta.messages.MessageCountTokensParams; import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; // ... AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCountTokensParams params = MessageCountTokensParams.builder() .model(Model.CLAUDE_OPUS_5_5) .addUserMessage("Hello, Claude") .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .addBeta("compact-2026-01-12") .build(); BetaMessageTokensCount countResponse = client.beta().messages().countTokens(params); System.out.println("Current tokens: " + countResponse.inputTokens()); System.out.println("Original tokens: " + countResponse.contextManagement().get().originalInputTokens()); ``` ```php PHP $client = new Client(); $messages = [['role' => 'user', 'content' => 'Hello, Claude']]; $countResponse = $client->beta->messages->countTokens( messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ ['type' => 'compact_20260112'] ] ] ); echo "Current tokens: " . $countResponse->inputTokens . "\n"; echo "Original tokens: " . $countResponse->contextManagement->originalInputTokens . "\n"; ``` ```ruby Ruby client = Anthropic::Client.new messages = [{ role: "user", content: "Hello, Claude" }] count_response = client.beta.messages.count_tokens( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", messages: messages, context_management: { edits: [{ type: "compact_20260112" }] } ) puts "Current tokens: #{count_response.input_tokens}" puts "Original tokens: #{count_response.context_management.original_input_tokens}" ``` ## Esempi Ecco un esempio completo di una conversazione di lunga durata con compattazione: ```bash cURL # curl invia richieste singole; mantieni l'array messages nello # script chiamante. Vedi le schede SDK per il ciclo chat() completo. Struttura # della richiesta a turno singolo: curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Help me build a Python web scraper" } ], "context_management": { "edits": [ { "type": "compact_20260112", "trigger": { "type": "input_tokens", "value": 100000 } } ] } }' ``` ```bash CLI # La CLI gestisce i singoli turni; mantieni l'array dei messaggi nello # script chiamante. Vedi le schede SDK per il ciclo chat() completo. Forma # della richiesta a turno singolo: ant beta:messages create \ --beta compact-2026-01-12 \ --transform 'content.#(type=="text").text' \ --raw-output <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Help me build a Python web scraper context_management: edits: - type: compact_20260112 trigger: type: input_tokens value: 100000 YAML ``` ```python Python client = anthropic.Anthropic() messages: list[dict] = [] def chat(user_message: str) -> str: messages.append({"role": "user", "content": user_message}) response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={ "edits": [ { "type": "compact_20260112", "trigger": {"type": "input_tokens", "value": 100000}, } ] }, ) # Aggiungi la risposta (i blocchi di compattazione sono inclusi automaticamente) messages.append({"role": "assistant", "content": response.content}) # Restituisci il contenuto testuale return next(block.text for block in response.content if block.type == "text") # Esegui una conversazione lunga print(chat("Help me build a Python web scraper")) print(chat("Add support for JavaScript-rendered pages")) print(chat("Now add rate limiting and error handling")) # Continua a chiamare chat() finché la conversazione lo richiede ``` ```typescript TypeScript const client = new Anthropic(); const messages: Anthropic.Beta.Messages.BetaMessageParam[] = []; async function chat(userMessage: string): Promise { messages.push({ role: "user", content: userMessage }); const response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: 100000 } } ] } }); // Aggiungi la risposta (i blocchi di compattazione sono inclusi automaticamente) messages.push({ role: "assistant", content: response.content }); // Restituisci il contenuto testuale const textBlock = response.content.find((block) => block.type === "text"); return textBlock?.text ?? ""; } // Esegui una conversazione lunga console.log(await chat("Help me build a Python web scraper")); console.log(await chat("Add support for JavaScript-rendered pages")); console.log(await chat("Now add rate limiting and error handling")); // Continua a chiamare chat() finché la conversazione lo richiede ``` ```csharp C# AnthropicClient client = new(); List messages = new(); Console.WriteLine(await Chat(client, messages, "Help me build a Python web scraper")); Console.WriteLine(await Chat(client, messages, "Add support for JavaScript-rendered pages")); Console.WriteLine(await Chat(client, messages, "Now add rate limiting and error handling")); static async Task Chat(AnthropicClient client, List messages, string userMessage) { messages.Add(new() { Role = Role.User, Content = userMessage }); var parameters = new MessageCreateParams { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit { Trigger = new BetaInputTokensTrigger(100000) }] } }; var response = await client.Beta.Messages.Create(parameters); messages.Add(new() { Role = Role.Assistant, Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList() }); return response.Content .Select(block => block.Value) .OfType() .Select(tb => tb.Text) .FirstOrDefault() ?? ""; } ``` ```go Go package main import ( "context" "fmt" "log" "github.com/anthropics/anthropic-sdk-go" ) var ( client = anthropic.NewClient() messages []anthropic.BetaMessageParam ) func chat(userMessage string) string { messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(userMessage))) response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{ Trigger: anthropic.BetaInputTokensTriggerParam{Value: 100000}, }}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } messages = append(messages, response.ToParam()) for _, block := range response.Content { if variant, ok := block.AsAny().(anthropic.BetaTextBlock); ok { return variant.Text } } return "" } func main() { fmt.Println(chat("Help me build a Python web scraper")) fmt.Println(chat("Add support for JavaScript-rendered pages")) fmt.Println(chat("Now add rate limiting and error handling")) } ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; import com.anthropic.models.beta.messages.BetaInputTokensTrigger; // ... private static final AnthropicClient client = AnthropicOkHttpClient.fromEnv(); private static final List messages = new ArrayList<>(); public static void main(String[] args) { System.out.println(chat("Help me build a Python web scraper")); System.out.println(chat("Add support for JavaScript-rendered pages")); System.out.println(chat("Now add rate limiting and error handling")); } private static String chat(String userMessage) { messages.add(BetaMessageParam.builder() .role(BetaMessageParam.Role.USER) .content(userMessage) .build()); MessageCreateParams params = MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .messages(messages) .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder() .trigger(BetaInputTokensTrigger.builder() .value(100000L) .build()) .build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); // Aggiungi la risposta (i blocchi di compattazione sono inclusi automaticamente) messages.add(response.toParam()); return response.content().stream() .filter(block -> block.text().isPresent()) .map(block -> block.text().get().text()) .findFirst() .orElse(""); } ``` ```php PHP $client = new Client(); $messages = []; function chat($client, &$messages, $userMessage) { $messages[] = ['role' => 'user', 'content' => $userMessage]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ [ 'type' => 'compact_20260112', 'trigger' => ['type' => 'input_tokens', 'value' => 100000] ] ] ] ); $messages[] = ['role' => 'assistant', 'content' => $response->content]; foreach ($response->content as $block) { if ($block->type === 'text') { return $block->text; } } return ''; } echo chat($client, $messages, "Help me build a Python web scraper") . "\n"; echo chat($client, $messages, "Add support for JavaScript-rendered pages") . "\n"; echo chat($client, $messages, "Now add rate limiting and error handling") . "\n"; ``` ```ruby Ruby client = Anthropic::Client.new messages = [] def chat(client, messages, user_message) messages << { role: "user", content: user_message } response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: 100000 } } ] } ) messages << { role: "assistant", content: response.content } response.content.find { |block| block.type == :text }&.text || "" end puts chat(client, messages, "Help me build a Python web scraper") puts chat(client, messages, "Add support for JavaScript-rendered pages") puts chat(client, messages, "Now add rate limiting and error handling") ``` Su Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5 e Claude Haiku 5.5, rimuovi i blocchi `thinking` e `redacted_thinking` da qualsiasi turno dell'assistente che reinserisci dopo il blocco di compattazione, oppure invia `thinking.block_binding.prefix_mismatch_behavior: "drop_block"` con l'[header beta](https://platform.claude.com/docs/it/api/beta-headers) `thinking-binding-controls-2026-08-01`. Quei blocchi sono stati prodotti quando era presente l'intera cronologia, quindi non superano più il [controllo della conversazione](https://platform.claude.com/docs/it/build-with-claude/thinking#preserved-in-conversation). Dove il controllo viene applicato, la richiesta di continuazione viene rifiutata con un errore 400. I blocchi di testo e di strumenti preservati possono restare così come sono. Lasciare che l'API riassuma tutto, senza reinserire i turni precedenti, evita questo problema. Su Claude Sonnet 5.5, `block_binding` funziona solo con `thinking: {"type": "adaptive"}`. Con `between_tools`, rimuovi invece i blocchi. Su Claude Haiku 5.5, `block_binding` funziona solo con `thinking: {"type": "adaptive"}`, quindi con `thinking: {"type": "disabled"}` rimuovi invece i blocchi. Ecco un esempio che usa `pause_after_compaction` per preservare lo scambio precedente e il messaggio utente corrente (tre messaggi in totale) invece di riassumerli. Mantiene invariati i loro blocchi di testo e di strumenti, rimuove i blocchi `thinking` e `redacted_thinking` dal turno dell'assistente preservato ed elimina quel turno se non rimane nient'altro: ```bash cURL # curl invia richieste singole; mantieni l'array messages nello # script chiamante. Vedi le schede SDK per il ciclo chat() completo con # gestione di pausa e conservazione. Struttura di una richiesta a turno singolo: curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "anthropic-beta: compact-2026-01-12" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [ { "role": "user", "content": "Help me build a Python web scraper" } ], "context_management": { "edits": [ { "type": "compact_20260112", "trigger": { "type": "input_tokens", "value": 100000 }, "pause_after_compaction": true } ] } }' ``` ```bash CLI # La CLI gestisce i singoli turni; mantieni l'array dei messaggi nello # script chiamante. Vedi le schede SDK per il ciclo chat() completo con # gestione pause-and-preserve. Struttura di una richiesta a turno singolo: ant beta:messages create \ --beta compact-2026-01-12 \ --transform 'content.#(type=="text").text' \ --raw-output <<'YAML' model: claude-opus-5-5 max_tokens: 4096 messages: - role: user content: Help me build a Python web scraper context_management: edits: - type: compact_20260112 trigger: type: input_tokens value: 100000 pause_after_compaction: true YAML ``` ```python Python from typing import Any client = anthropic.Anthropic() messages: list[dict[str, Any]] = [] def chat(user_message: str) -> str: messages.append({"role": "user", "content": user_message}) response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages, context_management={ "edits": [ { "type": "compact_20260112", "trigger": {"type": "input_tokens", "value": 100000}, "pause_after_compaction": True, } ] }, ) # Verifica se la compattazione è avvenuta e si è messa in pausa if response.stop_reason == "compaction": # Ottieni il blocco di compattazione dalla risposta compaction_block = response.content[0] # Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi) # includendoli dopo il blocco di compattazione, senza i blocchi di ragionamento # ; un turno dell'assistente rimasto senza contenuto viene scartato preserved_messages = [ { **message, "content": [ block for block in message["content"] if block.type not in ("thinking", "redacted_thinking") ], } if message["role"] == "assistant" else message for message in messages[-3:] ] preserved_messages = [m for m in preserved_messages if m["content"]] # Crea la nuova lista di messaggi: compattazione + messaggi conservati new_assistant_content = [compaction_block] messages_after_compaction = [ {"role": "assistant", "content": new_assistant_content} ] + preserved_messages # Continua la richiesta con il contesto compattato + i messaggi conservati response = client.beta.messages.create( betas=["compact-2026-01-12"], model="claude-opus-5-5", max_tokens=4096, messages=messages_after_compaction, context_management={"edits": [{"type": "compact_20260112"}]}, ) # Aggiorna la lista di messaggi per riflettere la compattazione messages.clear() messages.extend(messages_after_compaction) # Aggiungi la risposta finale messages.append({"role": "assistant", "content": response.content}) # Restituisci il contenuto testuale return next(block.text for block in response.content if block.type == "text") # Esegui una conversazione lunga print(chat("Help me build a Python web scraper")) print(chat("Add support for JavaScript-rendered pages")) print(chat("Now add rate limiting and error handling")) # Continua a chiamare chat() finché la conversazione lo richiede ``` ```typescript TypeScript const client = new Anthropic(); let messages: Anthropic.Beta.Messages.BetaMessageParam[] = []; async function chat(userMessage: string): Promise { messages.push({ role: "user", content: userMessage }); let response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: 100000 }, pause_after_compaction: true } ] } }); // Verifica se la compattazione è avvenuta e si è messa in pausa if (response.stop_reason === "compaction") { // Ottieni il blocco di compattazione dalla risposta const compactionBlock = response.content[0]; // Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi) // includendoli dopo il blocco di compattazione, senza i blocchi di ragionamento // ; un turno dell'assistente rimasto senza contenuto viene scartato const preservedMessages = messages .slice(-3) .map((message) => message.role === "assistant" && Array.isArray(message.content) ? { ...message, content: message.content.filter( (block) => block.type !== "thinking" && block.type !== "redacted_thinking" ) } : message ) .filter((message) => message.content.length > 0); // Crea il nuovo elenco di messaggi: compattazione + messaggi conservati const messagesAfterCompaction: Anthropic.Beta.Messages.BetaMessageParam[] = [ { role: "assistant", content: [compactionBlock] }, ...preservedMessages ]; // Continua la richiesta con il contesto compattato + i messaggi conservati response = await client.beta.messages.create({ betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messagesAfterCompaction, context_management: { edits: [{ type: "compact_20260112" }] } }); // Aggiorna l'elenco dei messaggi per riflettere la compattazione messages = messagesAfterCompaction; } // Aggiungi la risposta finale messages.push({ role: "assistant", content: response.content }); // Restituisci il contenuto testuale const textBlock = response.content.find((block) => block.type === "text"); return textBlock?.text ?? ""; } // Esegui una conversazione lunga console.log(await chat("Help me build a Python web scraper")); console.log(await chat("Add support for JavaScript-rendered pages")); console.log(await chat("Now add rate limiting and error handling")); // Continua a chiamare chat() finché la conversazione lo richiede ``` ```csharp C# AnthropicClient client = new(); List messages = new(); Console.WriteLine(await Chat("Help me build a Python web scraper")); Console.WriteLine(await Chat("Add support for JavaScript-rendered pages")); Console.WriteLine(await Chat("Now add rate limiting and error handling")); async Task Chat(string userMessage) { messages.Add(new() { Role = Role.User, Content = userMessage }); var response = await client.Beta.Messages.Create(new() { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messages, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit { Trigger = new BetaInputTokensTrigger(100000), PauseAfterCompaction = true }] } }); if (response.StopReason == BetaStopReason.Compaction) { if (!response.Content[0].TryPickCompaction(out _)) throw new InvalidOperationException("Expected compaction block"); // Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi), // senza blocchi di ragionamento; un turno dell'assistente rimasto vuoto viene scartato var preserved = messages .Skip(Math.Max(0, messages.Count - 3)) .Select(message => message.Content.TryPickBetaContentBlockParams(out var blocks) ? new BetaMessageParam { Role = message.Role, Content = blocks .Where(block => block.Type.GetString() is not ("thinking" or "redacted_thinking")) .ToList() } : message) .Where(message => !message.Content.TryPickBetaContentBlockParams(out var blocks) || blocks.Count > 0) .ToList(); var messagesAfterCompaction = new List { new() { Role = Role.Assistant, Content = new List { new BetaContentBlockParam(response.Content[0].Json) } } }; messagesAfterCompaction.AddRange(preserved); response = await client.Beta.Messages.Create(new() { Betas = ["compact-2026-01-12"], Model = Model.ClaudeOpus5_5, MaxTokens = 4096, Messages = messagesAfterCompaction, ContextManagement = new BetaContextManagementConfig { Edits = [new BetaCompact20260112Edit()] } }); messages = messagesAfterCompaction; } messages.Add(new() { Role = Role.Assistant, Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList() }); return response.Content .Select(block => block.Value) .OfType() .Select(tb => tb.Text) .FirstOrDefault() ?? ""; } ``` ```go Go package main import ( "context" "fmt" "log" "github.com/anthropics/anthropic-sdk-go" ) var ( client = anthropic.NewClient() messages []anthropic.BetaMessageParam ) func chat(userMessage string) string { messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(userMessage))) compactEdit := anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{ Trigger: anthropic.BetaInputTokensTriggerParam{Value: 100000}, PauseAfterCompaction: anthropic.Bool(true), }}, }, } response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messages, ContextManagement: compactEdit, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } if response.StopReason == "compaction" { compactionParam := response.Content[0].ToParam() // Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi), // senza blocchi di ragionamento; un turno dell'assistente rimasto vuoto viene scartato var preserved []anthropic.BetaMessageParam for _, message := range messages[max(0, len(messages)-3):] { var content []anthropic.BetaContentBlockParamUnion for _, block := range message.Content { if block.OfThinking == nil && block.OfRedactedThinking == nil { content = append(content, block) } } if len(content) == 0 { continue } message.Content = content preserved = append(preserved, message) } messagesAfterCompaction := []anthropic.BetaMessageParam{ {Role: anthropic.BetaMessageParamRoleAssistant, Content: []anthropic.BetaContentBlockParamUnion{compactionParam}}, } messagesAfterCompaction = append(messagesAfterCompaction, preserved...) response, err = client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 4096, Messages: messagesAfterCompaction, ContextManagement: anthropic.BetaContextManagementConfigParam{ Edits: []anthropic.BetaContextManagementConfigEditUnionParam{ {OfCompact20260112: &anthropic.BetaCompact20260112EditParam{}}, }, }, Betas: []anthropic.AnthropicBeta{"compact-2026-01-12"}, }) if err != nil { log.Fatal(err) } messages = messagesAfterCompaction } messages = append(messages, response.ToParam()) for _, block := range response.Content { if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok { return textBlock.Text } } return "" } func main() { fmt.Println(chat("Help me build a Python web scraper")) fmt.Println(chat("Add support for JavaScript-rendered pages")) fmt.Println(chat("Now add rate limiting and error handling")) } ``` ```java Java import com.anthropic.models.beta.messages.BetaContextManagementConfig; import com.anthropic.models.beta.messages.BetaCompact20260112Edit; import com.anthropic.models.beta.messages.BetaInputTokensTrigger; import com.anthropic.models.beta.messages.BetaStopReason; // ... private static final AnthropicClient client = AnthropicOkHttpClient.fromEnv(); private static final List messages = new ArrayList<>(); public static String chat(String userMessage) { messages.add(BetaMessageParam.builder() .role(BetaMessageParam.Role.USER) .content(userMessage) .build()); MessageCreateParams params = MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .messages(messages) .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder() .trigger(BetaInputTokensTrigger.builder() .value(100000L) .build()) .pauseAfterCompaction(true) .build()) .build()) .build(); BetaMessage response = client.beta().messages().create(params); // Verifica se la compattazione è avvenuta e si è messa in pausa if (response.stopReason().isPresent() && response.stopReason().get().equals(BetaStopReason.COMPACTION)) { // Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi), // senza blocchi di ragionamento; un turno dell'assistente rimasto vuoto viene scartato List preservedMessages = new ArrayList<>(); for (BetaMessageParam message : messages.subList(Math.max(0, messages.size() - 3), messages.size())) { if (message.content().isBetaContentBlockParams()) { message = message.toBuilder() .contentOfBetaContentBlockParams(message.content().asBetaContentBlockParams().stream() .filter(block -> !block.isThinking() && !block.isRedactedThinking()) .toList()) .build(); if (message.content().asBetaContentBlockParams().isEmpty()) { continue; } } preservedMessages.add(message); } // Costruisci il nuovo elenco di messaggi: compattazione + messaggi conservati List messagesAfterCompaction = new ArrayList<>(); messagesAfterCompaction.add(response.toParam()); messagesAfterCompaction.addAll(preservedMessages); // Prosegui la richiesta con il contesto compattato + i messaggi conservati MessageCreateParams continueParams = MessageCreateParams.builder() .addBeta("compact-2026-01-12") .model(Model.CLAUDE_OPUS_5_5) .maxTokens(4096L) .messages(messagesAfterCompaction) .contextManagement(BetaContextManagementConfig.builder() .addEdit(BetaCompact20260112Edit.builder().build()) .build()) .build(); response = client.beta().messages().create(continueParams); // Aggiorna l'elenco dei messaggi per riflettere la compattazione messages.clear(); messages.addAll(messagesAfterCompaction); } // Aggiungi la risposta finale messages.add(response.toParam()); return response.content().stream() .filter(block -> block.text().isPresent()) .map(block -> block.text().get().text()) .findFirst() .orElse(""); } public static void main(String[] args) { System.out.println(chat("Help me build a Python web scraper")); System.out.println(chat("Add support for JavaScript-rendered pages")); System.out.println(chat("Now add rate limiting and error handling")); } ``` ```php PHP $client = new Client(); $messages = []; function chat($client, &$messages, $userMessage) { $messages[] = ['role' => 'user', 'content' => $userMessage]; $response = $client->beta->messages->create( maxTokens: 4096, messages: $messages, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [ [ 'type' => 'compact_20260112', 'trigger' => ['type' => 'input_tokens', 'value' => 100000], 'pause_after_compaction' => true ] ] ] ); if ($response->stopReason === 'compaction') { $compactionBlock = $response->content[0]; // Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi), // senza blocchi di ragionamento; un turno assistant rimasto vuoto viene scartato $preserved = array_values(array_filter(array_map( fn($message) => $message['role'] === 'assistant' ? array_merge($message, ['content' => array_values(array_filter( $message['content'], fn($block) => !in_array($block->type, ['thinking', 'redacted_thinking'], true) ))]) : $message, array_slice($messages, -3) ), fn($message) => $message['content'] !== [])); $messagesAfterCompaction = array_merge( [['role' => 'assistant', 'content' => [$compactionBlock]]], $preserved ); $response = $client->beta->messages->create( maxTokens: 4096, messages: $messagesAfterCompaction, model: 'claude-opus-5-5', betas: ['compact-2026-01-12'], contextManagement: [ 'edits' => [['type' => 'compact_20260112']] ] ); $messages = $messagesAfterCompaction; } $messages[] = ['role' => 'assistant', 'content' => $response->content]; foreach ($response->content as $block) { if ($block->type === 'text') { return $block->text; } } return ''; } echo chat($client, $messages, "Help me build a Python web scraper") . "\n"; echo chat($client, $messages, "Add support for JavaScript-rendered pages") . "\n"; echo chat($client, $messages, "Now add rate limiting and error handling") . "\n"; ``` ```ruby Ruby client = Anthropic::Client.new messages = [] def chat(client, messages, user_message) messages << { role: "user", content: user_message } response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages, context_management: { edits: [ { type: "compact_20260112", trigger: { type: "input_tokens", value: 100000 }, pause_after_compaction: true } ] } ) if response.stop_reason == :compaction compaction_block = response.content[0] # Conserva lo scambio precedente + il messaggio utente corrente (3 messaggi), # senza blocchi di ragionamento; un turno dell'assistente rimasto vuoto viene scartato preserved = messages.last(3).map do |message| next message unless message[:role] == "assistant" message.merge(content: message[:content].reject { |block| %i[thinking redacted_thinking].include?(block.type) }) end.reject { |message| message[:content].empty? } messages_after_compaction = [ { role: "assistant", content: [compaction_block] } ] + preserved response = client.beta.messages.create( betas: ["compact-2026-01-12"], model: "claude-opus-5-5", max_tokens: 4096, messages: messages_after_compaction, context_management: { edits: [{ type: "compact_20260112" }] } ) messages.clear messages.concat(messages_after_compaction) end messages << { role: "assistant", content: response.content } response.content.find { |block| block.type == :text }&.text || "" end puts chat(client, messages, "Help me build a Python web scraper") puts chat(client, messages, "Add support for JavaScript-rendered pages") puts chat(client, messages, "Now add rate limiting and error handling") ``` ## Limitazioni attuali * **Stesso modello per il riepilogo:** il modello specificato nella tua richiesta viene usato per il riepilogo. Non è possibile usare un modello diverso (ad esempio, più economico) per il riepilogo. * **La compattazione potrebbe non riuscire quando sono definiti strumenti:** quando la tua richiesta include `tools`, il modello occasionalmente chiama uno strumento durante il passaggio interno di riepilogo invece di scrivere un riepilogo. Quando ciò accade, la risposta contiene un blocco `compaction` con `content: null`. Per evitarlo, imposta [`instructions`](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#custom-summarization-instructions) su un prompt che indichi esplicitamente al modello di non chiamare strumenti, ad esempio: ```text wrap Summarize the transcript inside

tags. Include relevant information in the summary for continuing the task in the next context window. Do not call any tools while writing this summary; respond with text only. ``` ## Passaggi successivi Gestisci automaticamente il contesto della conversazione man mano che cresce con la modifica del contesto. Scopri le dimensioni delle finestre di contesto e le strategie di gestione. Esplora un'implementazione pratica che gestisce conversazioni di lunga durata con la compattazione istantanea della memoria di sessione, usando il threading in background e la cache dei prompt.