Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Stratēģijas aģentu konteksta pārvaldībai

Nodarbība 14 no 20 Atjaunota 2026. gada 28. jūlijs Augstākais
Šajā lapā
  1. Konteksta izaicinājums aģentiem
  2. Trīs līmeņu atmiņa
  3. Rīku rezultātu savaldīšana
  4. Kad vairāki aģenti strādā kopā
  5. Galvenās atziņas

Konteksta izaicinājums aģentiem

Autonoms aģents secīgi veic desmitiem API izsaukumu: tas spriež, izmanto rīkus, lasa rezultātus un iterē. Katrā solī konteksts aug. Atšķirībā no parastas sarunas šis pieaugums nerodas no lietotāja, bet gan no paša aģenta: SQL vaicājums, kas atgriež trīs simtus rindu, pilna tīmekļa lapa vai nolasīts viss žurnālfails. Bez pārvaldības stratēģijas aģents sasniedz konteksta limitu dažu iterāciju laikā, bieži vien pirms tam ir pabeidzis tev uzticēto uzdevumu.

Tādēļ aģenta izstrāde, kas efektīvi pārvalda savu atmiņu, nozīmē atbildēt uz trim jautājumiem: kas ir jāsaglabā nemainīgs, ko var apkopot un kam vispār nevajadzēja nonākt kontekstā. Aplūkosim tos šajā secībā.

Trīs līmeņu atmiņa

Izmantotā struktūra balstās uz klasisko dalījumu darba atmiņā, epizodiskajā atmiņā un semantiskajā atmiņā. Darba atmiņā tiek glabātas visnesenākās darbības to neapstrādātajā formā, jo aģentam tās ir nepieciešamas tieši tādas, lai lemtu par nākamo soli. Epizodiskā atmiņa saglabā pagājušo soļu kopsavilkumus: aģents zina, ka ir izpētījis konkrētu virzienu un ko tas deva, nepārlasot detaļas. Visbeidzot, semantiskā atmiņa uzkrāj faktus, kas noteikti vienreiz un uz visiem laikiem – klienta ID, datubāzes shēmas versija, budžeta ierobežojums – un kuriem nekad nedrīkst pazust kopsavilkumā.

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)

Divi parametri ir pelnījuši diskusiju, pirms tos kopē tālāk nemainītus. 2000 zīmju saīsinājums funkcijā add_action pasargā no daudzrunīgiem rīkiem, taču tas griež akli: ja tavi rīki atgriež JSON, konteksta vidū nonāks nederīgs objekts. Un max_episodes: 10 nodrošina ierobežotu aizmāršību – vienpadsmitajā kopsavilkumā pirmais pazūd. Ja aģents darbojas ilgu laiku, pirms svarīgi fakti izkrīt no epizodiskā loga, pārvieto tos uz facts, citādi zaudēsi tos uz visiem laikiem.

Rīku rezultātu savaldīšana

Rīki bieži atgriež apjomīgus rezultātus: tīmekļa lapas, SQL rezultātus, failu saturu. Tas ir galvenais konteksta piesātinājuma cēlonis aģentiem, un to ir arī visvieglāk novērst, jo risinājums tiek pielietots datu ievades brīdī, nevis pēc tam.

Zemāk esošā funkcija piedāvā trīs saīsināšanas stratēģijas. Režīms start ir piemērots dokumentiem, kur būtiskākais ir sākumā, piemēram, rakstos vai ziņojumos. Režīms start_end darbojas, ja izšķirošā informācija ir beigās: izpildes pēdās, kur kļūda parādās visbeidzot, žurnālfailos vai lapotās atbildēs, kur kopsumma ir beigās. Režīms summary prasa papildu API izsaukumu, kas ir attaisnojams tikai garam saturam, kas patiešām ir noderīgs turpmākajai spriešanai.

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]

Tabulas veida rezultātiem nepieciešama īpaša pieeja. SQL tabulas pārgriešana uz pusēm noņem galveni vai sagrozī apjoma uztveri: aģents redz divdesmit rindas un secina, ka tabulā ir tikai divdesmit. Tālāk esošais filtrs saglabā galveni, paraugu no sākuma un beigām, un – tas ir galvenais – skaidri norāda izlaisto rindu skaitu un kopējo apjomu. Tādējādi aģents zina, ka skatās uz izrakstu, un var nolemt veikt agregācijas vaicājumu, nevis spriest, balstoties uz paraugu.

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

Kad vairāki aģenti strādā kopā

Kad vairāki apakšaģenti strādā paralēli, rodas kārdinājums dot viņiem visu kontekstu, lai būtu drošībā. Tas ir labākais veids, kā reizināt rēķinu ar aģentu skaitu, vienlaikus pasliktinot to veiktspēju, jo pārpildīts konteksts padara modeli mazāk precīzu tā uzdevumā. Tā vietā dalies ar minimālo kontekstu: globālo mērķi, lai aģents saprastu, kam tas kalpo, tā paša lomu, kopējiem ierobežojumiem un ierobežotu izrakstu no citu aģentu iegūtajiem rezultātiem.

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

200 zīmju limits katram daļējam rezultātam atspoguļo nodomu: apakšaģentam ir jāzina, ko citi ir atraduši, nevis kā viņi to atrada. Ja taviem aģentiem ir nepieciešamas pilnas detaļas par blakus esošajiem rezultātiem, tev, iespējams, ir jāpārdomā, kā esi sadalījis lomas.

Galvenās atziņas

  • Strukturē aģenta atmiņu trīs līmeņos: darba, epizodiskā, semantiskā
  • Automātiski veic kompaktizāciju, kad darba atmiņa pārsniedz slieksni
  • Saīsini rīku rezultātus pirms to ievietošanas kontekstā
  • Vienmēr norādi, ka rezultāts ir saīsināts un par cik
  • Daudzaģentu sistēmās dalies ar minimālu kontekstu, kas pielāgots konkrētai lomai