ReAct Prompting — Come Insegnare all'AI a Ragionare e Agire in Loop per Risultati Concreti

Hai mai chiesto a un'AI di cercare dati aggiornati e ti ha risposto con numeri inventati? Di calcolare il costo di una spedizione e ha sbagliato perché non poteva navigare sul sito del corriere? Il problema non è il modello: è che stai chiedendo a un cervello di fare cose da mano. Serve un loop: pensare, poi fare, poi pensare ancora. Questo è il ReAct prompting.

Noi, di Meteora Web, costruiamo sistemi AI per clienti reali — e abbiamo visto centinaia di prompt fallire perché il modello ragiona nel vuoto. Il ReAct (Reason + Act) è la tecnica che permette all'AI di usare strumenti esterni (API, database, calcolatrici) mentre ragiona, tornando un risultato basato su fatti, non su fantasia. In questa guida vediamo come funziona, quando conviene e come implementarlo subito con Python e OpenAI.

Cos'è il ReAct Prompting e Come Funziona il Loop Ragione-Azione?

Immagina un detective che deve risolvere un caso. Non si siede e scrive un romanzo: formula un'ipotesi (Thought), esce a cercare prove (Action), analizza i risultati (Observation), poi formula una nuova ipotesi. Il ReAct prompting formalizza esattamente questo: il modello genera un pensiero, decide un'azione da compiere (es. chiamare una API, cercare su un database), riceve l'osservazione e ripete finché non ha abbastanza informazioni per rispondere.

La struttura di ogni passo è chiara:

• Thought: il modello ragiona su cosa fare dopo.
• Action: specifica quale strumento usare e con quali parametri (es. "search: ultimo prezzo del petrolio").
• Observation: il risultato dell'azione viene reinserito nel contesto.
• Si ripete fino a un Final Answer quando il modello decide di aver raccolto dati sufficienti.

Questo loop è alla base di tutti gli AI agent moderni (LangChain, AutoGPT). Ma puoi implementarlo anche con una semplice chiamata alle API OpenAI e un ciclo while. Il segreto è un prompt di sistema che istruisce il modello a produrre output strutturati (es. JSON con i campi thought, action, action_input, observation).

Quando Conviene Usare il ReAct Invece di un Prompt Diretto?

Il ReAct non serve sempre. Per domande fattuali semplici ("Qual è la capitale della Francia?") un prompt diretto è più veloce ed economico. Ma ecco i casi in cui il loop cambia le carte in tavola:

• Ricerca dati aggiornati: se devi rispondere in base a quotazioni borsa, meteo, stock di magazzino. Il modello da solo non sa il dato attuale.
• Calcoli complessi: molti LLM sbagliano somme con più di 4 cifre. Con ReAct puoi chiamare una calcolatrice (es. eval Python) e ottenere il risultato esatto.
• Multi-step reasoning con verifiche: per esempio, "Verifica se l'articolo X è disponibile, poi calcola il prezzo con IVA e spedizione". Ogni passo può usare uno strumento diverso.
• Riduzione delle allucinazioni: costringendo il modello a basarsi su osservazioni reali, si abbassa drasticamente il rischio di invenzioni.

Noi lo applichiamo spesso per clienti e-commerce: il bot deve controllare il magazzino (API ERP), calcolare il costo di spedizione (API corriere), e poi rispondere. Senza ReAct, il modello inventa i dati. Con il loop, ogni informazione è verificata.

Come Implementare il ReAct Prompting con le API di OpenAI?

Struttura di base: system prompt e formato di output

Per far sì che il modello segua il loop, dobbiamo istruirlo a produrre output in un formato parsabile. Usiamo JSON con i campi thought, action, action_input e observation. Ecco un esempio di system prompt:

Sei un assistente che risponde usando il metodo ReAct.
Ogni tua risposta deve essere un JSON valido con questi campi:
- thought: il tuo ragionamento attuale (stringa)
- action: il nome dello strumento da chiamare o "final_answer" se hai finito
- action_input: i parametri per lo strumento (stringa)

Strumenti disponibili:
- search: query di ricerca web
- calculator: espressione matematica da valutare

Regole:
1. Fai un passo alla volta.
2. Dopo ogni azione, riceverai un campo "observation" con il risultato.
3. Quando hai abbastanza dati, usa action "final_answer" e metti la risposta in action_input.

Ciclo di esecuzione in Python

Il codice seguente implementa un esempio minimale con OpenAI. Copia, incolla e sostituisci la tua API key.

import openai
import json
import re

openai.api_key = "sk-..."

def call_llm(messages):
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=messages,
        temperature=0
    )
    return response.choices[0].message.content

def extract_json(text):
    # Cerca il primo JSON valido nel testo
    match = re.search(r'\{.*\}', text, re.DOTALL)
    if match:
        return json.loads(match.group())
    return None

def execute_action(action, action_input):
    # Simula strumenti: in produzione chiama API reali
    if action == "search":
        # Simula un motore di ricerca
        return f"Risultati fittizi per '{action_input}': prezzo olio d'oliva = 12 €/L"
    elif action == "calculator":
        try:
            result = eval(action_input)
            return str(result)
        except:
            return "Errore di calcolo"
    else:
        return "Azione sconosciuta"

# Esempio: domanda che richiede calcolo + ricerca
domanda = "Quanto costa 3 litri di olio d'oliva se il prezzo al litro è quello attuale?"
system_prompt = """Sei un assistente che risponde usando il metodo ReAct... (come sopra)"""
messages = [
    {"role": "system", "content": system_prompt},
    {"role": "user", "content": domanda}
]

max_loop = 5
for i in range(max_loop):
    output = call_llm(messages)
    step = extract_json(output)
    if not step:
        print("Errore parsing JSON")
        break
    print(f"Passo {i+1}:", json.dumps(step, indent=2))
    
    if step["action"] == "final_answer":
        print("\nRisposta finale:", step["action_input"])
        break
    
    observation = execute_action(step["action"], step["action_input"])
    messages.append({"role": "assistant", "content": output})
    messages.append({"role": "user", "content": f"Observation: {observation}"})
else:
    print("Loop massimo raggiunto")

Questo codice è volutamente semplice per far capire il meccanismo. In produzione useresti strumenti reali (API di ricerca, calcolatrice sicura, connessione a database) e parser più robusti.

Esempio con funzioni reali (API Search)

Se vuoi integrare una vera API di ricerca (es. SerpAPI o Tavily), sostituisci la funzione execute_action con chiamate HTTP reali. Noi usiamo spesso Tavily per la sua bassa latenza e costo contenuto.

Quali Sono i Costi e i Rischi del ReAct Prompting?

Ogni passo del loop consuma token in input (tutta la cronologia) e output. Con GPT-4, un loop di 3-5 passi può costare facilmente 10-20 centesimi di dollaro per risposta. Per applicazioni B2B con volumi ridotti è accettabile; per chatbot al pubblico devi ottimizzare o usare modelli più piccoli (GPT-4o-mini).

Rischi da gestire:

• Loop infinito: il modello potrebbe continuare a chiamare azioni senza mai decidere. Imposta sempre un numero massimo di iterazioni.
• Strumenti non sicuri: se permetti l'esecuzione di codice (es. eval), assicurati di sanificare l'input. Mai eseguire codice generato dall'AI senza sandbox.
• Allucinazioni residue: se l'osservazione è vuota o errata, il modello potrebbe inventare. Controlla sempre che l'azione sia stata eseguita correttamente.

Noi, di Meteora Web, consigliamo di partire con un budget di test: 10 query con ReAct, confrontare la qualità rispetto a prompt standard, e solo dopo decidere se il costo extra vale il miglioramento.

Cosa Fare Adesso

1. Prova il codice esempio: prendi la tua API key OpenAI, copia lo script sopra e testalo con una domanda che richiede ricerca o calcolo.
2. Aggiungi strumenti reali: sostituisci le funzioni simulate con chiamate a API (meteo, prezzi, database). Inizia con un solo strumento (es. una calcolatrice) per prendere confidenza.
3. Misura costo e accuratezza: confronta la stessa domanda con e senza ReAct. Quante volte ottieni una risposta corretta? Quanto costa in media?
4. Limita il loop: imposta un massimo di 3-5 iterazioni nel tuo codice per evitare sorprese.
5. Approfondisci: leggi la nostra guida principale sul Prompt Engineering Avanzato per altre tecniche complementari.

Il ReAct non è magia: è disciplina. Insegna all'AI a non sparare nel buio, ma a cercare la luce un passo alla volta. E quando la provi, capisci perché lo chiamano il metodo che trasforma un chatbot in un agente.