Kompakcija: Sažimanje dugih razgovora
Na ovoj stranici
Problem s dugim razgovorima
Svaka poruka dodana u razgovor povećava broj tokena poslanih API-ju. Razgovor od 50 izmjena lako može doseći 30 000 ulaznih tokena, što podiže i latenciju i troškove. Problem je podmukao: prvi zahtjev asistenta za podršku košta nekoliko stotina tokena, dok trideseti košta nekoliko tisuća, iako korisnik postavlja istu vrstu pitanja. Plaćaš sve više za identičnu uslugu, a korisnik čeka sve duže na odgovor.
Kompakcija to rješava komprimiranjem povijesti bez gubitka bitnih informacija. To uključuje sažimanje starijih razmjena radi smanjenja broja tokena uz očuvanje potrebnog konteksta. Umjesto slanja cijele povijesti, šalješ sažetak prošlih razmjena plus najnovije poruke. Model i dalje zna da se korisnik preziva Dupont, da ima sporan nalog i da si već ponudio povrat novca, a da ne mora ponovno čitati četrdeset poruka koje su utvrdile te činjenice.
Mehanizam
Funkcija u nastavku primjenjuje ovu logiku u najjednostavnijem obliku: procjenjuje volumen, ne radi ništa dok se ne prijeđe prag, zatim dijeli povijest na dva dijela. Starije poruke idu u sažetak; najnovije ostaju nepromijenjene.
import openai
client = openai.OpenAI()
def compact_history(
messages: list[dict],
token_threshold: int = 10_000,
keep_recent: int = 6,
) -> list[dict]:
"""Kompaktira povijest kada prijeđe prag."""
# Procjena broja tokena (aproksimacija)
estimated_tokens = sum(len(m["content"]) // 4 for m in messages)
if estimated_tokens < token_threshold:
return messages # Nema potrebe za kompakcijom
# Podjela: stare poruke naspram novijih
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
# Sažmi stare poruke
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,
)
# Ponovno izgradi kompaktnu povijest
summary_message = {
"role": "system",
"content": f"Summary of previous conversation:\n{response.output_text}",
}
return [summary_message] + recent_messages
Dva detalja zaslužuju tvoju pažnju. Upit za sažetak izričito traži donesene odluke jer sažetak koji zadržava samo teme uzrokuje da model izgubi pamćenje vlastitih obveza. A max_output_tokens=500 ograničava sažetak: bez ovog ograničenja, sažetak bi rastao sa svakom kompakcijom i završio bi s upravo onim problemom koji si pokušavao eliminirati.
Dvije strategije koje trebaš znati
Klizni prozor sa sažetkom
Sljedeća klasa industrijalizira ovaj princip. Održava jedan sažetak koji prepisuje pri svakoj kompakciji integriranjem novih razmjena, dok zadržava prozor sirovih poruka. Kontekst poslan API-ju stoga se uvijek sastoji od tri bloka: sistemskog upita, kumulativnog sažetka i nedavnog prozora.
class CompactedConversation:
"""Upravlja razgovorom s automatskom kompakcijom."""
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]:
"""Gradi kontekst za slanje API-ju."""
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:]
Imaj na umu da _compact ponovno ubacuje postojeći sažetak u upit prije novih razmjena. To sprječava progresivnu amneziju: bez ovog ponovnog ubacivanja, svaka bi kompakcija izbrisala sve što je prethodna zadržala.
Selektivna kompakcija
Sažimanje je destruktivno i neki sadržaj ne preživljava preformulaciju. Isječak koda, JSON odgovor API-ja ili tablica s brojčanim podacima gubi svoju korisnost čim se parafrazira. Selektivna kompakcija stoga sortira stare poruke prije sažimanja: one koje sadrže kod ili strukturirane podatke prolaze netaknute, dok se samo konverzacijski tekst komprimira.
def selective_compaction(
messages: list[dict],
keep_recent: int = 6,
) -> list[dict]:
"""Kompaktira uz zadržavanje strukturiranih poruka netaknutima."""
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
to_summarize = []
to_keep = []
for msg in old_messages:
content = msg["content"]
# Zadrži poruke koje sadrže kod ili podatke
if "```" in content or "{" in content:
to_keep.append(msg)
else:
to_summarize.append(msg)
# Sažmi samo konverzacijski tekst
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
Kriterij sortiranja korišten ovdje – prisutnost trostrukih obrnutih navodnika ili vitičaste zagrade – namjerno je grub. Prilagodi ga onome što tvoji alati zapravo proizvode: za asistenta koji obrađuje reference predmeta, možda ćeš htjeti sačuvati svaku poruku koja sadrži ID korisnika.
Provjera isplativosti kompakcije
Loše kalibrirana kompakcija košta dodatni API poziv bez primjetne dobiti ili komprimira tako agresivno da model gubi nit i postavlja pitanja koja su već riješena. Stoga izmjeri omjer prije nego što fiksiraš konačne pragove, koristeći uzorak stvarnih razgovora.
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),
}
Uzmi desetak transkripata iz svog produkcijskog okruženja, provedi ih kroz kompakciju i pročitaj proizvedene sažetke: ako ne možeš nastaviti razgovor temeljem samo sažetka, tvoj prag je prenizak ili je tvoj upit za sažetak previše nejasan.
Ključne točke
- Kompakcija smanjuje broj tokena sažimanjem starijih poruka
- Uvijek zadrži najnovije poruke netaknutima (klizni prozor)
- Sačuvaj poruke koje sadrže kod ili strukturirane podatke
- Ponovno ubaci postojeći sažetak pri svakoj novoj kompakciji kako bi izbjegao progresivnu amneziju
- Izmjeri omjer kompresije kako bi kalibrirao svoje pragove