Kompaktiranje: Stiskanje dolgih pogovorov
Na tej strani
Težava z dolgimi pogovori
Vsako sporočilo, dodano v pogovor, poveča število žetonov, poslanih API-ju. Pogovor s 50 izmenjavami zlahka doseže 30.000 vhodnih žetonov, kar poveča tako zakasnitev kot stroške. Težava je zahrbtna: prvi klic podpornega asistenta stane nekaj sto žetonov, medtem ko trideseti klic stane več tisoč, čeprav uporabnik zastavlja popolnoma enako vrsto vprašanja. Plačuješ vse več za identično storitev, uporabnik pa čaka vse dlje na odgovor.
Kompaktiranje to reši s stiskanjem zgodovine brez izgube bistvenih informacij. Vključuje povzemanje starejših izmenjav za zmanjšanje števila žetonov ob ohranjanju potrebnega konteksta. Namesto pošiljanja celotne zgodovine pošlješ povzetek preteklih izmenjav plus nedavna sporočila. Model še vedno ve, da se stranka imenuje Dupont, da ima sporni naročilo in da ste že ponudili povračilo, ne da bi moral znova prebrati štirideset sporočil, ki so ta dejstva vzpostavila.
Mehanizem
Spodnja funkcija uporablja to logiko v najpreprostejši obliki: oceni volumen, ne stori ničesar, dokler ni presežen prag, nato pa zgodovino razdeli na dva dela. Starejša sporočila gredo v povzetek; najnovejša ostanejo nespremenjena.
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
Dve podrobnosti si zaslužita tvojo pozornost. Poziv za povzetek izrecno zahteva sprejete odločitve, saj povzetek, ki ohranja le teme, povzroči, da model izgubi spomin na lastne zaveze. In max_output_tokens=500 omeji povzetek: brez te omejitve bi povzetek rasel z vsakim kompaktiranjem in končal bi s prav tisto težavo, ki si jo želel odpraviti.
Dve strategiji, ki ju moraš poznati
Drsno okno s povzetkom
Spodnji razred industrializira to načelo. Vzdržuje en sam povzetek, ki ga prepisuje ob vsakem kompaktiranju z vključevanjem novih izmenjav, hkrati pa ohranja okno surovih sporočil. Kontekst, poslan API-ju, zato vedno sestavljajo trije bloki: sistemski poziv, kumulativni povzetek in nedavno okno.
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:]
Upoštevaj, da _compact ponovno vbrizga obstoječi povzetek v poziv pred nove izmenjave. To preprečuje progresivno amnezijo: brez tega ponovnega vbrizgavanja bi vsako kompaktiranje izbrisalo vse, kar je ohranilo prejšnje.
Selektivno kompaktiranje
Povzemanje je destruktivno in nekatere vsebine ne preživijo preoblikovanja. Izsek kode, odgovor API-ja v formatu JSON ali tabela s številkami izgubijo svojo uporabnost, takoj ko so parafrazirani. Selektivno kompaktiranje zato razvrsti stara sporočila pred povzemanjem: tista, ki vsebujejo kodo ali strukturirane podatke, gredo skozi nespremenjena, stisnjen pa je le pogovorni tekst.
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
Merilo za razvrščanje, uporabljeno tukaj – prisotnost trojnih obratnih narekovajev ali oklepaja – je namerno grobo. Prilagodi ga temu, kar tvoja orodja dejansko proizvajajo: za asistenta, ki obravnava reference primerov, bi morda želel ohraniti vsako sporočilo, ki vsebuje ID stranke.
Preverjanje, ali se kompaktiranje splača
Slabo umerjeno kompaktiranje stane dodatni klic API-ja brez opaznega dobička ali pa stisne tako agresivno, da model izgubi nit in zastavlja vprašanja, ki so že bila razrešena. Zato izmeri razmerje pred določitvijo končnih pragov z uporabo vzorca resničnih pogovorov.
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),
}
Vzemi ducat prepisov iz svojega produkcijskega okolja, jih poženi skozi kompaktiranje in preberi nastale povzetke: če na podlagi samega povzetka ne moreš nadaljevati pogovora, je tvoj prag prenizek ali tvoj poziv za povzetek preveč nejasen.
Ključne ugotovitve
- Kompaktiranje zmanjša število žetonov s povzemanjem starejših sporočil
- Vedno ohrani najnovejša sporočila nespremenjena (drsno okno)
- Ohrani sporočila, ki vsebujejo kodo ali strukturirane podatke
- Ponovno vbrizgaj obstoječi povzetek ob vsakem novem kompaktiranju, da se izogneš progresivni amneziji
- Izmeri razmerje stiskanja za umeritev svojih pragov