Domande di intervista sulla serie AI 6: i tre metodi fondamentali dell'AI Agent: ReAct, Plan-and-Solve e Reflection

I tre metodi fondamentali dell'AI Agent: ReAct, Plan-and-Solve e Reflection

Un AI Agent è un'entità intelligente in grado di percepire autonomamente l'ambiente, prendere decisioni ed eseguire azioni. I suoi metodi fondamentali sono principalmente tre: ReAct, Plan-and-Solve e Reflection. Di seguito vengono presentati singolarmente, accompagnati da diagrammi di flusso ed esempi di codice.

1. ReAct (Reasoning + Acting)

Idea centrale: alternare ragionamento (Reasoning) e azione (Acting). Ad ogni passo, l'Agent riflette sullo stato attuale e sul piano successivo (ragionamento), poi esegue un'azione (come chiamare uno strumento, cercare informazioni), e infine continua a ragionare in base al risultato.

Diagramma di flusso:

[Stato iniziale] → [Ragionamento: pensa al passo successivo] → [Azione: esegui azione] → [Osserva risultato] → [Ragionamento: aggiorna piano] → ... → [Risposta finale]

Codice di esempio (pseudocodice):

def react_agent(question):
    context = []
    while not solved:
        # Ragionamento: genera un passo di pensiero
        thought = llm.generate_thought(question, context)
        # Azione: sceglie un'azione in base al pensiero
        action = llm.choose_action(thought)
        # Esegue l'azione, ottiene un'osservazione
        observation = execute_action(action)
        # Aggiunge pensiero, azione e osservazione al contesto
        context.append((thought, action, observation))
    return final_answer

Esempio:
- Utente chiede: "Com'è il tempo oggi a Pechino?"
- Agent ragiona: "Devo interrogare l'API meteo, ho bisogno del nome della città e della data."
- Azione: chiama API meteo (parametri: Pechino, oggi)
- Osservazione: restituisce "Sereno, 25°C"
- Ragionamento: "Ho ottenuto le informazioni, posso rispondere."
- Output: "Oggi a Pechino è sereno, 25°C."

2. Plan-and-Solve

Idea centrale: prima elaborare un piano completo (Plan), poi eseguirlo gradualmente (Solve). Nella fase di pianificazione, il compito complesso viene scomposto in sotto-passi; nella fase di esecuzione, si procede in ordine, con la possibilità di aggiustare il piano in base ai risultati intermedi.

Diagramma di flusso:

[Compito] → [Elabora piano: scomponi in sotto-passi] → [Esegui passo 1] → [Esegui passo 2] → ... → [Esegui passo N] → [Risposta finale]

Codice di esempio:

def plan_and_solve(task):
    # Fase di pianificazione
    plan = llm.generate_plan(task)  # ad esempio: ["Cerca materiali", "Organizza informazioni", "Scrivi report"]
    context = {}
    for step in plan:
        # Esegue ogni passo
        result = execute_step(step, context)
        context[step] = result
    # Sintetizza i risultati
    final = llm.synthesize(context)
    return final

Esempio:
- Compito: "Scrivi un blog sugli AI Agent"
- Piano:
1. Cerca definizione e ultimi progressi degli AI Agent
2. Leggi e organizza i punti chiave
3. Scrivi la bozza del blog
4. Completa i contenuti
5. Correggi e pubblica
- Esecuzione: completa ogni passo in sequenza, output finale del blog.

3. Reflection

Idea centrale: l'Agent riflette (Reflection) sulle proprie azioni durante o dopo l'esecuzione, valuta i risultati e migliora le azioni successive. Include tipicamente autocritica, correzione degli errori o ottimizzazione della strategia.

Diagramma di flusso:

[Azione] → [Osserva risultato] → [Riflessione: valuta se successo] → [Se fallimento: aggiusta strategia] → [Nuova azione] → ... → [Successo]

Codice di esempio:

def reflection_agent(task):
    max_attempts = 3
    for attempt in range(max_attempts):
        action = llm.generate_action(task)
        result = execute(action)
        # Riflessione
        reflection = llm.reflect(task, action, result)
        if reflection['success']:
            return result
        else:
            # Aggiusta la descrizione del compito o la strategia in base alla riflessione
            task = reflection['improved_task']
    return None

Esempio:
- Compito: "Calcola 1234 * 5678"
- Azione: calcolo diretto, risultato 7006652
- Riflessione: controlla il processo di calcolo, trova un errore di riporto
- Aggiustamento: ricalcola, ottiene il risultato corretto 7006652 (in realtà corretto)
- Se ancora errato, continua a riflettere fino a quando non è corretto.

Riepilogo e confronto

Nelle applicazioni reali, spesso si combinano i tre metodi, ad esempio aggiungendo un meccanismo di riflessione a ReAct, o riflettendo dopo ogni passo in Plan-and-Solve.