Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Kompakció: Hosszú beszélgetések tömörítése

11. lecke 20 közül Frissítve 2026. július 28. Haladó
Ezen az oldalon
  1. A hosszú beszélgetések problémája
  2. Két stratégia, amit ismerned kell
  3. Annak ellenőrzése, hogy megéri-e a kompakció
  4. Főbb megállapítások

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