Compattazione che mantiene i turni recenti

La "keep-tail compaction" (compattazione con mantenimento della coda) mantiene gli ultimi turni di una conversazione parola per parola dopo il riepilogo. Cambia due cose nel ciclo di compattazione: quali messaggi entrano nella richiesta di compattazione e cosa invii dopo il blocco. Tutto ciò che è descritto in Continua dal riepilogo si applica senza modifiche.

Scegli quali turni mantenere

Nessun parametro stabilisce quali turni vengono mantenuti. Sei tu a scegliere un punto di taglio nella cronologia: i messaggi che lo precedono entrano nella richiesta di compattazione, mentre i messaggi da quel punto in poi vengono mantenuti.

I turni mantenuti tornano a Claude per intero, quindi più ne mantieni, meno spazio libera la compattazione.

Posiziona il taglio dove nessuna "tool call" (chiamata a strumento) resta aperta, con ogni chiamata a strumento e il relativo risultato dallo stesso lato. Se i messaggi che invii terminano con un turno assistant la cui chiamata a strumento non ha ancora un risultato, l'API rifiuta la richiesta di compattazione.

Compatta i turni più vecchi e invia il resto dopo il blocco

Per mantenere parola per parola una coda di turni recenti, escludi quei turni dalla richiesta di compattazione. L'API riassume ogni messaggio che riceve, quindi invia solo i turni più vecchi, poi metti il blocco davanti ai turni che hai mantenuto.

Invia i turni mantenuti esattamente come sono nella cronologia, inclusi i "thinking blocks" (blocchi di pensiero). Entrambe le richieste includono il "beta header" (header beta), come in Richiedi un riepilogo.

Nell'esempio seguente, la cronologia contiene due turni e il taglio mantiene il secondo. La richiesta di compattazione contiene il primo turno:

{
  "model": "claude-opus-5-5",
  "max_tokens": 4096,
  "messages": [
    {
      "role": "user",
      "content": "I am building a recipe app. Help me name the main entities in the data model."
    },
    {
      "role": "assistant",
      "content": "Start with Recipe, Ingredient, and Step. Add a RecipeIngredient entry that holds the quantity and unit for each ingredient in a recipe."
    }
  ],
  "compaction": { "type": "summarize" }
}

La richiesta successiva invia prima il blocco restituito, poi il turno mantenuto esattamente com'era, poi il nuovo messaggio user. Continua dal riepilogo mostra una richiesta che inizia con un blocco.

Il programma seguente è il ciclo di Compatta in un ciclo, modificato per mantenere gli ultimi due turni. Le righe evidenziate mostrano dove differisce dal ciclo.

from anthropic.types.beta import BetaMessageParam

client = anthropic.Anthropic()

# Imposta questo valore vicino al tuo budget di input reale. Qui è basso così una conversazione breve viene compattata.
COMPACT_AT_TOKENS = 2500
SYSTEM = "You help design a recipe app's data model. Keep answers short."
KEEP_TURNS = 2

QUESTIONS = [
    "What are the main entities in the data model?",
    "Which fields should Recipe have?",
    "Which fields should Ingredient have?",
    "Which fields should RecipeIngredient have?",
    "Which fields should Step have?",
    "Which indexes should these tables have?",
    "Which fields should be required?",
    "Which fields should have default values?",
]

history: list[BetaMessageParam] = []
for turn, question in enumerate(QUESTIONS, start=1):
    history.append({"role": "user", "content": question})
    response = client.beta.messages.create(
        model="claude-opus-5-5",
        max_tokens=8192,
        system=SYSTEM,
        betas=["compact-2026-09-04"],
        messages=history,
    )
    history.append({"role": "assistant", "content": response.content})

    # Anche questa risposta viene inviata con la richiesta successiva, quindi contala.
    conversation_tokens = response.usage.input_tokens + response.usage.output_tokens
    if conversation_tokens > COMPACT_AT_TOKENS and KEEP_TURNS < turn < len(QUESTIONS):
        # Un turno è composto da un messaggio dell'utente e una risposta dell'assistente,
        # quindi i turni mantenuti iniziano con un messaggio dell'utente.
        split = -2 * KEEP_TURNS
        older, recent = history[:split], history[split:]
        summary = client.beta.messages.create(
            model="claude-opus-5-5",
            max_tokens=4096,
            system=SYSTEM,
            betas=["compact-2026-09-04"],
            messages=older,
            compaction={"type": "summarize"},
        )
        if summary.stop_reason == "compaction":
            history = [{"role": "assistant", "content": summary.content}, *recent]
            print(f"Kept {len(recent) // 2} turns after the block")

• Scelta del taglio: il programma mantiene gli ultimi due turni, dove un turno è un messaggio user e la relativa risposta. Divide la cronologia a quattro messaggi dalla fine, così i turni mantenuti iniziano con un messaggio user.
• Decidere quando compattare: il controllo della dimensione richiede anche che la conversazione abbia più turni di quanti il programma ne mantenga, così la parte più vecchia non è mai vuota.
• La richiesta di compattazione: dove il ciclo invia l'intera cronologia, questa versione invia solo i messaggi più vecchi.
• La sostituzione: dove il ciclo sostituisce l'intera cronologia con il messaggio restituito, in questa versione la nuova cronologia è il messaggio restituito seguito dai turni mantenuti.

Il controllo di stop_reason e ogni richiesta successiva alla sostituzione restano invariati rispetto al ciclo.

Mantieni valido il pensiero nei turni mantenuti

Se rinvii i blocchi di pensiero su un modello con "preserved thinking" (pensiero preservato), il pensiero nei turni mantenuti resta valido solo finché valgono le condizioni per il pensiero mantenuto, e una di queste limita dove può cadere il taglio.

Il taglio del programma, tra una risposta e il messaggio user successivo, soddisfa quella condizione. Lo stesso vale per un taglio alla fine di una richiesta che hai già effettuato: compatta esattamente i messages di quella richiesta e mantieni tutto ciò che la cronologia ha accumulato da allora.

Compatibility