Kompakció: Hosszú beszélgetések tömörítése
Ezen az oldalon
A hosszú beszélgetések problémája
Minden egyes üzenet, amit hozzáadsz a beszélgetéshez, növeli az API-nak küldött tokenek számát. Egy 50 fordulóból álló beszélgetés könnyen elérheti a 30 000 bemeneti tokent, ami növeli a késleltetést és a költségeket is. A probléma alattomos: egy támogatási asszisztens első fordulója néhány száz tokenbe kerül, míg a harcadik forduló már több ezerbe, még akkor is, ha a felhasználó pontosan ugyanolyan típusú kérdést tesz fel. Egyre többet fizetsz egy azonos szolgáltatásért, a felhasználónak pedig egyre tovább kell várnia a válaszra.
A kompakció ezt úgy oldja meg, hogy tömöríti az előzményeket anélkül, hogy elveszítené a lényeges információkat. Ez a régebbi váltások összefoglalását jelenti a tokenszám csökkentése érdekében, miközben megőrzi a szükséges kontextust. A teljes előzmények elküldése helyett a múltbeli váltások összefoglalását és a legfrissebb üzeneteket küldöd el. A modell így továbbra is tudja, hogy az ügyfél neve Dupont, vitatott rendelése van, és már ajánlottál visszatérítést, anélkül, hogy újra el kellene olvasnia a negyven üzenetet, amelyek ezeket a tényeket rögzítették.
A mechanizmus
Az alábbi függvény ennek a logikának a legegyszerűbb formáját alkalmazza: becslést végez a volumenről, nem tesz semmit, amíg a küszöbértéket el nem éri, majd két részre osztja az előzményeket. A régebbi üzenetek az összefoglalásba kerülnek; a legfrissebbek változatlanul maradnak.
import openai
client = openai.OpenAI()
def compact_history(
messages: list[dict],
token_threshold: int = 10_000,
keep_recent: int = 6,
) -> list[dict]:
"""Tömöríti az előzményeket, ha azok meghaladják a küszöbértéket."""
# Tokenek számának becslése (közelítés)
estimated_tokens = sum(len(m["content"]) // 4 for m in messages)
if estimated_tokens < token_threshold:
return messages # Nincs szükség tömörítésre
# Szétválasztás: régi üzenetek vs. legfrissebbek
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
# Régi üzenetek összefoglalása
old_text = "\n".join(
f"{m['role']}: {m['content']}" for m in old_messages
)
response = client.responses.create(
model="gpt-5.6-terra",
input=(
"Foglald össze tömören ezt a beszélgetést. "
"Tartsd meg a kulcsfontosságú tényeket, a meghozott döntéseket, "
"és a kontextust, ami szükséges a folytatás megértéséhez.\n\n"
f"{old_text}"
),
max_output_tokens=500,
)
# Tömörített előzmények újjáépítése
summary_message = {
"role": "system",
"content": f"Előző beszélgetés összefoglalója:\n{response.output_text}",
}
return [summary_message] + recent_messages
Két részletre érdemes figyelned. Az összefoglaló prompt kifejezetten kéri a meghozott döntéseket, mert egy olyan összefoglaló, amely csak a témákat tartja meg, arra készteti a modellt, hogy elfelejtse a saját vállalásait. A max_output_tokens=500 pedig korlátozza az összefoglalót: e korlát nélkül az összefoglaló minden kompakcióval nőne, és végül pontosan azt a problémát okoznád, amit meg akartál szüntetni.
Két stratégia, amit ismerned kell
Csúszó ablak összefoglalóval
Az alábbi osztály iparosítja ezt az elvet. Egyetlen összefoglalót tart fenn, amelyet minden kompakciónál átír az új váltások integrálásával, miközben megőrzi a nyers üzenetek ablakát. Az API-nak küldött kontextus tehát mindig három blokkból áll: a rendszerprompt, a kumulatív összefoglaló és a legfrissebb ablak.
class CompactedConversation:
"""Automatikus kompakcióval kezeli a beszélgetést."""
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]:
"""Felépíti az API-nak küldendő kontextust."""
context = [{"role": "system", "content": self.system_prompt}]
if self.summary:
context.append({
"role": "system",
"content": f"Előző kontextus: {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"Meglévő összefoglaló: {self.summary}\n\n" if self.summary else ""
response = client.responses.create(
model="gpt-5.6-terra",
input=(
f"{existing_context}"
f"Új váltások az összefoglalóba integrálva:\n{text}\n\n"
"Készíts egy frissített, tömör és tényalapú összefoglalót."
),
max_output_tokens=400,
)
self.summary = response.output_text
self.messages = self.messages[-self.window_size:]
Figyeld meg, hogy a _compact módszer visszainjektálja a meglévő összefoglalót a promptba az új váltások előtt. Ez megakadályozza a progresszív amnéziát: e visszainjektálás nélkül minden kompakció törölné mindazt, amit az előző megőrzött.
Szelektív kompakció
Az összefoglalás romboló hatású, és egyes tartalmak nem élik túl az átfogalmazást. Egy kódrészlet, egy JSON API-válasz vagy egy számadatokból álló táblázat elveszíti hasznosságát, amint átfogalmazzák. A szelektív kompakció ezért válogat a régi üzenetek között az összefoglalás előtt: a kódot vagy strukturált adatokat tartalmazók érintetlenül maradnak, míg csak a beszélgetési szöveget tömöríti.
def selective_compaction(
messages: list[dict],
keep_recent: int = 6,
) -> list[dict]:
"""Tömörít, miközben a strukturált üzeneteket érintetlenül hagyja."""
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
to_summarize = []
to_keep = []
for msg in old_messages:
content = msg["content"]
# Kódot vagy adatot tartalmazó üzenetek megtartása
if "```" in content or "{" in content:
to_keep.append(msg)
else:
to_summarize.append(msg)
# Csak a beszélgetési szöveg összefoglalása
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"Foglald össze ezeket a váltásokat 3 mondatban:\n{text}",
max_output_tokens=200,
)
summary = response.output_text
result = []
if summary:
result.append({
"role": "system",
"content": "Váltások összefoglalója: {summary}",
})
result.extend(to_keep)
result.extend(recent_messages)
return result
Az itt használt rendezési kritérium – három backtick vagy egy kapcsos zárójel jelenléte – szándékosan durva. Igazítsd ahhoz, amit az eszközeid valójában produkálnak: egy ügyfélszámokat kezelő asszisztens esetén például érdemes lehet megőrizni minden olyan üzenetet, amely ügyfélazonosítót tartalmaz.
Annak ellenőrzése, hogy megéri-e a kompakció
A rosszul bekalibrált kompakció plusz egy API-hívásba kerül észrevehető haszon nélkül, vagy olyan agresszíven tömörít, hogy a modell elveszíti a fonalat, és olyan kérdéseket tesz fel, amelyekre már választ kapott. Ezért a végső küszöbértékek rögzítése előtt mérd le az arányt valós beszélgetések mintáján.
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égy egy tucat transzkriptumot a production környezetedből, futtasd át őket a kompakción, és olvasd el a létrehozott összefoglalókat: ha az összefoglaló alapján egyedül nem tudod folytatni a beszélgetést, akkor a küszöbértéked túl alacsony, vagy az összefoglaló promptod túl homályos.
Főbb megállapítások
- A kompakció csökkenti a tokenek számát a régebbi üzenetek összefoglalásával
- Mindig tartsd meg a legfrissebb üzeneteket érintetlenül (csúszó ablak)
- Őrizd meg a kódot vagy strukturált adatokat tartalmazó üzeneteket
- Injektáld vissza a meglévő összefoglalót minden új kompakciónál a progresszív amnézia elkerülése érdekében
- Mérd le a tömörítési arányt a küszöbértékek bekalibrálásához