Kompakcija: Garu sarunu saspiešana
Šajā lapā
Problēma ar garām sarunām
Katrs ziņojums, kas pievienots sarunai, palielina API nosūtāmo tokenus skaitu. 50 soļu saruna var viegli sasniegt 30 000 ievades tokenus, kas palielina gan latentumu, gan izmaksas. Problēma ir mānīga: atbalsta asistenta pirmais solis maksā dažus simtus tokenus, bet trīsdesmitais solis maksā vairākus tūkstošus, lai gan lietotājs uzdod tieši tāda paša veida jautājumu. Tu maksā arvien vairāk par identisku pakalpojumu, un lietotājs gaida arvien ilgāk uz atbildi.
Kompakcija to atrisina, saspiežot vēsturi, nezaudējot būtisku informāciju. Tas ietver vecāku apmaiņu apkopošanu, lai samazinātu tokenus skaitu, vienlaikus saglabājot nepieciešamo kontekstu. Visa vēstures nosūtīšanas vietā tu nosūti pagātnes apmaiņu kopsavilkumu plus jaunākos ziņojumus. Modelis joprojām zina, ka klienta uzvārds ir Dupont, ka viņam ir strīdīgs pasūtījums un ka tu jau piedāvāji naudas atmaksu, nevajadzējot atkārtoti lasīt četrdesmit ziņojumus, kas noteica šos faktus.
Mehānisms
Zemāk esošā funkcija piemēro šo loģiku tās vienkāršākajā formā: tā novērtē apjomu, neko nedara, līdz tiek pārsniegts slieksnis, un pēc tam sadala vēsturi divās daļās. Vecākie ziņojumi nonāk kopsavilkumā; jaunākie paliek nemainīgi.
import openai
client = openai.OpenAI()
def compact_history(
messages: list[dict],
token_threshold: int = 10_000,
keep_recent: int = 6,
) -> list[dict]:
"""Saspiež vēsturi, kad tā pārsniedz slieksni."""
# Novērtē tokenus skaitu (aptuveni)
estimated_tokens = sum(len(m["content"]) // 4 for m in messages)
if estimated_tokens < token_threshold:
return messages # Nav nepieciešams saspiest
# Sadalījums: vecie ziņojumi pret jaunajiem
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
# Apkopojam vecos ziņojumus
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,
)
# Atjaunojam saspiesto vēsturi
summary_message = {
"role": "system",
"content": f"Summary of previous conversation:\n{response.output_text}",
}
return [summary_message] + recent_messages
Divas detaļas ir pelnījušas tavu uzmanību. Kopsavilkuma uzvedne tieši pieprasa pieņemtos lēmumus, jo kopsavilkums, kas saglabā tikai tēmas, liek modelim zaudēt atmiņu par saviem solījumiem. Un max_output_tokens=500 ierobežo kopsavilkumu: bez šī ierobežojuma kopsavilkums augtu ar katru kompakciju, un tu nonāktu pie tieši tās problēmas, kuru centies novērst.
Divas stratēģijas, kas jāzina
Slīdošais logs ar kopsavilkumu
Tālāk esošā klase industrializē šo principu. Tā uztur vienu kopsavilkumu, ko pārraksta katrā kompakcijā, integrējot jaunas apmaiņas, vienlaikus saglabājot neapstrādātu ziņojumu logu. Konteksts, kas tiek nosūtīts API, tāpēc vienmēr sastāv no trim blokiem: sistēmas uzvednes, kumulatīvā kopsavilkuma un jaunākā loga.
class CompactedConversation:
"""Pārvalda sarunu ar automātisku kompakciju."""
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]:
"""Veido kontekstu, kas nosūtāms 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:]
Ņem vērā, ka _compact atkārtoti ievada esošo kopsavilkumu uzvednē pirms jaunajām apmaiņām. Tas novērš progresējošu amnēziju: bez šīs atkārtotas ievades katra kompakcija dzēstu visu, ko iepriekšējā bija saglabājusi.
Selektīvā kompakcija
Apkopošana ir destruktīva, un daži saturi nepārdzīvo pārfrazēšanu. Koda fragments, JSON API atbilde vai skaitļu tabula zaudē savu lietderību, tiklīdz tā tiek pārstāstīta. Selektīvā kompakcija tāpēc šķiro vecos ziņojumus pirms apkopošanas: tie, kas satur kodu vai strukturētus datus, tiek nodoti cauri neskarti, kamēr tiek saspiests tikai sarunu teksts.
def selective_compaction(
messages: list[dict],
keep_recent: int = 6,
) -> list[dict]:
"""Saspiež, saglabājot strukturētos ziņojumus neskartus."""
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
to_summarize = []
to_keep = []
for msg in old_messages:
content = msg["content"]
# Saglabā ziņojumus, kas satur kodu vai datus
if "```" in content or "{" in content:
to_keep.append(msg)
else:
to_summarize.append(msg)
# Apkopojam tikai sarunu tekstu
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
Šeit izmantotais šķirošanas kritērijs – trīs atpakaļslīpsvītru vai figūriekavas klātbūtne – ir apzināti rupjš. Pielāgo to tam, ko tavī rīki faktiski rada: asistentam, kas apstrādā lietu atsauces, tu vari vēlēties saglabāt jebkuru ziņojumu, kas satur klienta ID.
Pārliecināšanās, ka kompakcija ir tā vērta
Slikti kalibrēta kompakcija izmaksā papildu API izsaukumu bez manāma ieguvuma vai saspiež tik agresīvi, ka modelis zaudē pavedienu un uzdod jau atrisinātus jautājumus. Tāpēc izmēri attiecību pirms nostiprini savus galīgos sliekšņus, izmantojot reālu sarunu paraugu.
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),
}
Paņem duci transkriptu no savas ražošanas vides, izlaid tos caur kompakciju un izlasi iegūtos kopsavilkumus: ja tu nevari atsākt sarunu, balstoties tikai uz kopsavilkumu, tavs slieksnis ir pārāk zems vai tava kopsavilkuma uzvedne pārāk neskaidra.
Galvenās atziņas
- Kompakcija samazina tokenus, apkopojot vecākos ziņojumus
- Vienmēr saglabā jaunākos ziņojumus neskartus (slīdošais logs)
- Saglabā ziņojumus, kas satur kodu vai strukturētus datus
- Atkārtoti ievada esošo kopsavilkumu katrā jaunā kompakcijā, lai izvairītos no progresējošas amnēzijas
- Izmēri saspiešanas koeficientu, lai kalibrētu savus sliekšņus