Programma Les 231 van 250 · Project: onderzoeksagent die tools gebruikt
Project: onderzoeksagent die tools gebruikt

Bedrading van de ReAct Loop van de Agent

Nu het hart van het project: de ReAct loop (Reason -> Act -> Observe), de control loop achter bijna elk agent framework. Het model geeft niet in één keer een antwoord. Het denkt een step, kiest een tool, voert deze uit, leest het resultaat, en beslist dan pas wat de volgende actie is. Jouw taak is om die loop in plain Python over mock tools te schrijven, zodat je de mechaniek begrijpt in plaats van LangChain als een black box te behandelen.

In een echte uitrol is de "reason" stap een LLM call. Hier vervangen we het model door een kleine deterministische policy zodat het geheel offline testbaar is (geen netwerk, geen API). De policy kijkt naar de taak en naar de observaties die tot nu toe zijn verzameld, en geeft de volgende actie terug. Die scheiding is de echte les: de loop is generiek; alleen de policy is slim.

taak is een kleine specificatie die het beleid leest:

task = {"need": ["team size", "office floors"], "op": "*"}
# "look up these facts, then combine them with this operator"

Je bouwt run_agent(task, tools, max_steps=8). Het geeft een trace terug: een geordende lijst van (thought, tool, args, observation) tuples, één per stap. Die trace is de volledige redeneringsgeschiedenis van de agent, en dat is precies wat je logt, opnieuw afspeelt en (volgende lessen) evalueert.

De redenering die de lus codeert, elke iteratie:

  • Als een nodig feit nog steeds onbekend is, is de volgende actie search voor het eerste ontbrekende feit. Noteer de waarneming en onthoud het feit.
  • Zodra alle feiten zijn verzameld en de taak een op heeft, is de volgende actie calc om de twee feiten te combineren. Onthoud het resultaat.
  • Wanneer er niets meer te doen is, voer je een laatste finish actie uit waarvan de observatie het antwoord is, en stop je.
def run_agent(task, tools, max_steps=8):
    trace, facts = [], {}
    for _ in range(max_steps):
        missing = [k for k in task["need"] if k not in facts]
        if missing:
            key = missing[0]
            obs = tools["search"]({"query": key})   # ACT + OBSERVE
            facts[key] = obs
            trace.append(("need " + key, "search", {"query": key}, obs))
            continue
        ...   # compute if there is an op, else finish

De tools dict is je register uit les 1 in geest: search(args) lost een feit op, calc(args) past op toe op a en b. Het final answer is het calc resultaat wanneer er een op is, of het enkel opgezochte feit wanneer dat niet zo is. De grader controleert de stapsgewijze (tool, args, observation) sequence en het finale antwoord, dus de loop moet daadwerkelijk correct routeren, niet gokken. Het voert ook een second, different taak uit, dus een hardgecode trace kan niet slagen. Druk op Run om te zien hoe een taak met twee feiten zijn weg naar een antwoord redeneert.

Jij bent aan de beurt

Schrijf make_tools() die een dictionary retourneert met search(args) (los args["query"] op tegen de FACTS tabel gegeven in de starter; "not found" als afwezig) en calc(args) (pas args["op"] toe over args["a"], args["b"] voor + - * /). Schrijf dan run_agent(task, tools, max_steps=8) die de reason-act-observe lus implementeert: zoek elke nog ontbrekende sleutel in task["need"] (eerst de eerste ontbrekende), dan calc als task["op"] is ingesteld, dan een laatste finish stap geschreven als (thought, "finish", {"answer": answer}, answer). Retourneer de geordende lijst van (thought, tool, args, observation) tuples; het uiteindelijke antwoord is het calc resultaat, of het enkele feit wanneer er geen op is.

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.