Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Il-Kompattazzjoni: Tikkumpressa Konversazzjonijiet Twal

Lezzjoni 11 / 20 Aġġornat 28 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. Il-Problema tal-Konversazzjonijiet Twal
  2. Żewġ Strateġiji li Trid Tkun Taf
  3. Verifika li l-Kompattazzjoni Tiswa l-Isforz
  4. Punti Ewlenin

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