Kompakce: Komprese dlouhých konverzací
Na této stránce
Problém s dlouhými konverzacemi
Každá zpráva přidaná do konverzace zvyšuje počet tokenů odesílaných do API. Konverzace o 50 kolech snadno dosáhne 30 000 vstupních tokenů, což zvyšuje latenci i náklady. Problém je zákeřný: první kolo podpůrného asistenta stojí několik stovek tokenů, zatímco třicáté kolo stojí několik tisíc, přestože se uživatel ptá na úplně stejný typ otázky. Platíš čím dál víc za identickou službu a uživatel čeká čím dál déle na odpověď.
Kompakce tento problém řeší kompresí historie bez ztráty podstatných informací. Spočívá ve shrnutí starších výměn za účelem snížení počtu tokenů při zachování nezbytného kontextu. Místo odeslání celé historie odešleš shrnutí minulých výměn plus nejnovější zprávy. Model stále ví, že se zákazník jmenuje Dupont, že má zpochybněnou objednávku a že jsi již nabídl vrácení peněz, aniž by musel znovu číst čtyřicet zpráv, které tyto skutečnosti stanovily.
Mechanismus
Níže uvedená funkce aplikuje tuto logiku v nejjednodušší formě: odhadne objem, nic nedělá, dokud není překročen práh, a poté rozdělí historii na dvě části. Starší zprávy jdou do shrnutí; ty nejnovější zůstávají tak, jak jsou.
import openai
client = openai.OpenAI()
def compact_history(
messages: list[dict],
token_threshold: int = 10_000,
keep_recent: int = 6,
) -> list[dict]:
"""Kompaktuje historii, když překročí práh."""
# Odhad počtu tokenů (aproximace)
estimated_tokens = sum(len(m["content"]) // 4 for m in messages)
if estimated_tokens < token_threshold:
return messages # Není třeba kompaktnovat
# Rozdělení: staré zprávy vs. nejnovější
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
# Shrnutí starých zpráv
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,
)
# Obnovení kompaktované historie
summary_message = {
"role": "system",
"content": f"Summary of previous conversation:\n{response.output_text}",
}
return [summary_message] + recent_messages
Dva detaily si zaslouží tvou pozornost. Prompt pro shrnutí explicitně požaduje učiněná rozhodnutí, protože shrnutí, které si ponechá pouze témata, způsobí, že model ztratí paměť na své vlastní závazky. A max_output_tokens=500 omezuje rozsah shrnutí: bez tohoto limitu by shrnutí rostlo s každou kompaktací a skončil bys přesně s tím problémem, který jsi se snažil eliminovat.
Dvě strategie, které musíš znát
Posuvné okno se shrnutím
Následující třída industrializuje tento princip. Udržuje jediné shrnutí, které přepisuje při každé kompaktaci integrací nových výměn, zatímco udržuje okno surových zpráv. Kontext odesílaný do API se tedy vždy skládá ze tří bloků: systémový prompt, kumulativní shrnutí a nedávné okno.
class CompactedConversation:
"""Spravuje konverzaci s automatickou kompaktací."""
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]:
"""Vytváří kontext k odeslání do 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:]
Všimni si, že _compact znovu vkládá existující shrnutí do promptu před nové výměny. To zabraňuje progresivní amnézii: bez tohoto znovu vložení by každá kompaktace smazala vše, co si ta předchozí zachovala.
Selektivní kompakce
Shrnutí je destruktivní a některý obsah nepřežije přeformulování. Úryvek kódu, odpověď JSON API nebo tabulka čísel ztrácí svou užitečnost, jakmile jsou parafrázovány. Selektivní kompakce proto nejprve třídí staré zprávy před shrnutím: ty obsahující kód nebo strukturovaná data projdou nedotčené, zatímco se komprimuje pouze konverzační text.
def selective_compaction(
messages: list[dict],
keep_recent: int = 6,
) -> list[dict]:
"""Kompaktuje při zachování strukturovaných zpráv nedotčených."""
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
to_summarize = []
to_keep = []
for msg in old_messages:
content = msg["content"]
# Zachování zpráv obsahujících kód nebo data
if "```" in content or "{" in content:
to_keep.append(msg)
else:
to_summarize.append(msg)
# Shrnutí pouze konverzačního textu
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
Kritérium třídění použité zde – přítomnost trojitých zpětných lomítek nebo složené závorky – je záměrně hrubé. Přizpůsob ho tomu, co tvoje nástroje skutečně produkují: pro asistenta, který zpracovává reference případů, můžeš chtít zachovat jakoukoli zprávu obsahující ID zákazníka.
Ověření, zda se kompakce vyplatí
Špatně nastavená kompakce stojí další volání API bez znatelného přínosu, nebo komprimuje tak agresivně, že model ztratí vlákno a ptá se na otázky, které jsou již vyřešeny. Proto změř poměr před fixací konečných prahů pomocí vzorku skutečných konverzací.
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),
}
Vezmi tucet přepisů ze svého produkčního prostředí, proveď jimi kompaktaci a přečti si vygenerovaná shrnutí: pokud nemůžeš na základě samotného shrnutí pokračovat v konverzaci, je tvůj práh příliš nízký nebo tvůj prompt pro shrnutí příliš vágní.
Klíčové poznatky
- Kompakce snižuje počet tokenů shrnutím starších zpráv
- Vždy udržuj nejnovější zprávy nedotčené (posuvné okno)
- Zachovávej zprávy obsahující kód nebo strukturovaná data
- Při každé nové kompaktaci znovu vlož existující shrnutí, abys předešel progresivní amnézii
- Změř poměr komprese pro kalibraci svých prahů