Compattazione: comprimere conversazioni lunghe
In questa pagina
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
Finestra scorrevole con riepilogo
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