Kompaktavimas: ilgų pokalbių suspaudimas
Šiame puslapyje
Ilgų pokalbių problema
Kiekvienas pokalbiui pridėtas žinutės pranešimas padidina API siunčiamų tokenų skaičių. 50 ėjimų pokalbis lengvai gali pasiekti 30 000 įvesties tokenų, todėl didėja tiek delsos, tiek išlaidos. Problema yra klastinga: pirmasis pagalbos asistento ėjimas kainuoja kelis šimtus tokenų, o trisdešimtasis – kelis tūkstančius, nors vartotojas užduoda точно tokio paties tipo klausimą. Mokate vis daugiau už identišką paslaugą, o vartotojas laukia atsakymo vis ilgiau.
Kompaktavimas tai išsprendžia suspausdamas istoriją neprarandant esminės informacijos. Tai apima senesnių mainų apibendrinimą, siekiant sumažinti tokenų skaičių išlaikant būtiną kontekstą. Vietoj visos istorijos siuntimo siunčiate praeities mainų santrauką plus naujausius pranešimus. Modelis vis dar žino, kad kliento pavardė yra Dupont, kad jis turi ginčytiną užsakymą ir kad jau pasiūlėte grąžinti pinigus, nereikėdamas iš naujo perskaityti keturiasdešimties žinučių, kurios nustatė šiuos faktus.
Mechanizmas
Toliau pateikta funkcija taiko šią logiką paprasčiausia forma: ji įvertina apimtį, nieko nedaro, kol nepasiekiamas slenkstis, tada padalija istoriją į dvi dalis. Senesni pranešimai skirti santraukai; naujausi lieka nepakitę.
import openai
client = openai.OpenAI()
def compact_history(
messages: list[dict],
token_threshold: int = 10_000,
keep_recent: int = 6,
) -> list[dict]:
"""Compacts history when it exceeds the threshold."""
# Estimate token count (approximation)
estimated_tokens = sum(len(m["content"]) // 4 for m in messages)
if estimated_tokens < token_threshold:
return messages # No need to compact
# Split: old messages vs recent ones
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
# Summarize old messages
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,
)
# Rebuild compacted history
summary_message = {
"role": "system",
"content": f"Summary of previous conversation:\n{response.output_text}",
}
return [summary_message] + recent_messages
Du aspektai nusipelno tavo dėmesio. Santraukos raginimas aiškiai prašo įtraukti priimtus sprendimus, nes santrauka, išsauganti tik temas, priverčia modelį pamiršti savo įsipareigojimus. Be to, max_output_tokens=500 riboja santraukos dydį: be šio limito santrauka augtų su kiekvienu kompaktavimu ir galiausiai susidurtumėte būtent su ta problema, kurią bandėte pašalinti.
Dvi strategijos, kurias reikia žinoti
Slankusis langas su santrauka
Toliau pateikta klasė industrializuoja šį principą. Ji palaiko vieną santrauką, kurią perrašo kiekvieno kompaktavimo metu, integruodama naujus mainus, kartu išlaikydama žalių pranešimų langą. API siunčiamas kontekstą todėl visada sudaro trys blokai: sistemos raginimas, kaupiamoji santrauka ir naujausias langas.
class CompactedConversation:
"""Manages a conversation with automatic compaction."""
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]:
"""Builds the context to send to the 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:]
Atkreipk dėmesį, kad _compact prieš naujus mainus į raginimą vėl įterpia esamą santrauką. Tai apsaugo nuo progresuojančios amnezijos: be šio įterpimo kiekvienas kompaktavimas ištrintų viską, ką buvo išsaugojęs ankstesnis.
Atrankinis kompaktavimas
Apibendrinimas yra destruktyvus, ir kai kuri turinys neišgyvena performulavimo. Kodo fragmentas, JSON API atsakas arba skaičių lentelė praranda savo naudą, kai tik yra parafruojami. Todėl atrankinis kompaktavimas prieš apibendrinant rūšiuoja senus pranešimus: tie, kuriuose yra kodo arba struktūrizuotų duomenų, praeina nepakitę, o suspaudžiamas tik pokalbių tekstas.
def selective_compaction(
messages: list[dict],
keep_recent: int = 6,
) -> list[dict]:
"""Compacts while keeping structured messages intact."""
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
to_summarize = []
to_keep = []
for msg in old_messages:
content = msg["content"]
# Keep messages containing code or data
if "```" in content or "{" in content:
to_keep.append(msg)
else:
to_summarize.append(msg)
# Summarize only conversational text
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
Čia naudojamas rūšiavimo kriterijus – trigubų atvirkštinių kabučių arba figūrinių skliaustų buvimas – sąmoningai yra grubus. Pritaikyk jį tam, ką iš tikrųjų generuoja tavo įrankiai: pavyzdžiui, asistentui, tvarkančiam bylų nuorodas, gali tekti išsaugoti bet kurį pranešimą, kuriame yra kliento ID.
Tikrinimas, ar kompaktavimas vertas efforto
Netinkamai sureguliuotas kompaktavimas kainuoja papildomą API užklausą be pastebimos naudos arba suspaudžia taip agresyviai, kad modelis praranda siūlą ir pradeda klausti klausimų, į kuriuos jau buvo atsakyta. Todėl prieš nustatydami galutinius slenksčius išmatuokite santykį naudodami realių pokalbių imtį.
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),
}
Paimk tuziną transkriptų iš savo gamybinės aplinkos, paleisk juos per kompaktavimą ir perskaityk sugeneruotas santraukas: jei negali tęsti pokalbio remdamasis tik santrauka, tavo slenkstis yra per žemas arba santraukos raginimas per daug miglotas.
Svarbiausi punktai
- Kompaktavimas sumažina tokenų skaičių apibendrinant senesnius pranešimus
- Visada palikite naujausius pranešimus nepaliestus (slankusis langas)
- Išsaugokite pranešimus, kuriuose yra kodo arba struktūrizuotų duomenų
- Kiekvieno naujo kompaktavimo metu vėl įterpkite esamą santrauką, kad išvengtumėte progresuojančios amnezijos
- Išmatuokite suspaudimo santykį, kad tinkamai sureguliuotumėte savo slenksčius