Kompaktowanie: kompresja długich rozmów
Na tej stronie
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