Strategie kontekstu dla agentów
Na tej stronie
Wyzwanie kontekstu dla agentów
Autonomiczny agent łączy ze sobą dziesiątki wywołań API: rozumuje, używa narzędzi, czyta wyniki i iteruje. Na każdym kroku kontekst rośnie. Różnica w porównaniu ze zwykłą rozmową polega na tym, że ten wzrost nie pochodzi od użytkownika, lecz od samego agenta: zapytanie SQL zwracające trzysta wierszy, pobrana pełna strona internetowa lub odczytany cały plik dziennika. Bez strategii zarządzania agent osiągnie limit kontekstu w ciągu kilku iteracji, często zanim zakończy przydzielone mu zadanie.
Projektowanie agenta, który skutecznie zarządza swoją pamięcią, sprowadza się zatem do odpowiedzi na trzy pytania: co musi pozostać nienaruszone, co można podsumować, a co w ogóle nie powinno było trafić do kontekstu. Zajmiemy się nimi właśnie w tej kolejności.
Pamięć trzywarstwowa
Struktura, której używamy, opiera się na klasycznym rozróżnieniu między pamięcią roboczą, pamięcią epizodyczną a pamięcią semantyczną. Pamięć robocza przechowuje najnowsze działania w ich surowej formie, ponieważ agent potrzebuje ich dokładnie takich, jakie są, aby zdecydować, co zrobić dalej. Pamięć epizodyczna przechowuje podsumowania przeszłych kroków: agent wie, że zbadał pewien trop i co to przyniosło, bez ponownego czytania szczegółów. Wreszcie pamięć semantyczna gromadzi fakty ustalone raz na zawsze – identyfikator klienta, wersję schematu bazy danych, ograniczenie budżetowe – które nigdy nie mogą zaginąć w podsumowaniu.
from dataclasses import dataclass, field
@dataclass
class AgentMemory:
"""Trójpoziomowy system pamięci dla agenta."""
# Poziom 1: pamięć robocza (bieżący kontekst)
working: list[dict] = field(default_factory=list)
# Poziom 2: pamięć epizodyczna (podsumowania przeszłych kroków)
episodes: list[str] = field(default_factory=list)
# Poziom 3: pamięć semantyczna (trwałe fakty)
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):
"""Dodaje działanie do pamięci roboczej."""
self.working.append({
"action": action,
"result": result[:2000], # Skróć długie wyniki
})
self._check_compaction()
def add_fact(self, fact: str):
"""Dodaje trwały fakt."""
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):
"""Kompaktuje pamięć roboczą do epizodu."""
import openai
client = openai.OpenAI()
text = "\n".join(
f"Akcja: {a['action']}\nWynik: {a['result']}"
for a in self.working[:-2]
)
response = client.responses.create(
model="gpt-5.6-terra",
input=(
"Podsumuj te działania agenta w 3-5 kluczowych punktach. "
"Zachowaj ważne fakty, wyniki i decyzje.\n\n"
f"{text}"
),
max_output_tokens=300,
)
self.episodes.append(response.output_text)
self.working = self.working[-2:] # Zachowaj ostatnie 2 działania
# Ogranicz liczbę epizodów
if len(self.episodes) > self.max_episodes:
self.episodes = self.episodes[-self.max_episodes:]
def build_context(self) -> str:
"""Buduje pełny kontekst dla następnego wywołania."""
parts = []
if self.facts:
parts.append(
"Ustalone fakty:\n" + "\n".join(f"- {f}" for f in self.facts)
)
if self.episodes:
parts.append(
"Podsumowana historia:\n" + "\n---\n".join(self.episodes)
)
if self.working:
parts.append(
"Ostatnie działania:\n" + "\n".join(
f"- {a['action']} → {a['result'][:500]}"
for a in self.working
)
)
return "\n\n".join(parts)
Dwa parametry zasługują na omówienie, zanim skopiujesz je bez zmian. Skrócenie do 2000 znaków w metodzie add_action chroni przed rozwlekłymi narzędziami, ale robi to w sposób ślepy: jeśli Twoje narzędzia zwracają JSON, w środku kontekstu znajdziesz nieprawidłowy obiekt. Z kolei max_episodes: 10 wymusza ograniczoną amnezję – przy jedenastym podsumowaniu pierwsze znika. Dla agenta działającego przez długi czas promuj ważne fakty do listy facts, zanim wypadną z okna epizodycznego, inaczej stracisz je na zawsze.
Okiełznanie wyników narzędzi
Narzędzia często zwracają obszerne wyniki: strony internetowe, wyniki SQL, zawartość plików. To zdecydowanie główna przyczyna nasycenia kontekstu u agenta, a jednocześnie najłatwiejsza do naprawienia, ponieważ zajmujesz się nią na etapie ingestii, a nie post factum.
Poniższa funkcja oferuje trzy strategie skracania. Tryb start pasuje do dokumentów, w których najważniejsze informacje znajdują się na początku, takich jak artykuł czy raport. Tryb start_end sprawdza się, gdy decydujące informacje znajdują się na końcu: ślad wykonania, gdzie błąd pojawia się jako ostatni, plik dziennika lub odpowiedź stronicowana, gdzie suma całkowita znajduje się na końcu. Tryb summary kosztuje dodatkowe wywołanie API, co jest uzasadnione tylko w przypadku długich treści, które są naprawdę użyteczne dla dalszego rozumowania.
def truncate_tool_result(
result: str,
max_tokens: int = 2000,
strategy: str = "start_end",
) -> str:
"""Skraca wynik narzędzia, zachowując kluczowe informacje."""
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[... skrócono]"
case "start_end":
half = max_chars // 2
return (
result[:half]
+ "\n[... środek skrócony ...]\n"
+ result[-half:]
)
case "summary":
import openai
client = openai.OpenAI()
response = client.responses.create(
model="gpt-5.6-terra",
input=f"Podsumuj te dane, zachowując essentials:\n{result}",
max_output_tokens=max_tokens,
)
return response.output_text
return result[:max_chars]
Wyniki tabelaryczne wymagają specjalnego traktowania. Przecięcie tabeli SQL w połowie usuwa nagłówek lub zniekształca poczucie objętości: agent widzi dwadzieścia wierszy i wnioskuje, że tabela zawiera tylko dwadzieścia. Poniższy filtr zachowuje nagłówek, próbkę z góry i z dołu, a co kluczowe – jawnie podaje liczbę pominiętych wierszy oraz łączną liczbę. Agent wie wtedy, że patrzy na wycinek, i może zdecydować się na uruchomienie zapytania agregującego, zamiast rozumować na podstawie próbki.
def filter_sql_result(result: str, question: str) -> str:
"""Filtruje wynik SQL, zachowując tylko to, co istotne."""
lines = result.strip().split("\n")
if len(lines) <= 20:
return result
# Zachowaj nagłówek oraz pierwsze i ostatnie linie
header = lines[0]
first_lines = lines[1:6]
last_lines = lines[-5:]
return (
f"{header}\n"
+ "\n".join(first_lines)
+ f"\n[... pominięto {len(lines) - 11} linii ...]\n"
+ "\n".join(last_lines)
+ f"\n\nRazem: {len(lines) - 1} wierszy"
)
Gdy współpracuje wielu agentów
Gdy kilka podagentów pracuje równolegle, pokusa polega na przekazaniu im wszystkim pełnego kontekstu „na wszelki wypadek“. To najlepszy sposób na pomnożenie rachunku przez liczbę agentów przy jednoczesnym pogorszeniu ich wydajności, ponieważ zaśmiecony kontekst sprawia, że model jest mniej precyzyjny w swoim własnym zadaniu. Zamiast tego dziel się minimalnym kontekstem: globalnym celem, aby agent rozumiał, do czego się przyczynia, jego własną rolą, wspólnymi ograniczeniami oraz ograniczonym wycinkiem wyników wyprodukowanych przez innych.
@dataclass
class SharedContext:
"""Kontekst współdzielony między podagentami."""
objective: str
constraints: list[str]
partial_results: dict[str, str] = field(default_factory=dict)
def context_for_sub_agent(self, role: str) -> str:
"""Generuje ukierunkowany kontekst dla podagenta."""
return (
f"Cel globalny: {self.objective}\n"
f"Twoja rola: {role}\n"
f"Ograniczenia: {', '.join(self.constraints)}\n"
f"Wyniki od innych agentów:\n"
+ "\n".join(
f"- {k}: {v[:200]}"
for k, v in self.partial_results.items()
)
)
Limit 200 znaków na częściowy wynik odzwierciedla zamysł: podagent musi wiedzieć, co inni znaleźli, a nie jak tego dokonali. Jeśli Twoje agenty potrzebują pełnych szczegółów wyników sąsiednich, prawdopodobnie musisz przemyśleć sposób podziału ról.
Kluczowe wnioski
- Ustrukturyzuj pamięć agenta na trzy poziomy: roboczy, epizodyczny, semantyczny
- Kompaktuj automatycznie, gdy pamięć robocza przekroczy próg
- Skracaj wyniki narzędzi przed wstrzyknięciem ich do kontekstu
- Zawsze sygnalizuj, że wynik został skrócony i o ile
- W konfiguracjach wieloagentowych dziel się minimalnym kontekstem ukierunkowanym na rolę