Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Kompakcija: Sažimanje dugih razgovora

Lekcija 11 od 20 Ažurirano 28. srpnja 2026. Napredno
Na ovoj stranici
  1. Problem s dugim razgovorima
  2. Dvije strategije koje trebaš znati
  3. Provjera isplativosti kompakcije
  4. Ključne točke

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