Kompaktimine: pikkade vestluste tihendamine
Sellel lehel
Pikkade vestluste probleem
Iga vestlusele lisatud sõnum suurendab API-le saadetavate tokenite arvu. 50 pöördega vestlus võib hõlpsasti jõuda 30 000 sisendtokenini, mis tõstab nii latentsust kui ka kulusid. Probleem on salakaval: tugiteenuse assistendi esimene pööre maksab paar sada tokenit, samas kui kolmekümnes pööre maksab mitu tuhat, kuigi kasutaja küsib täpselt sama tüüpi küsimust. Sa maksad üha rohkem identse teenuse eest ja kasutaja ootab vastust üha kauem.
Kompaktimine lahendab selle, tihendades ajalugu ilma olulist teavet kaotamata. See hõlmab vanemate vahetuste kokkuvõtmist tokenite arvu vähendamiseks, säilitades samal ajal vajaliku konteksti. Kogu ajaloo saatmise asemel saadad mineviku vahetuste kokkuvõtte koos viimaste sõnumitega. Mudel teab endiselt, et kliendi nimi on Dupont, et tal on vaidlustatud tellimus ja et oled juba tagasimakset pakkunud, ilma et peaks uuesti läbi lugema neljakümmet sõnumit, mis need faktid kindlaks tegid.
Mehhanism
Allpool olev funktsioon rakendab seda loogikat oma lihtsaimal kujul: see hindab mahtu, ei tee midagi enne lävendi ületamist ja jagab seejärel ajaloo kaheks osaks. Vanemad sõnumid lähevad kokkuvõttesse; kõige uuemad jäävad muutmata.
import openai
client = openai.OpenAI()
def compact_history(
messages: list[dict],
token_threshold: int = 10_000,
keep_recent: int = 6,
) -> list[dict]:
"""Tihendab ajaloo, kui see ületab lävendi."""
# Hinda tokenite arvu (ligikaudne)
estimated_tokens = sum(len(m["content"]) // 4 for m in messages)
if estimated_tokens < token_threshold:
return messages # Tihendamine pole vajalik
# Jaota: vanad sõnumid vs viimased
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
# Võta vanadest sõnumitest kokkuvõte
old_text = "\n".join(
f"{m['role']}: {m['content']}" for m in old_messages
)
response = client.responses.create(
model="gpt-5.6-terra",
input=(
"Võta sellest vestlusest lühike kokkuvõte. "
"Jäta alles peamised faktilised andmed, tehtud otsused "
"ja kontekst, mis on vajalik järgneva mõistmiseks.\n\n"
f"{old_text}"
),
max_output_tokens=500,
)
# Taasta tihendatud ajalugu
summary_message = {
"role": "system",
"content": f"Eelmise vestluse kokkuvõte:\n{response.output_text}",
}
return [summary_message] + recent_messages
Kaks detaili väärivad tähelepanu. Kokkuvõtte viip palub sõnaselgelt tehtud otsuseid, sest kokkuvõte, mis säilitab ainult teemad, paneb mudeli unustama oma enda kohustused. Ja max_output_tokens=500 piirab kokkuvõtet: ilma selle piiranguta kasvaks kokkuvõte iga tihendamisega ja lõpetaksid täpselt selle probleemiga, mida püüdsid kõrvaldada.
Kaks strateegiat, mida tundma õppida
Liuguv aken koos kokkuvõttega
Järgnev klass industrialiseerib põhimõtet. See haldab ühte kokkuvõtet, mida kirjutatakse iga tihendamise korral ümber, integreerides uusi vahetusi, hoides samal ajal toorsõnumite akent. API-le saadetav kontekst koosneb seega alati kolmest plokist: süsteemiviip, kumulatiivne kokkuvõte ja viimane aken.
class CompactedConversation:
"""Haldab vestlust automaatse tihendamisega."""
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]:
"""Ehitab API-le saadetava konteksti."""
context = [{"role": "system", "content": self.system_prompt}]
if self.summary:
context.append({
"role": "system",
"content": f"Eelnev kontekst: {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"Olemasolev kokkuvõte: {self.summary}\n\n" if self.summary else ""
response = client.responses.create(
model="gpt-5.6-terra",
input=(
f"{existing_context}"
f"Uued vahetused, mis tuleb kokkuvõttesse integreerida:\n{text}\n\n"
"Koosta uuendatud, lühike ja faktiline kokkuvõte."
),
max_output_tokens=400,
)
self.summary = response.output_text
self.messages = self.messages[-self.window_size:]
Pane tähele, et _compact sisestab olemasoleva kokkuvõtte enne uusi vahetusi uuesti viipa. See hoiab ära progresseeruva amneesia: ilma selle uuesti sisestamiseta kustutaks iga tihendamine kõik, mida eelmine oli säilitanud.
Valikuline tihendamine
Kokkuvõtete tegemine on destruktiivne ja mõni sisu ei ela ümberformuleerimist üle. Koodilõik, JSON-API vastus või arvude tabel kaotab oma kasulikkuse niipea, kui seda parafraseeritakse. Valikuline tihendamine sorteerib seega vanad sõnumid enne kokkuvõtte tegemist: need, mis sisaldavad koodi või struktureeritud andmeid, läbivad protsessi muutumatuna, samal ajal kui tihendatakse ainult vestlusteksti.
def selective_compaction(
messages: list[dict],
keep_recent: int = 6,
) -> list[dict]:
"""Tihendab, hoides struktureeritud sõnumid muutmatuna."""
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
to_summarize = []
to_keep = []
for msg in old_messages:
content = msg["content"]
# Säilita koodi või andmeid sisaldavad sõnumid
if "```" in content or "{" in content:
to_keep.append(msg)
else:
to_summarize.append(msg)
# Võta kokkuvõte ainult vestlustekstist
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"Võta nendest vahetustest 3 lausega kokkuvõte:\n{text}",
max_output_tokens=200,
)
summary = response.output_text
result = []
if summary:
result.append({
"role": "system",
"content": f"Vahetuste kokkuvõte: {summary}",
})
result.extend(to_keep)
result.extend(recent_messages)
return result
Siin kasutatud sorteerimiskriteerium – kolme tagurpidi komaga või looksulu olemasolu – on tahtlikult toores. Kohanda seda selle järgi, mida sinu tööriistad tegelikult toodavad: näiteks juhtumeid haldava assistendi puhul võid soovida säilitada iga sõnumi, mis sisaldab kliendi ID-d.
Kontrolli, kas tihendamine on seda väärt
Halvasti kalibreeritud tihendamine toob kaasa täiendava API kõne ilma märgatava kasuta või tihendab nii agressiivselt, et mudel kaotab niidi otsa ja küsib juba lahendatud küsimusi. Seetõttu mõõda suhet enne lõplike lävendite fikseerimist, kasutades reaalsete vestluste valimit.
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),
}
Võta tootmiskeskkonnast tosin transkripti, lase need läbi tihendamise ja loe loodud kokkuvõtteid: kui sa ei saa vestlust jätkata ainult kokkuvõtte põhjal, on sinu lävend liiga madal või kokkuvõtte viip liiga ebamäärane.
Peamised punktid
- Kompaktimine vähendab tokeneid, võttes vanematest sõnumitest kokkuvõtte
- Säilita alati kõige uuemad sõnumid muutumatuna (liuguv aken)
- Säilita koodi või struktureeritud andmeid sisaldavad sõnumid
- Sisesta olemasolev kokkuvõte iga uue tihendamise korral uuesti, et vältida progresseeruvat amneesiat
- Mõõda tihendussuhet oma lävendite kalibreerimiseks