Programma Les 175 van 250 · Agents bouwen (Tool-Use & ReAct)
Agents bouwen (Tool-Use & ReAct)

Agentgeheugen & Staataccumulatie

De ReAct loop die je hebt gebouwd heeft geheugenverlies: elke stap roept een tool aan en vergeet het. Een echte agent moet zaken die het heeft geleerd meenemen naar voren - de feiten die het heeft opgezocht, de resultaten die tools teruggaven - zodat een latere stap ze kan gebruiken. Dat draaiende notebook is het memory van de agent (mensen noemen het ook de scratchpad of de werkcontext). Jouw code bezit het; het model nooit.

Maar context is niet gratis. Alles in het geheugen wordt bij de volgende stap weer in de prompt gestopt, en het model heeft een vast context window gemeten in tokens. Laat het geheugen eeuwig groeien en je overstroomt uiteindelijk het window (en betaal voor elk token daarnaast). Dus geheugen heeft twee helften nodig: accumulate nieuwe feiten terwijl je verder gaat, en trim terug naar een Budget wanneer het te groot wordt.

De vorm ervan

State is één dictionary: een permanente system notitie (de vaste instructies van de agent, die je nooit weggooit) en een lijst van facts die het heeft verzameld:

state = {"system": "You are a research agent.", "facts": []}

Elke waarneming wordt één feitenregel. Nadat een tool draait voeg je een leesbare registratie van wat er gebeurde toe:

state["facts"].append(f"{tool}({args}) -> {observation}")

Afkappen naar een token Budget

Echte tokenizers zijn geleerd en gebaseerd op subwoorden; we kunnen er hier geen draaien, dus schatten we een token als één woord met een witregel (len(text.split())) - dezelfde truc als bij het LLM module. (In productie zou je de echte subwoordtelling gebruiken van het usage veld van de API, of de len(text) / 4 vuistregel voor karakters; de witregel schatting houdt deze oefening gewoon deterministisch.) De trim regel weerspiegelt wat productie agents echt doen: bewaar altijd de systeemnotitie, bewaar dan zoveel van de meest-recente feiten als passen in wat overblijft van het Budget. Recency wint omdat de laatste resultaten meestal de resultaten zijn die de volgende stap nodig heeft.

budget = max_tokens - est_tokens(state["system"])
# walk facts newest-first, keep while they fit, then stop

Loop door de feiten van nieuw naar oud. Tel de tokenkosten van elk feit bij elkaar op tot het volgende feit het Budget zou overschrijden, en stop dan. Draai het om zodat de behouden feiten in hun oorspronkelijke volgorde blijven. Als het Budget heel klein is, kun je nul feiten behouden, maar de systeemnotitie overleeft altijd.

In een live agent zou het model render(state) bovenaan elke stap lezen en dezelfde accumulate-then-trim cyclus zou na elke tool call draaien, zodat het venster nooit overloopt. De on-device tutor kan deze lus aansturen, maar grading inspecteert alleen de deterministische status. Druk op Run om een korte transcriptie te verzamelen en kijk hoe de oudste feiten wegvallen onder een strak Budget.

Jij bent aan de beurt

Bouw het geheugen van de agent. Schrijf new_state(system_note) -> {"system": note, "facts": []}; record(state, tool, args, observation) die de feitenregel "<tool>(<args>) -> <observation>" toevoegt en de status retourneert; est_tokens(text) -> whitespace token count; en trim(state, max_tokens) die de systeemnotitie plus de meest recente feiten behoudt waarvan de tokens (de systeemnotitie telt mee voor het Budget) in max_tokens passen. Schrijf dan accumulate(system_note, transcript, max_tokens): start een nieuwe status, record elke (tool, args, observation) stap in volgorde, trim één keer aan het einde, en retourneer de bijgesneden status.

Een probleem ontdekt in deze les? Meld het · Vraag naar deze les

Deze oefening opent binnenkort

Maak de les ervoor af voordat deze wordt ontgrendeld. De hele cursus is gratis, geen account nodig, en je kunt deze les nu lezen.