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

Strateġiji tal-kuntest għall-aġenti

Lezzjoni 14 / 20 Aġġornat 28 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. L-isfida tal-kuntest għall-aġenti
  2. Memorja fuq tliet livelli
  3. Ir-raddim tar-riżultati tal-għodod
  4. Meta diversi aġenti jaħdmu flimkien
  5. Punti Ewlenin

L-isfida tal-kuntest għall-aġenti

Aġent awtonomu jgħaqqad flimkien għexieren ta’ sejħiet API: jirraġuna, juża għodod, jaqra r-riżultati, u jiterah. F’kull pass, il-kuntest jikber. Id-differenza minn konversazzjoni ordinarja hija li dan it-tkabbir ma jiġix mill-utent iżda mill-aġent innifsu: mistoqsija SQL li tirritorna tliet mitt ringiela, paġna web sħiħa rkuprata, jew fajl tal-log sħiħ moqri. Mingħajr strateġija ta’ ġestjoni, aġent jilħaq il-limitu tal-kuntest fi ftit iterazzjonijiet, spiss qabel ma jtemm il-kompitu li fdatlu.

Id-disinn ta’ aġent li jimmaniġġja l-memorja tiegħu b’mod effettiv għalhekk jinżel biex twieġeb tliet mistoqsijiet: x’għandu jibqa’ intatt, x’jista’ jiġi ssuntat, u x’qatt ma kellu jidħol fil-kuntest mill-bidu nett. Se nittrattawhom f’dak l-ordni.

Memorja fuq tliet livelli

L-istruttura li nużaw tibbaża fuq id-distinzjoni klassika bejn il-memorja tax-xogħol, il-memorja episodika u l-memorja semantika. Il-memorja tax-xogħol iżżomm l-aktar azzjonijiet riċenti fil-forma mhux maqlugħa tagħhom għax l-aġent jeħtieġhom eżattament kif inhuma biex jiddeċiedi x’għandu jagħmel wara. Il-memorja episodika żżomm sommarji ta’ passi preċedenti: l-aġent ikun jaf li esplora ċerta triq u x’ħarġet minnha, mingħajr ma jerġa’ jaqra d-dettalji. Fl-aħħar nett, il-memorja semantika takkumula fatti stabbiliti darba għal dejjem—l-ID tal-klijent, il-verżjoni tal-iskema tad-database, il-vinċolu tal-baġit—li qatt m’għandhom jintilfu f’sommarju.

from dataclasses import dataclass, field

@dataclass
class AgentMemory:
    """Three-level memory system for an agent."""

    # Level 1: working memory (current context)
    working: list[dict] = field(default_factory=list)

    # Level 2: episodic memory (summaries of past steps)
    episodes: list[str] = field(default_factory=list)

    # Level 3: semantic memory (permanent facts)
    facts: list[str] = field(default_factory=list)

    max_tokens_working: int = 20_000
    max_episodes: int = 10

    def add_action(self, action: str, result: str):
        """Adds an action to working memory."""
        self.working.append({
            "action": action,
            "result": result[:2000],  # Truncate long results
        })
        self._check_compaction()

    def add_fact(self, fact: str):
        """Adds a permanent fact."""
        if fact not in self.facts:
            self.facts.append(fact)

    def _check_compaction(self):
        tokens = sum(
            len(str(e)) // 4 for e in self.working
        )
        if tokens > self.max_tokens_working:
            self._compact()

    def _compact(self):
        """Compacts working memory into an episode."""
        import openai
        client = openai.OpenAI()

        text = "\n".join(
            f"Action: {a['action']}\nResult: {a['result']}"
            for a in self.working[:-2]
        )

        response = client.responses.create(
            model="gpt-5.6-terra",
            input=(
                "Summarize these agent actions in 3-5 key points. "
                "Keep important facts, results, and decisions.\n\n"
                f"{text}"
            ),
            max_output_tokens=300,
        )

        self.episodes.append(response.output_text)
        self.working = self.working[-2:]  # Keep the last 2 actions

        # Limit the number of episodes
        if len(self.episodes) > self.max_episodes:
            self.episodes = self.episodes[-self.max_episodes:]

    def build_context(self) -> str:
        """Builds the full context for the next call."""
        parts = []

        if self.facts:
            parts.append(
                "Established facts:\n" + "\n".join(f"- {f}" for f in self.facts)
            )

        if self.episodes:
            parts.append(
                "Summarized history:\n" + "\n---\n".join(self.episodes)
            )

        if self.working:
            parts.append(
                "Recent actions:\n" + "\n".join(
                    f"- {a['action']} → {a['result'][:500]}"
                    for a in self.working
                )
            )

        return "\n\n".join(parts)

Żewġ parametri jistħoqqilhom diskussjoni qabel ma tikkopjahom hekk kif inhuma. It-trunkament ta’ 2,000 karattru f’add_action jipproteġi kontra għodod verbali, iżda jaqta’ bl-indiscriminat: jekk l-għodod tiegħek jirritornaw JSON, tispiċċa b’oġġett invalidu fin-nofs tal-kuntest tiegħek. U max_episodes: 10 jinfurza amneżija limitata: fil-ħdax-il sommarju, l-ewwel wieħed jisparixxi. Għal aġent li jopera għal żmien twil, promwovi fatti importanti għal facts qabel ma joħorġu mit-tieqa episodika, inkella titlefhom għal dejjem.

Ir-raddim tar-riżultati tal-għodod

L-għodod spiss jirritornaw riżultati voluminużi: paġni web, riżultati SQL, kontenuti ta’ fajls. Din hija bla dubju l-aktar kawża ewlenija ta’ saturazzjoni tal-kuntest għal aġent, u hija wkoll l-aktar waħda faċli biex issolviha għax tittrattaha fl-ingestjoni aktar milli wara l-fatt.

Il-funzjoni hawn taħt toffri tliet strateġiji ta’ trunkament. Il-modalità start taqbel għal dokumenti fejn l-essenzjali jinsabu fuq nett, bħal artiklu jew rapport. Il-modalità start_end taħdem meta t-tmiem iġorr l-informazzjoni deċiżiva: traċċa ta’ eżekuzzjoni fejn l-iżball jidher l-aħħar, fajl tal-log, jew tweġiba paġinata fejn it-total jidher fl-aħħar. Il-modalità summary tispiċċa b’sejħa API ekstra, li tiġġustifika ruħha biss għal kontenut twil li huwa verament utli għall-bqija tar-raġunament.

def truncate_tool_result(
    result: str,
    max_tokens: int = 2000,
    strategy: str = "start_end",
) -> str:
    """Truncates a tool result while preserving key information."""
    estimated_tokens = len(result) // 4

    if estimated_tokens <= max_tokens:
        return result

    max_chars = max_tokens * 4

    match strategy:
        case "start":
            return result[:max_chars] + "\n[... truncated]"

        case "start_end":
            half = max_chars // 2
            return (
                result[:half]
                + "\n[... middle truncated ...]\n"
                + result[-half:]
            )

        case "summary":
            import openai
            client = openai.OpenAI()
            response = client.responses.create(
                model="gpt-5.6-terra",
                input=f"Summarize this data keeping the essentials:\n{result}",
                max_output_tokens=max_tokens,
            )
            return response.output_text

    return result[:max_chars]

Ir-riżultati tabulari jeħtieġu trattament speċjali. Li taqta’ tabella SQL fin-nofs ineħħi l-intestatura jew idgħajjef is-sens tal-volum: l-aġent jara għoxrin ringiela u jikkonkludi li t-tabella fiha biss għoxrin. Il-filtru hawn taħt iżomm l-intestatura, kampjun mill-bidu u mit-tmiem, u—dan huwa l-punt ewlieni—jiddikjara b’mod espliċitu n-numru ta’ ringieli mħassra u t-total. L-aġent imbagħad ikun jaf li qed iħares lejn estratt u jista’ jiddeċiedi li jħaddem mistoqsija aggregata aktar milli jirraġuna fuq kampjun.

def filter_sql_result(result: str, question: str) -> str:
    """Filters a SQL result to keep only what's relevant."""
    lines = result.strip().split("\n")

    if len(lines) <= 20:
        return result

    # Keep the header and first/last lines
    header = lines[0]
    first_lines = lines[1:6]
    last_lines = lines[-5:]

    return (
        f"{header}\n"
        + "\n".join(first_lines)
        + f"\n[... {len(lines) - 11} lines omitted ...]\n"
        + "\n".join(last_lines)
        + f"\n\nTotal: {len(lines) - 1} rows"
    )

Meta diversi aġenti jaħdmu flimkien

Meta diversi sotto-aġenti jaħdmu parallell, it-tentazzjoni hija li tagħtihom ilkoll il-kuntest sħiħ, biss biex tkun żgur. Dik hija l-aħjar triqa biex timmultiplika l-kont tiegħek bin-numru ta’ aġenti filwaqt li tiddeterjora l-prestazzjoni tagħhom, peress li kuntest imħawwad jagħmel il-mudell inqas preċiż fil-kompitu tiegħu stess. Minflok, aqsam il-kuntest minimu: l-għan globali biex l-aġent jifhem għal xiex qed jikkontribwixxi, ir-rwol tiegħu stess, vinċoli komuni, u estratt limitat tar-riżultati prodotti mill-pari tiegħu.

@dataclass
class SharedContext:
    """Context shared between sub-agents."""
    objective: str
    constraints: list[str]
    partial_results: dict[str, str] = field(default_factory=dict)

    def context_for_sub_agent(self, role: str) -> str:
        """Generates a targeted context for a sub-agent."""
        return (
            f"Global objective: {self.objective}\n"
            f"Your role: {role}\n"
            f"Constraints: {', '.join(self.constraints)}\n"
            f"Results from other agents:\n"
            + "\n".join(
                f"- {k}: {v[:200]}"
                for k, v in self.partial_results.items()
            )
        )

Il-limitu ta’ 200 karattru għal kull riżultat parzjali jirrifletti intenzjoni: sotto-aġent jeħtieġ ikun jaf x’sabu l-oħrajn, mhux kif sabuh. Jekk l-aġenti tiegħek jeħtieġu d-dettall sħiħ tar-riżultati tal-ġirien, probabbilment għandek terġa’ taħseb kif qassamt ir-rwoli.

Punti Ewlenin

  • Iddisinja l-memorja tal-aġent fuq tliet livelli: tax-xogħol, episodika, semantika
  • Ikkompatta awtomatikament meta l-memorja tax-xogħol taqbeż il-limitu
  • Aqta’ r-riżultati tal-għodod qabel ma tinjettahom fil-kuntest
  • Dejjem indika li riżultat ġie maqtugħ, u kemm
  • Għal setups multi-aġent, aqsam kuntest minimu mmirat skont ir-rwol