Programma Lezione 231 di 250 · Progetto: un agente di ricerca che usa strumenti
Progetto: un agente di ricerca che usa strumenti

Collegare il ciclo ReAct dell'agente

Ora il cuore del progetto: il ciclo ReAct (Ragiona -> Agisci -> Osserva), il ciclo di controllo dietro praticamente ogni framework per agenti. Il modello non risponde in un colpo. Pensa un passo, sceglie uno strumento, lo esegue, legge il risultato, e solo allora decide che cosa fare dopo. Il tuo lavoro è scrivere quel ciclo in semplice Python su strumenti simulati, così capisci il meccanismo invece di trattare LangChain come una scatola nera.

In un rilascio vero il passo "ragiona" è una chiamata a un LLM. Qui sostituiamo il modello con una piccola politica deterministica così tutto si può testare offline (niente rete, niente API). La politica guarda il compito e le osservazioni raccolte fin lì, e restituisce l'azione successiva. Quella separazione è la vera lezione: il ciclo è generico; solo la politica è intelligente.

Un compito è una piccola specifica che la politica legge:

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

Costruirai run_agent(task, tools, max_steps=8). Restituisce una traccia: una lista ordinata di tuple (thought, tool, args, observation), una per passo. Quella traccia è tutta la storia del ragionamento dell'agente, ed è esattamente ciò che registri, rigiochi e (nelle prossime lezioni) valuti.

Il ragionamento che codifica il ciclo, a ogni iterazione:

  • Se un fatto necessario è ancora sconosciuto, l'azione successiva è search del primo mancante. Registra l'osservazione e ricorda il fatto.
  • Una volta raccolti tutti i fatti e se il compito ha un op, l'azione successiva è calc per combinare i due fatti. Ricorda il risultato.
  • Quando non resta niente da fare, emetti un'azione finale finish la cui osservazione è la risposta, e fermati.
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

Il dict tools è nello spirito il tuo registro della lezione 1: search(args) risolve un fatto, calc(args) applica op ad a e b. La risposta finale è il risultato di calc quando c'è un op, o il singolo fatto cercato quando non c'è. Il correttore controlla la sequenza passo per passo (tool, args, observation) e la risposta finale, quindi il ciclo deve instradare davvero in modo giusto, non tirare a indovinare. Fa girare anche un secondo compito, diverso, quindi una traccia scritta a mano non può passare. Premi Run per guardare un compito a due fatti ragionare fino a una risposta.

Tocca a te

Scrivi make_tools() che restituisce un dict con search(args) (risolvi args["query"] nella tabella FACTS data nel codice di partenza; "not found" se manca) e calc(args) (applica args["op"] ad args["a"], args["b"] per + - * /). Poi scrivi run_agent(task, tools, max_steps=8) che implementa il ciclo ragiona-agisci-osserva: cerca con search ogni chiave ancora mancante in task["need"] (prima la prima mancante), poi calc se task["op"] è impostato, poi un passo finale finish scritto come (thought, "finish", {"answer": answer}, answer). Restituisci la lista ordinata delle tuple (thought, tool, args, observation); la risposta finale è il risultato di calc, o il singolo fatto quando non c'è un op.

Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione

Questo esercizio si apre presto

Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.