Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Strategije konteksta za agente

Lekcija 14 od 20 Ažurirano 28. srpnja 2026. Napredno
Na ovoj stranici
  1. Izazov konteksta za agente
  2. Memorija s tri razine
  3. Ukroćivanje rezultata alata
  4. Kada više agenata radi zajedno
  5. Ključne točke

Izazov konteksta za agente

Autonomni agent povezuje desetke API poziva: rezonira, koristi alate, čita rezultate i iterira. Pri svakom koraku kontekst raste. Razlika u odnosu na običan razgovor jest u tome što taj rast ne dolazi od korisnika, već od samog agenta: SQL upit koji vraća tristo redaka, preuzeta cijela web-stranica ili pročitan cijeli zapisnik (log file). Bez strategije upravljanja, agent doseže ograničenje konteksta unutar nekoliko iteracija, često prije nego što završi zadatak koji si mu dodijelio.

Dizajniranje agenta koji učinkovito upravlja svojom memorijom svodi se dakle na odgovaranje na tri pitanja: što mora ostati netaknuto, što se može sažeti i što uopće nije trebalo ući u kontekst. Obradit ćemo ih tim redoslijedom.

Memorija s tri razine

Struktura koju koristimo oslanja se na klasičnu razliku između radne memorije, epizodne memorije i semantičke memorije. Radna memorija drži najnovije radnje u njihovom sirovom obliku jer ih agentu trebaju točno takve kakve jesu kako bi odlučio što učiniti sljedeće. Epizodna memorija čuva sažetke prošlih koraka: agent zna da je istražio određeni trag i što je to donijelo, bez ponovnog čitanja detalja. Konačno, semantička memorija akumulira činjenice utvrđene jednom zauvijek – ID kupca, verziju sheme baze podataka, ograničenje proračuna – koje se nikada ne smiju izgubiti u sažetku.

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)

Dva parametra zaslužuju raspravu prije nego što ih kopiraš takve kakvi jesu. Skraćivanje od 2000 znakova u add_action štiti od opširnih alata, ali reže nasumično: ako tvoji alati vraćaju JSON, završit ćeš s neispravnim objektom usred svog konteksta. A max_episodes: 10 nameće ograničenu amneziju – kod jedanaestog sažetka, prvi nestaje. Za agenta koji radi dugo vrijeme, promoviraj važne činjenice u facts prije nego ispadnu iz epizodnog prozora, inače ćeš ih trajno izgubiti.

Ukroćivanje rezultata alata

Alati često vraćaju glomazne rezultate: web-stranice, SQL rezultate, sadržaje datoteka. To je daleko vodeći uzrok zasićenja konteksta za agenta, a ujedno i najlakši za popraviti jer to rješavaš pri unosu, a ne naknadno.

Funkcija u nastavku nudi tri strategije skraćivanja. Način start odgovara dokumentima gdje je bitno na vrhu, poput članka ili izvješća. Način start_end funkcionira kada kraj nosi odlučujuće informacije: trag izvršenja gdje se greška pojavljuje zadnja, zapisnik (log file) ili straniciirani odgovor gdje se ukupan broj pojavljuje na kraju. Način summary košta dodatni API poziv, što je opravdano samo za dug sadržaj koji je doista koristan za ostatak rezoniranja.

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]

Tablični rezultati zahtijevaju posebno postupanje. Rezanje SQL tablice usred uklanja zaglavlje ili iskrivljuje osjećaj volumena: agent vidi dvadeset redaka i zaključuje da tablica sadrži samo dvadeset. Filtrar u nastavku zadržava zaglavlje, uzorak s vrha i dna, i – što je ključna točka – eksplicitno navodi broj izostavljenih redaka i ukupan broj. Agent tada zna da gleda isječak i može odlučiti pokrenuti agregatni upit umjesto da rezonira na temelju uzorka.

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

Kada više agenata radi zajedno

Kada nekoliko podagenata radi paralelno, napast je dati im svima puni kontekst, samo da budeš siguran. To je najbolji način da pomnožiš svoj račun s brojem agenata dok istovremeno degradiraš njihovu izvedbu, jer zagušen kontekst čini model manje preciznim za vlastiti zadatak. Umjesto toga, podijeli minimalni kontekst: globalni cilj kako bi agent razumio čemu doprinosi, njegovu vlastitu ulogu, zajednička ograničenja i ograničeni isječak rezultata koje su proizveli njegovi kolege.

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

Ograničenje od 200 znakova po djelomičnom rezultatu odražava namjeru: podagent treba znati što su drugi pronašli, a ne kako su to pronašli. Ako tvoji agenti trebaju pune detalje susjednih rezultata, vjerojatno trebaš ponovno razmisliti o tome kako si podijelio uloge.

Ključne točke

  • Strukturiraj memoriju agenta u tri razine: radna, epizodna, semantička
  • Automatski kompakiraj kada radna memorija prijeđe prag
  • Skrati rezultate alata prije ubacivanja u kontekst
  • Uvijek signaliziraj da je rezultat skraćen i za koliko
  • Za postavke s više agenata, podijeli minimalni kontekst ciljan prema ulozi