Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Straitéisí comhthéacs do ghníomhairí

Ceacht 14 as 20 Nuashonraithe 28 Iúil 2026 Ardleibhéal
Ar an leathanach seo
  1. An dúshlán comhthéacs do ghníomhairí
  2. Cuimhne trí leibhéal
  3. Torthaí uirlisí a chur faoi smacht
  4. Nuair a oibríonn gníomhairí iolracha le chéile
  5. Príomhphointí

An dúshlán comhthéacs do ghníomhairí

Déanann gníomhaire uathrialach slabhrú de dhusaintí glaonna API: déanann sé réasúnaíocht, úsáideann sé uirlisí, léann sé torthaí, agus déanann sé atrialacha. Ag gach céim, fásann an comhthéacs. Is é an difríocht idir é seo agus gnáthchomhrá ná nach ón úsáideoir a thagann an fás seo, ach ón ngníomhaire féin: ceist SQL a fhilleann trí chéad rón, leathanach gréasáin iomlán a aisghabháil, nó comhad logála iomlán a léamh. Gan straitéis bainistíochta, sroicheann gníomhaire an teorainn comhthéacs laistigh de chúpla atrialach, go minic sula gcríochnaíonn sé an tasc a shanntaigh tú dó.

Mar sin, is é atá i gceist le gníomhaire a dhearadh a bhainistíonn a chuimhne go héifeachtach ná freagra a thabhairt ar thrí cheist: cad a chaithfidh fanacht slán, cad is féidir a achoimriú, agus cad nár chóir a bheith sa chomhthéacs ar chor ar bith ó thús. Pléifimid iad san ord sin.

Cuimhne trí leibhéal

Baineann an struchtúr a úsáidimid leis an idirdhealú clasaiceach idir cuimhne oibre, cuimhne eipeasóideach, agus cuimhne shéimeantach. Coinníonn cuimhne oibre na gníomhaíochtaí is déanaí ina bhfoirm amh toisc go dteastaíonn siad ón ngníomhaire díreach mar atá siad chun cinneadh a dhéanamh faoin gcéad rud eile le déanamh. Coinníonn cuimhne eipeasóideach achoimrí de chéimeanna caite: tá a fhios ag an ngníomhaire gur iniúch sé treoir áirithe agus cad a tháinig as, gan na mionsonraí a athléamh. Ar deireadh, carnann cuimhne shéimeantach fíricí a bunaíodh uair amháin agus do gach uair—ID an chustaiméara, leagan scéimre an bhunachair sonraí, an srian buiséid—nach caillfear go deo in achoimre.

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)

Tá dhá pharaiméadar ann a thuilleann plé sula ndéanann tú cóip díobh mar atá siad. Cosnaíonn an gearradh 2,000 carachtar in add_action in aghaidh uirlisí fochlóireacha, ach gearrann sé go dall: má fhilleann do chuid uirlisí JSON, críochnóidh tú le réad neamhbhailí i lár do chomhthéacs. Agus forchuireann max_episodes: 10 amnéis theoranta: ar an aonú achoimre déag, imíonn an chéad cheann. I gcás gníomhaire a ritheann ar feadh i bhfad, ardaigh fíricí tábhachtacha go facts sula dtiteann siad as fuinneog na cuimhne eipeasóidí, nó caillfidh tú go buan iad.

Torthaí uirlisí a chur faoi smacht

Is minic a fhilleann uirlisí torthaí toirtiúla: leathanaigh ghréasáin, torthaí SQL, ábhar comhad. Is é seo i bhfad an chúis is coitianta le sáithiú comhthéacs do ghníomhaire, agus is é freisin an ceann is fusa a shocrú toisc go ndéileálann tú leis ag an ionghabháil seachas tar éis an fhíric.

Tairgeann an fheidhm thíos trí straitéis ghearrtha. Oireann an mód start do dhoiciméid ina bhfuil na rudaí riachtanacha ar an mbarr, cosúil le halt nó tuarascáil. Oibríonn an mód start_end nuair a bhíonn an fhaisnéis chinntitheach ag an deireadh: rian feidhmithe ina dtagann an earráid last, comhad logála, nó freagra leathanaithe ina bhfuil an t-iomlán ag an deireadh. Costálann an mód summary glaonna API breise, rud nach bhfuil údar leis ach d’ábhar fada atá fíor-úsáideach don chuid eile den réasúnaíocht.

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]

Éilíonn torthaí táblacha láimhseáil speisialta. Má ghearrann tú tábla SQL sa lár, baintear an ceanntásc nó saobhtar an tuiscint ar an méid: feiceann an gníomhaire fiche rón agus tagann sé ar an gconclúid nach bhfuil ach fiche rón sa tábla. Coinníonn an scagaire thíos an ceanntásc, sampla ón mbarr agus ón mbun, agus—seo an pointe ríthábhachtach—léiríonn sé go soiléir líon na línte a fágadh ar lár agus an t-iomlán. Ansin tá a fhios ag an ngníomhaire go bhfuil sé ag breathnú ar eastósc agus is féidir leis cinneadh a dhéanamh ceist chomhiomlánaithe a rith seachas réasúnaíocht a dhéanamh ar shampla.

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"
    )

Nuair a oibríonn gníomhairí iolracha le chéile

Nuair a oibríonn roinnt fho-ghníomhairí go comhthreomhar, is é an tspreagadh ná an comhthéacs iomlán a thabhairt dóibh go léir, díreach chun a bheith sábháilte. Sin an bealach is fearr chun do bhille a iolrú faoi líon na ngníomhairí agus a bhfeidhmíocht a laghdú, ós rud é go ndéanann comhthéacs míshláintiúil an tsamhail níos lú cruinn ar a tasc féin. Ina ionad sin, roinn an comhthéacs íosta: an cuspóir domhanda ionas go dtuigeann an gníomhaire cad a chuireann sé leis, a ról féin, srianta coiteanna, agus eastósc teoranta de thorthaí a tháirg a chomhghleacaithe.

@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()
            )
        )

Léiríonn an teorainn 200 carachtar in aghaidh an toraidh pháirtigh rún: ní gá don fho-ghníomhaire a fháil amach cad a fuair daoine eile, ní conas a fuair siad é. Má theastaíonn mionsonraí iomlána na dtorthaí comharsanacha ó do chuid gníomhairí, is dócha go gcaithfidh tú athbhreithniú a dhéanamh ar an gcaoi ar roinn tú na róil.

Príomhphointí

  • Struchtúraigh cuimhne an ghníomhaire i dtrí leibhéal: oibre, eipeasóideach, séimeantach
  • Déan comhbhrú go huathoibríoch nuair a sháraíonn cuimhne oibre an tairseach
  • Gearr torthaí uirlisí sula n-instealltar sa chomhthéacs iad
  • Cuir in iúl i gcónaí go ndearnadh toradh a ghearradh, agus cé mhéad
  • I gcás socruithe ilghníomhaire, roinn comhthéacs íosta atá dírithe de réir róil