---
title: Panoramica della compattazione
url: https://platform.claude.com/docs/it/build-with-claude/compaction
description: Scopri cosa fa la compattazione, come differiscono la compattazione su richiesta e la compattazione a una soglia di token, e quale pagina copre il tuo compito.
---

La “compaction” (compattazione) sostituisce i turni più vecchi di una conversazione con un riepilogo che Claude scrive sul server, così non hai bisogno di alcun codice di riepilogo tuo. Mantiene una conversazione lunga o un’attività agentica all’interno della “context window” (finestra di contesto) e mantiene piccolo il contesto attivo, perché la qualità delle risposte peggiora man mano che una conversazione cresce.

Se vuoi saltare questa panoramica, inizia con [Compattazione su richiesta](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand) per aggiungere la compattazione alla tua applicazione. Sebbene sia questa sia la [Compattazione a una soglia di token](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold) siano in beta, la Compattazione su richiesta copre più casi d’uso comuni. Per eliminare i vecchi risultati degli strumenti o i vecchi blocchi di ragionamento in base a una regola invece di riassumerli, consulta [Modifica del contesto](https://platform.claude.com/docs/it/build-with-claude/context-editing).

## Scegli come compattare

Usa la compattazione su richiesta ovunque sia disponibile.

|                                                                                                                                                                            | [Compattazione su richiesta](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand)                                                                                                                                                      | [Compattazione a una soglia di token](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold)                                                                                                                                                                      | [Il tuo riassuntore](https://platform.claude.com/docs/it/build-with-claude/compaction-thinking-blocks#own-summary)                                         |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Chi decide quando**                                                                                                                                                      | Tu, inviando una richiesta                                                                                                                                                                                                                                    | L’API, quando i token di input raggiungono la soglia di attivazione che hai impostato                                                                                                                                                                                                  | Tu                                                                                                                                                         |
| **Codice che scrivi**                                                                                                                                                      | Un [ciclo di compattazione](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand#compact-in-a-loop) che richiede il riassunto e lo inserisce al posto dei messaggi                                                                      | Un parametro sulle tue richieste ordinarie                                                                                                                                                                                                                                             | La chiamata di riassunto, il suo prompt e la riscrittura della cronologia                                                                                  |
| **Cosa rinvii dopo**                                                                                                                                                       | Il blocco restituito, posto per primo in `messages`, al posto dei messaggi che riassume                                                                                                                                                                       | La risposta, aggiunta come di consueto. L’API scarta ciò che precede il blocco                                                                                                                                                                                                         | Il tuo riassunto, come un tuo messaggio                                                                                                                    |
| **I turni recenti restano parola per parola**                                                                                                                              | Sì: [Compattazione che mantiene i turni recenti](https://platform.claude.com/docs/it/build-with-claude/compaction-keep-recent-turns)                                                                                                                          | Sì, [mettendo in pausa dopo la compattazione](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#pausing-after-compaction) e reinserendoli                                                                                                                     | Sì                                                                                                                                                         |
| **Viene eseguita in background**                                                                                                                                           | Sì: [Compattazione in background](https://platform.claude.com/docs/it/build-with-claude/compaction-background)                                                                                                                                                | No: viene eseguita all’interno della richiesta che raggiunge la soglia                                                                                                                                                                                                                 | Sì, nel tuo codice                                                                                                                                         |
| **I turni mantenuti conservano il loro ragionamento**, sui modelli con [ragionamento preservato](https://platform.claude.com/docs/it/build-with-claude/preserved-thinking) | Sì, alle condizioni descritte in [Compattazione e ragionamento preservato](https://platform.claude.com/docs/it/build-with-claude/compaction-thinking-blocks)                                                                                                  | No: rimuovi il ragionamento dai turni che reinserisci, oppure lascia che sia l’API a scartarlo con `prefix_mismatch_behavior: "drop_block"` (vedi gli [esempi di compattazione a soglia](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#examples))         | No: quel ragionamento [non supera il controllo del prefisso](https://platform.claude.com/docs/it/build-with-claude/compaction-thinking-blocks#own-summary) |
| **Header beta, parametro e piattaforme**                                                                                                                                   | `compact-2026-09-04` e il parametro di primo livello `compaction`. Piattaforme: vedi la [sezione sul supporto API per la compattazione su richiesta](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand#availability-feature-support) | Vedi la [sezione sul supporto API per la compattazione a soglia](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#availability-feature-support) e [Utilizzo di base](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#basic-usage) | Nessuno. Viene eseguita nel tuo codice                                                                                                                     |
| **Sceglila quando**                                                                                                                                                        | La tua applicazione deve controllare quando avviene la compattazione, non può mettersi in pausa mentre viene scritto un riassunto, o deve mantenere i turni recenti e il loro ragionamento                                                                    | Vuoi che l’API gestisca il contesto all’interno delle richieste ordinarie                                                                                                                                                                                                              | Esegui già un tuo riassuntore e questo sostituisce l’intera cronologia con il riassunto                                                                    |

## Opzioni di compattazione su richiesta

[Compattazione su richiesta](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand) mostra un ciclo che riepiloga l’intera conversazione mentre la tua applicazione attende. Le prime due pagine in questo elenco cambiano il modo in cui quel ciclo viene eseguito, e puoi combinarle. La terza si applica se rimandi indietro i blocchi di ragionamento e fai una delle due cose.

* [Compattazione che mantiene i turni recenti](https://platform.claude.com/docs/it/build-with-claude/compaction-keep-recent-turns): quando gli ultimi turni devono raggiungere Claude parola per parola. Il riepilogo copre solo i turni più vecchi.
* [Compattazione in background](https://platform.claude.com/docs/it/build-with-claude/compaction-background): quando la conversazione non può mettersi in pausa per il riepilogo. La richiesta viene eseguita mentre il lavoro continua, e sostituisci il blocco quando arriva.
* [Compattazione e ragionamento preservato](https://platform.claude.com/docs/it/build-with-claude/compaction-thinking-blocks): se rimandi indietro i blocchi di ragionamento su un modello con ragionamento preservato e mantieni i turni recenti o compatti in background. Altrimenti saltala.
* [Scrivi il tuo prompt di riepilogo](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand#write-your-own-summarization-prompt): quando il riepilogo predefinito scarta qualcosa di cui un turno successivo ha bisogno. Il tuo prompt sostituisce quello predefinito.
* [Compatta di nuovo](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand#compact-again): quando una conversazione che inizia già con un blocco di compattazione torna a diventare lunga.

Trova questi argomenti su altre pagine:

* [Richiedere un riassunto](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand#request-a-summary) si trova in Compattazione su richiesta.
* [Continuare dal riassunto](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand#continue-from-the-summary) si trova in Compattazione su richiesta. Le condizioni che mantengono valido il ragionamento nei turni che mantieni si trovano in [Compattazione e ragionamento preservato](https://platform.claude.com/docs/it/build-with-claude/compaction-thinking-blocks).
* Quando non viene restituito alcun riassunto: vedi [Gestire un riassunto mancante o un errore](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand#when-no-summary-comes-back) in Compattazione su richiesta.
* Come si integra con il resto dell’API: vedi [Limiti e interazioni con altre funzionalità](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand#how-it-fits-with-the-rest-of-the-api) in Compattazione su richiesta.
* Comprendere l’utilizzo: vedi [Conteggiare l’utilizzo della compattazione](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand#understanding-usage) per la compattazione su richiesta, oppure [Comprendere l’utilizzo](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#understanding-usage) per la compattazione a soglia.
* Compatibilità: ogni tipo ha il proprio header beta, quindi ogni pagina ha la propria sezione: [Supporto API per la compattazione su richiesta](https://platform.claude.com/docs/it/build-with-claude/compaction-on-demand#availability-feature-support) e [Supporto API per la compattazione a soglia](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold#availability-feature-support).

La compattazione a soglia ha una pagina dedicata: [Compattazione a una soglia di token](https://platform.claude.com/docs/it/build-with-claude/compaction-threshold).
