De ReAct lus over mock tools
Strap de marketing eraf en een "AI agent" is een lus. Het model onderneemt niet magisch acties; jouw code doet dat. Het patroon is ReAct: Reason over wat te doen, neem een Action door een tool aan te roepen, Observe het resultaat, en loop dan tot de taak klaar is. Het model produceert alleen tekst; de lus eromheen zet die tekst om in echte tool calls en voert de resultaten terug.
De redeneringsstap is het LLM, en het is niet-deterministisch, dus we kunnen het niet unit-testen. Maar alles eromheen is deterministisch en is precies wat in productie kapot gaat: de dispatch, de observation handling, de stop conditie. Dus we testen de loop met de taak van het model vervangen door een scripted plan - een vaste lijst van (tool, args) acties. Dat is hoe je een agent echt unit-testt: zet het plan vast, assert de trace.
Je bouwt run_agent(plan, tools, max_steps). plan is een lijst van stappen zoals ("lookup", {"country": "France"}). tools is een dictionary die een toolnaam koppelt aan een Python functie die de args dictionary aanneemt en een observation teruggeeft. Voor elke stap roep je de bijbehorende tool aan en voeg je een (tool, args, observation) triple toe aan een trace - het audit log van wat de agent deed.
def run_agent(plan, tools, max_steps=10):
trace = []
for action, args in plan:
if len(trace) >= max_steps:
break
if action == "finish":
break
observation = tools[action](args)
trace.append((action, args, observation))
return traceDe regels:
- Voor elke stap roep je
tools[action](args)aan en noteer je(action, args, observation)in volgorde. - A
"finish"act beëindigt de lus onmiddellijk en wordt niet opgenomen in de trace (het is een signaal, geen tool call). - Stop zodra de trace al
max_stepsentries bevat, zelfs als het plan meer steps heeft - die guard stopt een runaway agent. - Als een step geen args heeft, behandel het dan als een lege dict.
In een echte app zou het LLM elke volgende actie als JSON uitstoten en dezelfde loop zou deze uitvoeren, dus kun je het gescripte plan vervangen door live model output zonder de loop aan te raken. De on-device tutor kan deze loop live aansturen, maar het beoordelen kijkt alleen naar de deterministische trace. Druk op Run om te zien hoe een plan van twee stappen wordt uitgevoerd: zoek een hoofdstad op, doe dan een berekening en maak het af.
Wat je net hebt gebouwd heeft een naam in de industrie. Deze observe-think-act loop is de kern van elk agent framework: LangGraph en soortgelijke libraries geven je deze loop als een graph van nodes, hosted agent APIs draaien het aan de kant van de provider, en een MCP client is eigenlijk gewoon deze loop verbonden aan tools die het via een protocol ontdekt. Ze voegen streaming, retries, persistence en tracing toe, maar de engine is precies de loop die je schreef. Het één keer vanaf nul bouwen is wat die frameworks leesbaar maakt in plaats van magie: je zult precies weten welk deel elk framework automatiseert.
Schrijf run_agent(plan, tools, max_steps=10) dat een gescript plan van (tool, args) stappen uitvoert tegen een mock tool registry. Roep voor elke stap tools[action](args) aan en voeg (action, args, observation) toe aan een trace lijst. Een "finish" actie stopt de lus en wordt niet vastgelegd; stop zodra de trace max_steps items bevat. Geef de trace terug.
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.
Deze browser blokkeert cookies voor learn.floati.life, dus lessen die je hier hebt afgerond kunnen niet in de juiste volgorde worden geopend. Sta cookies toe voor deze site en laad de pagina opnieuw.