Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Kompaktointi: Pitkien keskustelujen tiivistäminen

Oppitunti 11 / 20 Päivitetty 28. heinäkuuta 2026 Edistynyt
Tällä sivulla
  1. Pitkien keskustelujen ongelma
  2. Kaksi strategiaa, jotka sinun tulee tuntea
  3. Varmista, että kompaktointi kannattaa
  4. Keskeiset asiat

Pitkien keskustelujen ongelma

Jokainen keskusteluun lisätty viesti kasvattaa rajapinnalle lähetettävien tokenien määrää. 50 vuorovaikutuskerran keskustelu voi helposti ylittää 30 000 syötetokenia, mikä nostaa sekä viivettä että kustannuksia. Ongelma on salakavala: tukiasistentin ensimmäinen vuorokerta maksaa muutaman sadan tokenia, kun taas kolmaskymmenes vuorokerta maksaa useita tuhansia, vaikka käyttäjä esittää täsmälleen samantyyppisen kysymyksen. Maksat yhä enemmän identtisestä palvelusta, ja käyttäjä odottaa yhä kauemmin vastausta.

Kompaktointi ratkaisee tämän tiivistämällä historiaa menettämättä olennaista tietoa. Se tarkoittaa vanhempien vaiheiden tiivistämistä tokenimäärän vähentämiseksi säilyttäen samalla tarvittavan kontekstin. Koko historian lähettämisen sijaan lähetät yhteenvedon menneistä vaiheista plus viimeisimmät viestit. Malli tietää edelleen, että asiakkaan nimi on Dupont, että heillä on riitautettu tilaus ja että olet jo tarjonnut hyvitystä, ilman että sen tarvitsee lukea uudelleen neljääkymmentä viestiä, jotka nämä faktat osoittivat.

Mekanismi

Alla oleva funktio soveltaa tätä logiikkaa yksinkertaisimmassa muodossaan: se arvioi volyymin, ei tee mitään ennen kuin kynnysarvo ylittyy, ja jakaa sitten historian kahteen osaan. Vanhemmat viestit menevät yhteenvetoon; viimeisimmät pysyvät sellaisinaan.

import openai

client = openai.OpenAI()

def compact_history(
    messages: list[dict],
    token_threshold: int = 10_000,
    keep_recent: int = 6,
) -> list[dict]:
    """Tiivistää historian, kun se ylittää kynnysarvon."""

    # Arvioi tokenien määrä (likiarvo)
    estimated_tokens = sum(len(m["content"]) // 4 for m in messages)

    if estimated_tokens < token_threshold:
        return messages  # Tiivistämistä ei tarvita

    # Jaa: vanhat viestit vs. viimeisimmät
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    # Tiivistä vanhat viestit
    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,
    )

    # Rakenna tiivistetty historia uudelleen
    summary_message = {
        "role": "system",
        "content": f"Summary of previous conversation:\n{response.output_text}",
    }

    return [summary_message] + recent_messages

Kaksi yksityiskohtaa ansaitsevat huomiosi. Yhteenvetokehote pyytää nimenomaan tehtyjä päätöksiä, koska yhteenveto, joka säilyttää vain teemat, saa mallin unohtamaan omat sitoumuksensa. Ja max_output_tokens=500 rajoittaa yhteenvedon kokoa: ilman tätä rajaa yhteenveto kasvaa jokaisen kompaktointikerran myötä, ja päädyt juuri siihen ongelmaan, jota yritit poistaa.

Kaksi strategiaa, jotka sinun tulee tuntea

Liukuva ikkuna yhteenvedolla

Seuraava luokka teollistaa periaatteen. Se ylläpitää yhtä yhteenvetoa, jonka se kirjoittaa uudelleen jokaisen kompaktoinnin yhteydessä integroimalla uudet vaiheet, pitäen samalla yllä raakaviestien ikkunaa. Rajapinnalle lähetettävä konteksti koostuu siis aina kolmesta lohkosta: järjestelmäkehotteesta, kumulatiivisesta yhteenvedosta ja viimeisimmästä ikkunasta.

class CompactedConversation:
    """Hallitsee keskustelua automaattisella kompaktioinnilla."""

    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]:
        """Rakentaa rajapinnalle lähetettävän kontekstin."""
        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:]

Huomaa, että _compact syöttää olemassa olevan yhteenvedon uudelleen kehoteeseen ennen uusia vaiheita. Tämä estää progressiivisen muistinmenetyksen: ilman tätä uudelleensyöttöä jokainen kompaktointi pyyhkisi pois kaiken, mitä edellinen oli säilyttänyt.

Valikoiva kompaktointi

Tiivistäminen on tuhoisaa, eikä kaikki sisältö kestä uudelleenmuotoilua. Koodinpätkä, JSON-rajapintavastaus tai taulukko lukuineen menettää hyödyllisyytensä heti, kun sitä paraphrasoidaan. Valikoiva kompaktointi lajittelee siis vanhat viestit ennen tiivistämistä: koodia tai jäsenneltyä dataa sisältävät viestit kulkevat ehjinä, kun taas vain keskusteluteksti tiivistetään.

def selective_compaction(
    messages: list[dict],
    keep_recent: int = 6,
) -> list[dict]:
    """Tiivistää säilyttäen jäsennellyt viestit ehjinä."""
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    to_summarize = []
    to_keep = []

    for msg in old_messages:
        content = msg["content"]
        # Säilytä koodia tai dataa sisältävät viestit
        if "```" in content or "{" in content:
            to_keep.append(msg)
        else:
            to_summarize.append(msg)

    # Tiivistä vain keskusteluteksti
    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

Tässä käytetty lajittelukriteeri – kolmen takakenoviivan tai aaltosulkeen esiintyminen – on tarkoituksellisen karkea. Sovita se siihen, mitä työkalusi todellisuudessa tuottavat: esimerkiksi tapauksia käsittelevälle assistentille saatat haluta säilyttää kaikki viestit, jotka sisältävät asiakastunnuksen.

Varmista, että kompaktointi kannattaa

Huonosti kalibroitu kompaktointi maksaa ylimääräisen rajapintakutsun ilman havaittavaa hyötyä, tai tiivistää niin aggressiivisesti, että malli menettää langan ja kysyy jo ratkaistuja kysymyksiä. Mittaa siis suhde ennen lopullisten kynnysarvojen lukitsemista käyttämällä otosta aidosta tuotantokeskustelusta.

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),
    }

Ota tusina litterointia tuotantoympäristöstäsi, aja ne kompaktioinnin läpi ja lue tuotetut yhteenvedot: jos et pysty jatkamaan keskustelua pelkän yhteenvedon perusteella, kynnysarvosi on liian matala tai yhteenvetokehotteesi liian epämääräinen.

Keskeiset asiat

  • Kompaktointi vähentäjä tokeneita tiivistämällä vanhempia viestejä
  • Säilytä aina viimeisimmät viestit ehjinä (liukuva ikkuna)
  • Säilytä viestit, jotka sisältävät koodia tai jäsenneltyä dataa
  • Syötä olemassa oleva yhteenveto uudelleen jokaisen uuden kompaktioinnin yhteydessä välttääksesi progressiivista muistinmenetystä
  • Mittaa pakkaussuhdetta kalibroidaksesi kynnysarvosi