Compaction: Compresarea conversațiilor lungi
Pe această pagină
Problema conversațiilor lungi
Fiecare mesaj adăugat într-o conversație mărește numărul de tokeni trimiși către API. O conversație de 50 de tururi poate ajunge ușor la 30.000 de tokeni de intrare, ceea ce crește atât latența, cât și costurile. Problema este insidioasă: primul tur al unui asistent de suport costă câteva sute de tokeni, în timp ce al treizecilea tur costă câteva mii, chiar dacă utilizatorul pune exact același tip de întrebare. Plătiți din ce în ce mai mult pentru un serviciu identic, iar utilizatorul așteaptă din ce în ce mai mult un răspuns.
Compaction rezolvă această problemă prin comprimarea istoricului fără a pierde informațiile esențiale. Aceasta implică rezumarea schimburilor mai vechi pentru a reduce numărul de tokeni, păstrând în același timp contextul necesar. În loc să trimiteți întregul istoric, trimiteți un rezumat al schimburilor anterioare plus mesajele recente. Modelul știe în continuare că numele clientului este Dupont, că există o comandă contestată și că ați oferit deja o rambursare, fără a fi nevoie să recitească cele patruzeci de mesaje care au stabilit aceste fapte.
Mecanismul
Funcția de mai jos aplică această logică în forma sa cea mai simplă: estimează volumul, nu face nimic până când pragul este depășit, apoi împarte istoricul în două părți. Mesajele mai vechi merg către rezumat; cele mai recente rămân neschimbate.
import openai
client = openai.OpenAI()
def compact_history(
messages: list[dict],
token_threshold: int = 10_000,
keep_recent: int = 6,
) -> list[dict]:
"""Compacts history when it exceeds the threshold."""
# Estimate token count (approximation)
estimated_tokens = sum(len(m["content"]) // 4 for m in messages)
if estimated_tokens < token_threshold:
return messages # No need to compact
# Split: old messages vs recent ones
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
# Summarize old messages
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,
)
# Rebuild compacted history
summary_message = {
"role": "system",
"content": f"Summary of previous conversation:\n{response.output_text}",
}
return [summary_message] + recent_messages
Două detalii merită atenția dumneavoastră. Promptul de rezumat solicită în mod explicit deciziile luate, deoarece un rezumat care reține doar temele face ca modelul să piardă memoria propriilor angajamente. Și max_output_tokens=500 limitează rezumatul: fără această limită, rezumatul crește la fiecare compaction și ajungeți exact la problema pe care încercați să o eliminați.
Două strategii de cunoscut
Fereastră glisantă cu rezumat
Clasa de mai jos industrializează principiul. Aceasta menține un singur rezumat pe care îl rescrie la fiecare compaction prin integrarea noilor schimburi, păstrând în același timp o fereastră de mesaje brute. Contextul trimis către API este therefore întotdeauna compus din trei blocuri: promptul de sistem, rezumatul cumulativ și fereastra recentă.
class CompactedConversation:
"""Manages a conversation with automatic compaction."""
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]:
"""Builds the context to send to the 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:]
Rețineți că _compact reinjectează rezumatul existent în prompt înainte de noile schimburi. Acest lucru previne amnezia progresivă: fără această reinjectare, fiecare compaction ar șterge tot ceea ce reținuse cea anterioară.
Compaction selectiv
Rezumarea este distructivă, iar anumite conținuturi nu supraviețuiesc reformulării. Un fragment de cod, un răspuns API JSON sau un tabel de cifre își pierd utilitatea imediat ce sunt parafrazate. Compaction selectiv sortează therefore mesajele vechi înainte de a le rezuma: cele care conțin cod sau date structurate trec intacte, în timp ce doar textul conversațional este comprimat.
def selective_compaction(
messages: list[dict],
keep_recent: int = 6,
) -> list[dict]:
"""Compacts while keeping structured messages intact."""
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
to_summarize = []
to_keep = []
for msg in old_messages:
content = msg["content"]
# Keep messages containing code or data
if "```" in content or "{" in content:
to_keep.append(msg)
else:
to_summarize.append(msg)
# Summarize only conversational text
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
Criteriul de sortare utilizat aici — prezența a trei accent grave sau a unei acolade — este intenționat brut. Adaptați-l la ceea ce produc efectiv instrumentele dumneavoastră: pentru un asistent care gestionează referințe de dosare, s-ar putea să doriți să păstrați orice mesaj care conține un ID de client.
Verificarea faptului că Compaction merită
O compaction calibrată necorespunzător costă un apel API suplimentar fără niciun câștig vizibil sau comprimă atât de agresiv încât modelul pierde firul logic și pune întrebări deja rezolvate. Prin urmare, măsurați raportul înainte de a vă fixa pragurile finale, folosind un eșantion de conversații reale.
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),
}
Luați o duzină de transcrieri din mediul dumneavoastră de producție, rulați-le prin compaction și citiți rezumatele produse: dacă nu puteți relua conversația bazându-vă doar pe rezumat, pragul dumneavoastră este prea scăzut sau promptul de rezumat este prea vag.
Puncte cheie
- Compaction reduce tokenii prin rezumarea mesajelor mai vechi
- Păstrați întotdeauna mesajele cele mai recente intacte (fereastră glisantă)
- Păstrați mesajele care conțin cod sau date structurate
- Reinjectați rezumatul existent la fiecare nouă compaction pentru a evita amnezia progresivă
- Măsurați raportul de compresie pentru a vă calibra pragurile