Programma Lezione 172 di 250 · Costruire agenti (uso di strumenti e ReAct)
Costruire agenti (uso di strumenti e ReAct)

Il ciclo ReAct su strumenti simulati

Togli il marketing e un "agente IA" è un ciclo. Il modello non compie azioni per magia; le compie il tuo codice. Lo schema è ReAct: Ragiona (Reason) su che cosa fare, compi un'Azione (Act) chiamando uno strumento, Osserva (Observe) il risultato, poi ripeti finché il compito non è finito. Il modello produce sempre e solo testo; il ciclo intorno trasforma quel testo in vere chiamate agli strumenti e gli rimanda i risultati.

Il passo di ragionamento è l'LLM, e non è deterministico, quindi non possiamo farci test unitari. Ma tutto ciò che c'è intorno è deterministico ed è esattamente ciò che si rompe in produzione: lo smistamento, la gestione delle osservazioni, la condizione di arresto. Quindi testiamo il ciclo sostituendo il lavoro del modello con un piano prestabilito: una lista fissa di azioni (tool, args). È così che si fanno davvero i test unitari di un agente: fissi il piano, verifichi la traccia.

Costruirai run_agent(plan, tools, max_steps). plan è una lista di passi come ("lookup", {"country": "France"}). tools è un dict che associa al nome di uno strumento una funzione Python che riceve il dict degli argomenti e restituisce un'osservazione. Per ogni passo chiami lo strumento corrispondente e aggiungi una tripla (tool, args, observation) a una traccia: il registro di ciò che ha fatto l'agente.

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 trace

Le regole:

  • Per ogni passo, chiama tools[action](args) e registra (action, args, observation) in ordine.
  • Un'azione "finish" chiude subito il ciclo e non viene registrata nella traccia (è un segnale, non una chiamata a uno strumento).
  • Fermati quando la traccia contiene già max_steps voci, anche se il piano ha altri passi: quella protezione ferma un agente impazzito.
  • Se un passo non ha argomenti, trattalo come un dict vuoto.

In un'app reale l'LLM emetterebbe ogni azione successiva come JSON e lo stesso ciclo la eseguirebbe, quindi potresti sostituire il piano prestabilito con l'uscita dal vivo del modello senza toccare il ciclo. Il tutor sul dispositivo può guidare dal vivo proprio questo ciclo, ma la correzione guarda sempre e solo la traccia deterministica. Premi Run per guardare un piano di due passi: cerca una capitale, poi fai un po' di aritmetica, poi finisci.

Ciò che hai appena costruito ha un nome nel settore. Questo ciclo osserva-pensa-agisci è il cuore di ogni framework per agenti: LangGraph e librerie simili ti danno questo ciclo come un grafo di nodi, le API di agenti ospitati lo fanno girare dalla parte del fornitore, e un client MCP è in realtà solo questo ciclo collegato a strumenti che scopre tramite un protocollo. Aggiungono streaming, nuovi tentativi, persistenza e tracciamento, ma il motore è esattamente il ciclo che hai scritto. Costruirlo da zero una volta è ciò che rende quei framework leggibili invece che magici: saprai esattamente quale parte automatizza ciascuno.

Tocca a te

Scrivi run_agent(plan, tools, max_steps=10) che esegue un piano prestabilito di passi (tool, args) su un registro di strumenti simulati. Per ogni passo, chiama tools[action](args) e aggiungi (action, args, observation) a una lista traccia. Un'azione "finish" ferma il ciclo e non viene registrata; fermati quando la traccia contiene max_steps voci. Restituisci la traccia.

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.