Il-Kompattazzjoni: Tikkumpressa Konversazzjonijiet Twal
F'din il-paġna
Il-Problema tal-Konversazzjonijiet Twal
Kull messaġġ miżjud ma’ konversazzjoni jżid in-numru ta’ tokens mibgħuta lill-API. Konversazzjoni ta’ 50 dawra tista’ faċilment tilħaq 30,000 token tad-dħul, u b’hekk tiżdied kemm il-latency kif ukoll l-ispiża. Il-problema hija insidjuża: l-ewwel dawra ta’ assistent tas-support tispiċċa ftit mijiet ta’ tokens, filwaqt li t-tletin dawra tispiċċa diversi eluf, anke jekk l-utent qed jistaqsi l-istess tip ta’ mistoqsija. Inti tħallas dejjem aktar għal servizz identiku, u l-utent jistenna dejjem itwal għal tweġiba.
Il-kompattazzjoni ssolvi dan billi tikkumpressa l-istorja mingħajr ma titlef informazzjoni essenzjali. Dan jinvolvi li tagħmel sommarju tal-iskambji l-antiki biex tnaqqas in-numru ta’ tokens filwaqt li żżomm il-kuntest meħtieġ. Minflok tibgħat l-istorja kollha, tibgħat sommarju tal-iskambji tal-passat flimkien mal-messaġġi riċenti. Il-mudell għadu jaf li l-isem tal-klijent huwa Dupont, li għandu ordni kkontestata, u li diġà offrejt rimbors, mingħajr ma jkollu jerġa’ jaqra l-erbgħin messaġġ li stabbilixxew dawk il-fatti.
Il-Mekkaniżmu
Il-funzjoni hawn taħt tapplika din il-loġika fl-aktar forma sempliċi tagħha: tistma l-volum, ma tagħmel xejn sakemm ma tintlaħaqx il-limitu, imbagħad taqsam l-istorja f’żewġ partijiet. Il-messaġġi l-antiki jmorru għas-sommarju; dawk l-aktar riċenti jibqgħu kif inhum.
import openai
client = openai.OpenAI()
def compact_history(
messages: list[dict],
token_threshold: int = 10_000,
keep_recent: int = 6,
) -> list[dict]:
"""Tikkumpatta l-istorja meta taqbeż il-limitu."""
# Stima tan-numru ta' tokens (approssimazzjoni)
estimated_tokens = sum(len(m["content"]) // 4 for m in messages)
if estimated_tokens < token_threshold:
return messages # M'hemmx bżonn tikkumpatta
# Qsim: messaġġi antiki vs dawk riċenti
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
# Agħmel sommarju tal-messaġġi antiki
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,
)
# Ibni mill-ġdid l-istorja kkumpattata
summary_message = {
"role": "system",
"content": f"Summary of previous conversation:\n{response.output_text}",
}
return [summary_message] + recent_messages
Żewġ dettalji jistħoqqilhom attenzjoni. Il-prompt tas-sommarju jitlob espliċitament id-deċiżjonijiet meħuda għax sommarju li jżomm biss it-temi jikkawża li l-mudell jitlif il-memorja tal-impenji tiegħu stess. U max_output_tokens=500 jillimita s-sommarju: mingħajr din il-limitu, is-sommarju jikber ma’ kull kompattazzjoni, u tispiċċa bil-problema stess li kont qed tipprova telimina.
Żewġ Strateġiji li Trid Tkun Taf
Tieqa Li Tiżżerżaq b’Sommarju
Il-klassi li ġejja tindustrializza l-prinċipju. Iżżomm sommarju wieħed li terġa’ tikteb f’kull kompattazzjoni billi tintegra skambji ġodda, filwaqt li żżomm tieqa ta’ messaġġi mhux maqlugħa. Għalhekk, il-kuntest mibgħut lill-API dejjem jikkonsisti f’tliet blokok: il-prompt tas-sistema, is-sommarju kumulattiv, u t-tieqa riċenti.
class CompactedConversation:
"""Timmaniġġja konversazzjoni b'kompattazzjoni awtomatika."""
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]:
"""Tibni l-kuntest biex tibgħatu lill-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:]
Innota li _compact terġa’ ddħol is-sommarju eżistenti fil-prompt qabel l-iskambji l-ġodda. Dan jipprevjeni l-amnesija progressiva: mingħajr din id-dħul mill-ġdid, kull kompattazzjoni tkun tħassar kull ma kien żamm dak ta’ qablu.
Kompattazzjoni Selettiva
Is-sommarizzazzjoni hija distruttiva, u xi kontenut ma jgħixx ir-riformulazzjoni. Snippet tal-kodiċi, tweġiba JSON tal-API, jew tabella ta’ figuri jitilfu l-utilità tagħhom hekk kif jiġu parafrasati. Għalhekk, il-kompattazzjoni selettiva tissortja l-messaġġi antiki qabel ma tagħmel is-sommarju: dawk li fihom kodiċi jew data strutturata jgħaddu intatti, filwaqt li biss it-test konversazzjonali jiġi kkompressat.
def selective_compaction(
messages: list[dict],
keep_recent: int = 6,
) -> list[dict]:
"""Tikkumpatta filwaqt li żżomm il-messaġġi strutturati intatti."""
old_messages = messages[:-keep_recent]
recent_messages = messages[-keep_recent:]
to_summarize = []
to_keep = []
for msg in old_messages:
content = msg["content"]
# Żomm il-messaġġi li fihom kodiċi jew data
if "```" in content or "{" in content:
to_keep.append(msg)
else:
to_summarize.append(msg)
# Agħmel sommarju biss tat-test konversazzjonali
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
Il-kriterju tal-għażla użat hawn—il-preżenza ta’ tliet backticks jew parentesi miftuħa—huwa intenzjonalment grossolan. Adattah għal dak li l-għodod tiegħek jipproduċu fil-fatt: għal assistent li jimmaniġġja referenzi ta’ każijiet, jista’ jkun li trid iżżomm kull messaġġ li fih ID tal-klijent.
Verifika li l-Kompattazzjoni Tiswa l-Isforz
Kompattazzjoni mhux ikkalibrata sew tispiċċa tiswa sejħa API żejda mingħajr qligħ notevoli, jew tikkumpressa b’mod aggressiv wisq sakemm il-mudell jitlif il-fil u jistaqsi mistoqsijiet diġà solvuti. Għalhekk, kejjel ir-raġġ qabel ma tiffissa l-limiti finali tiegħek, billi tuża kampjun ta’ konversazzjonijiet reali.
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),
}
Ħu doġġina ta’ transkrizzjonijiet mill-ambjent tal-produzzjoni tiegħek, għaddihom mill-kompattazzjoni, u aqra s-sommarji prodotti: jekk ma tkunx tista’ tkompli l-konversazzjoni bbażat biss fuq is-sommarju, allura l-limitu tiegħek huwa baxx wisq jew il-prompt tas-sommarju tiegħek huwa vag wisq.
Punti Ewlenin
- Il-kompattazzjoni tnaqqas it-tokens billi tagħmel sommarju tal-messaġġi l-antiki
- Dejjem żomm l-aktar messaġġi riċenti intatti (tieqa li tiżżerżaq)
- Ippreserva l-messaġġi li fihom kodiċi jew data strutturata
- Erġa’ ddħol is-sommarju eżistenti f’kull kompattazzjoni ġdida biex tevita l-amnesija progressiva
- Kejjel ir-raġġ tal-kompressjoni biex tikkalibra l-limiti tiegħek