Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Compattazione: comprimere conversazioni lunghe

Lezione 11 di 20 Aggiornata il 28 luglio 2026 Avanzato
In questa pagina
  1. Il problema delle conversazioni lunghe
  2. Due strategie da conoscere
  3. Verificare che la compattazione valga la pena
  4. Punti chiave

Il problema delle conversazioni lunghe

Ogni messaggio aggiunto a una conversazione aumenta il numero di token inviati alle API. Una conversazione di 50 turni può facilmente raggiungere i 30.000 token in input, facendo crescere sia la latenza sia i costi. Il problema è insidioso: il primo turno di un assistente per il supporto costa poche centinaia di token, mentre il trentesimo ne costa diverse migliaia, anche se l’utente pone esattamente lo stesso tipo di domanda. Paghi sempre di più per un servizio identico e l’utente attende sempre più a lungo una risposta.

La compattazione risolve il problema comprimendo la cronologia senza perdere le informazioni essenziali. Consiste nel riassumere gli scambi più vecchi per ridurre il conteggio dei token, preservando al contempo il contesto necessario. Invece di inviare l’intera cronologia, invii un riepilogo degli scambi passati più i messaggi recenti. Il modello sa comunque che il cliente si chiama Dupont, che ha un ordine contestato e che hai già proposto un rimborso, senza dover rileggere i quaranta messaggi che hanno stabilito questi fatti.

Il meccanismo

La funzione seguente applica questa logica nella sua forma più semplice: stima il volume, non interviene finché non viene superata la soglia, quindi divide la cronologia in due parti. I messaggi più vecchi vanno al riepilogo; i più recenti restano invariati.

import openai

client = openai.OpenAI()

def compact_history(
    messages: list[dict],
    token_threshold: int = 10_000,
    keep_recent: int = 6,
) -> list[dict]:
    """Compatta la cronologia quando supera la soglia."""

    # Stima del conteggio token (approssimazione)
    estimated_tokens = sum(len(m["content"]) // 4 for m in messages)

    if estimated_tokens < token_threshold:
        return messages  # Nessuna necessità di compattare

    # Divisione: messaggi vecchi vs recenti
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    # Riassunto dei messaggi vecchi
    old_text = "\n".join(
        f"{m['role']}: {m['content']}" for m in old_messages
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        input=(
            "Summarize this conversation concisely. "
            "Keep key factual information, decisions made, "
            "and the context needed to understand what follows.\n\n"
            f"{old_text}"
        ),
        max_output_tokens=500,
    )

    # Ricostruzione della cronologia compattata
    summary_message = {
        "role": "system",
        "content": f"Summary of previous conversation:\n{response.output_text}",
    }

    return [summary_message] + recent_messages

Due dettagli meritano la tua attenzione. Il prompt di riepilogo richiede esplicitamente le decisioni prese, perché un riassunto che trattiene solo i temi fa perdere al modello la memoria dei propri impegni. Inoltre, max_output_tokens=500 limita la lunghezza del riassunto: senza questo limite, il riassunto crescerebbe a ogni compattazione e finiresti con lo stesso problema che volevi eliminare.

Due strategie da conoscere

La classe seguente industrializza il principio. Mantiene un unico riepilogo che riscrive a ogni compattazione integrando i nuovi scambi, mantenendo al contempo una finestra di messaggi grezzi. Il contesto inviato alle API è quindi sempre composto da tre blocchi: il prompt di sistema, il riepilogo cumulativo e la finestra recente.

class CompactedConversation:
    """Gestisce una conversazione con compattazione automatica."""

    def __init__(
        self,
        system_prompt: str,
        compaction_threshold: int = 8_000,
        window_size: int = 8,
    ):
        self.system_prompt = system_prompt
        self.threshold = compaction_threshold
        self.window_size = window_size
        self.summary: str | None = None
        self.messages: list[dict] = []

    def build_context(self) -> list[dict]:
        """Costruisce il contesto da inviare alle API."""
        context = [{"role": "system", "content": self.system_prompt}]

        if self.summary:
            context.append({
                "role": "system",
                "content": f"Previous context: {self.summary}",
            })

        context.extend(self.messages[-self.window_size:])
        return context

    def add_message(self, role: str, content: str):
        self.messages.append({"role": role, "content": content})
        self._check_compaction()

    def _check_compaction(self):
        tokens = sum(len(m["content"]) // 4 for m in self.messages)
        if tokens > self.threshold:
            self._compact()

    def _compact(self):
        old_messages = self.messages[:-self.window_size]
        if not old_messages:
            return

        text = "\n".join(
            f"{m['role']}: {m['content']}" for m in old_messages
        )

        existing_context = f"Existing summary: {self.summary}\n\n" if self.summary else ""

        response = client.responses.create(
            model="gpt-5.6-terra",
            input=(
                f"{existing_context}"
                f"New exchanges to integrate into the summary:\n{text}\n\n"
                "Produce an updated, concise, and factual summary."
            ),
            max_output_tokens=400,
        )

        self.summary = response.output_text
        self.messages = self.messages[-self.window_size:]

Nota che _compact reinietta il riepilogo esistente nel prompt prima dei nuovi scambi. Questo previene l’amnesia progressiva: senza questa reiniezione, ogni compattazione cancellerebbe tutto ciò che quella precedente aveva conservato.

Compattazione selettiva

La sintesi è distruttiva e alcuni contenuti non sopravvivono alla riformulazione. Uno snippet di codice, una risposta JSON di un’API o una tabella di cifre perdono la loro utilità non appena vengono parafrasati. La compattazione selettiva ordina quindi i messaggi vecchi prima di riassumerli: quelli contenenti codice o dati strutturati passano intatti, mentre viene compresso solo il testo conversazionale.

def selective_compaction(
    messages: list[dict],
    keep_recent: int = 6,
) -> list[dict]:
    """Compatta mantenendo intatti i messaggi strutturati."""
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    to_summarize = []
    to_keep = []

    for msg in old_messages:
        content = msg["content"]
        # Mantieni i messaggi contenenti codice o dati
        if "```" in content or "{" in content:
            to_keep.append(msg)
        else:
            to_summarize.append(msg)

    # Riassumi solo il testo conversazionale
    summary = ""
    if to_summarize:
        text = "\n".join(f"{m['role']}: {m['content']}" for m in to_summarize)
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=f"Summarize these exchanges in 3 sentences:\n{text}",
            max_output_tokens=200,
        )
        summary = response.output_text

    result = []
    if summary:
        result.append({
            "role": "system",
            "content": f"Summary of exchanges: {summary}",
        })
    result.extend(to_keep)
    result.extend(recent_messages)
    return result

Il criterio di ordinamento usato qui – presenza di tre backtick o di una parentesi graffa – è volutamente grezzo. Adattalo a ciò che i tuoi strumenti producono realmente: per un assistente che gestisce riferimenti di casi, potresti voler preservare qualsiasi messaggio contenente un ID cliente.

Verificare che la compattazione valga la pena

Una compattazione mal calibrata costa una chiamata API extra senza guadagni percepibili, oppure comprime in modo così aggressivo che il modello perde il filo e pone domande già risolte. Misura quindi il rapporto prima di fissare le soglie definitive, utilizzando un campione di conversazioni reali.

def compaction_ratio(
    before: list[dict],
    after: list[dict],
) -> dict:
    tokens_before = sum(len(m["content"]) // 4 for m in before)
    tokens_after = sum(len(m["content"]) // 4 for m in after)
    reduction = 1 - (tokens_after / tokens_before) if tokens_before else 0

    return {
        "tokens_before": tokens_before,
        "tokens_after": tokens_after,
        "reduction": f"{reduction:.0%}",
        "messages_before": len(before),
        "messages_after": len(after),
    }

Prendi una dozzina di trascrizioni dal tuo ambiente di produzione, eseguile attraverso la compattazione e leggi i riepiloghi prodotti: se non riesci a riprendere la conversazione basandoti solo sul riepilogo, la tua soglia è troppo bassa o il tuo prompt di riepilogo troppo vago.

Punti chiave

  • La compattazione riduce i token riassumendo i messaggi più vecchi
  • Mantieni sempre intatti i messaggi più recenti (finestra scorrevole)
  • Preserva i messaggi contenenti codice o dati strutturati
  • Reinietta il riepilogo esistente a ogni nuova compattazione per evitare l’amnesia progressiva
  • Misura il rapporto di compressione per calibrare le tue soglie