Przejdź do głównej treści
Polski— Wybierz język
Menu

Kompaktowanie: kompresja długich rozmów

Lekcja 11 z 20 Zaktualizowano 28 lipca 2026 Zaawansowany
Na tej stronie
  1. Problem z długimi rozmowami
  2. Dwie strategie, które musisz znać
  3. Weryfikacja opłacalności kompaktowania
  4. Kluczowe wnioski

Problem z długimi rozmowami

Każda wiadomość dodana do rozmowy zwiększa liczbę tokenów wysyłanych do API. Rozmowa składająca się z 50 tur może łatwo osiągnąć 30 000 tokenów wejściowych, co podnosi zarówno opóźnienia, jak i koszty. Problem jest podstępny: pierwsza tura działania asystenta wsparcia kosztuje kilka setek tokenów, podczas gdy trzydziesta tura kosztuje kilka tysięcy, mimo że użytkownik zadaje dokładnie ten sam typ pytania. Płacisz coraz więcej za identyczną usługę, a użytkownik czeka coraz dłużej na odpowiedź.

Kompaktowanie rozwiązuje ten problem poprzez kompresję historii bez utraty istotnych informacji. Polega ono na podsumowaniu starszych wymian w celu zmniejszenia liczby tokenów przy jednoczesnym zachowaniu niezbędnego kontekstu. Zamiast wysyłać całą historię, wysyłasz podsumowanie przeszłych wymian wraz z najnowszymi wiadomościami. Model nadal wie, że klient nazywa się Dupont, że ma sporne zamówienie i że już zaproponowano mu zwrot pieniędzy, bez konieczności ponownego czytania czterdziestu wiadomości, które ustaliły te fakty.

Mechanizm

Poniższa funkcja stosuje tę logikę w najprostszej formie: szacuje objętość, nie robi nic, dopóki próg nie zostanie przekroczony, a następnie dzieli historię na dwie części. Starsze wiadomości trafiają do podsumowania; najnowsze pozostają bez zmian.

import openai

client = openai.OpenAI()

def compact_history(
    messages: list[dict],
    token_threshold: int = 10_000,
    keep_recent: int = 6,
) -> list[dict]:
    """Kompaktuje historię, gdy przekracza ona próg."""

    # Szacowanie liczby tokenów (przybliżenie)
    estimated_tokens = sum(len(m["content"]) // 4 for m in messages)

    if estimated_tokens < token_threshold:
        return messages  # Nie ma potrzeby kompaktowania

    # Podział: stare wiadomości vs najnowsze
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    # Podsumowanie starych wiadomości
    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,
    )

    # Odbudowa skompaktowanej historii
    summary_message = {
        "role": "system",
        "content": f"Summary of previous conversation:\n{response.output_text}",
    }

    return [summary_message] + recent_messages

Dwa szczegóły zasługują na Twoją uwagę. Monit podsumowujący wyraźnie żąda uwzględnienia podjętych decyzji, ponieważ podsumowanie zachowujące tylko tematy powoduje, że model traci pamięć o własnych zobowiązaniach. Parametr max_output_tokens=500 ogranicza długość podsumowania: bez tego limitu podsumowanie rosłoby przy każdym kompaktowaniu i skończyłbyś z dokładnie tym problemem, który próbowałeś wyeliminować.

Dwie strategie, które musisz znać

Okno przesuwne z podsumowaniem

Poniższa klasa uprzemysławia tę zasadę. Utrzymuje ona pojedyncze podsumowanie, które przepisuje przy każdym kompaktowaniu, integrując nowe wymiany, jednocześnie zachowując okno surowych wiadomości. Kontekst wysyłany do API składa się zatem zawsze z trzech bloków: monitu systemowego, skumulowanego podsumowania oraz ostatniego okna wiadomości.

class CompactedConversation:
    """Zarządza rozmową z automatycznym kompaktowaniem."""

    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]:
        """Buduje kontekst do wysłania do API."""
        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:]

Zauważ, że metoda _compact ponownie wprowadza istniejące podsumowanie do monitu przed dodaniem nowych wymian. Zapobiega to postępującej amnezji: bez tego ponownego wprowadzenia każde kompaktowanie wymazywałoby wszystko, co zachowało poprzednie.

Kompaktowanie selektywne

Podsumowywanie jest destrukcyjne i niektóre treści nie przetrwają przeformułowania. Fragment kodu, odpowiedź API w formacie JSON czy tabela z danymi liczbowymi tracą swoją użyteczność, gdy zostaną sparafrazowane. Kompaktowanie selektywne sortuje zatem stare wiadomości przed podsumowaniem: te zawierające kod lub dane strukturalne przechodzą nienaruszone, podczas gdy kompresowany jest tylko tekst konwersacyjny.

def selective_compaction(
    messages: list[dict],
    keep_recent: int = 6,
) -> list[dict]:
    """Kompaktuje, zachowując nienaruszone wiadomości strukturalne."""
    old_messages = messages[:-keep_recent]
    recent_messages = messages[-keep_recent:]

    to_summarize = []
    to_keep = []

    for msg in old_messages:
        content = msg["content"]
        # Zachowaj wiadomości zawierające kod lub dane
        if "```" in content or "{" in content:
            to_keep.append(msg)
        else:
            to_summarize.append(msg)

    # Podsumuj tylko tekst konwersacyjny
    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

Kryterium sortowania użyte tutaj – obecność potrójnych backticków lub nawiasu klamrowego – jest celowo prymitywne. Dostosuj je do tego, co faktycznie generują Twoje narzędzia: w przypadku asystenta obsługującego odwołania do spraw możesz chcieć zachować każdą wiadomość zawierającą ID klienta.

Weryfikacja opłacalności kompaktowania

Źle skalibrowane kompaktowanie kosztuje dodatkowe wywołanie API bez zauważalnej korzyści lub kompresuje tak agresywnie, że model gubi wątek i zadaje pytania, na które już odpowiedziano. Dlatego przed ustaleniem końcowych progów zmierz współczynnik kompresji, używając próbki rzeczywistych rozmów.

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

Weź tuzin transkryptów ze swojego środowiska produkcyjnego, poddaj je procesowi kompaktowania i przeczytaj wygenerowane podsumowania: jeśli nie jesteś w stanie kontynuować rozmowy, bazując wyłącznie na podsumowaniu, Twój próg jest zbyt niski lub monit podsumowujący zbyt ogólny.

Kluczowe wnioski

  • Kompaktowanie redukuje liczbę tokenów poprzez podsumowywanie starszych wiadomości
  • Zawsze zachowuj najnowsze wiadomości w nienaruszonej formie (okno przesuwne)
  • Zachowuj wiadomości zawierające kod lub dane strukturalne
  • Ponownie wprowadzaj istniejące podsumowanie przy każdym nowym kompaktowaniu, aby uniknąć postępującej amnezji
  • Mierz współczynnik kompresji, aby odpowiednio skalibrować swoje progi