AI-serie interviewvraag 6: De drie kernmethodologieën van AI Agent: ReAct, Plan-and-Solve en Reflection

Drie kernmethodologieën van AI Agent: ReAct, Plan-and-Solve en Reflection

Een AI Agent is een intelligente entiteit die autonoom zijn omgeving kan waarnemen, beslissingen kan nemen en acties kan uitvoeren. De drie belangrijkste methodologieën zijn ReAct, Plan-and-Solve en Reflection. Hieronder worden ze beschreven, vergezeld van stroomdiagrammen en codevoorbeelden.

1. ReAct (Reasoning + Acting)

Kernidee: Redeneren (Reasoning) en handelen (Acting) worden afgewisseld. De Agent denkt eerst na over de huidige toestand en de volgende stap (redeneren), voert vervolgens een actie uit (zoals het aanroepen van een tool of het zoeken van informatie), en gaat verder met redeneren op basis van het resultaat.

Stroomdiagram:

[Begintoestand] → [Redeneren: volgende stap bedenken] → [Actie: actie uitvoeren] → [Resultaat observeren] → [Redeneren: plan bijwerken] → ... → [Eindantwoord]

Voorbeeldcode (pseudocode):

def react_agent(question):
    context = []
    while not solved:
        # Redeneren: denkstap genereren
        thought = llm.generate_thought(question, context)
        # Actie: kies actie op basis van gedachte
        action = llm.choose_action(thought)
        # Voer actie uit, krijg observatie
        observation = execute_action(action)
        # Voeg gedachte, actie en observatie toe aan context
        context.append((thought, action, observation))
    return final_answer

Voorbeeld:
- Gebruiker vraagt: "Hoe is het weer vandaag in Peking?"
- Agent redeneert: "Ik moet de weer-API raadplegen, ik heb de stadsnaam en datum nodig."
- Actie: Roep weer-API aan (parameters: Peking, vandaag)
- Observatie: retourneert "Zonnig, 25°C"
- Redeneren: "Ik heb de informatie, ik kan antwoorden."
- Uitvoer: "Het is vandaag zonnig in Peking, 25°C."

2. Plan-and-Solve

Kernidee: Eerst een volledig plan maken (Plan), dan stap voor stap uitvoeren (Solve). In de planfase wordt de complexe taak opgesplitst in substappen; in de uitvoeringsfase worden deze in volgorde voltooid, mogelijk met aanpassingen op basis van tussentijdse resultaten.

Stroomdiagram:

[Taak] → [Plan maken: substappen opsplitsen] → [Stap 1 uitvoeren] → [Stap 2 uitvoeren] → ... → [Stap N uitvoeren] → [Eindantwoord]

Voorbeeldcode:

def plan_and_solve(task):
    # Planfase
    plan = llm.generate_plan(task)  # Bijv.: ["Informatie zoeken", "Gegevens ordenen", "Rapport schrijven"]
    context = {}
    for step in plan:
        # Voer elke stap uit
        result = execute_step(step, context)
        context[step] = result
    # Synthetiseer resultaten
    final = llm.synthesize(context)
    return final

Voorbeeld:
- Taak: "Schrijf een blog over AI Agent"
- Plan:
1. Zoek naar definitie en nieuwste ontwikkelingen van AI Agent
2. Lees en vat kernpunten samen
3. Maak een blog outline
4. Vul inhoud in
5. Proeflezen en publiceren
- Uitvoering: Voer elke stap achtereenvolgens uit, lever uiteindelijk de blog op.

3. Reflection

Kernidee: De Agent reflecteert tijdens of na de uitvoering op zijn eigen gedrag, evalueert het resultaat en verbetert volgende acties. Dit omvat zelfkritiek, foutcorrectie of strategieoptimalisatie.

Stroomdiagram:

[Actie] → [Resultaat observeren] → [Reflectie: beoordeel of succesvol] → [Indien mislukt: strategie aanpassen] → [Opnieuw actie] → ... → [Succes]

Voorbeeldcode:

def reflection_agent(task):
    max_attempts = 3
    for attempt in range(max_attempts):
        action = llm.generate_action(task)
        result = execute(action)
        # Reflectie
        reflection = llm.reflect(task, action, result)
        if reflection['success']:
            return result
        else:
            # Pas taakomschrijving of strategie aan op basis van reflectie
            task = reflection['improved_task']
    return None

Voorbeeld:
- Taak: "Bereken 1234 * 5678"
- Actie: Direct berekenen, resultaat 7006652
- Reflectie: Controleer berekeningsproces, ontdek fout in overdracht
- Aanpassing: Herbereken, krijg correct resultaat 7006652 (eigenlijk correct)
- Indien nog fout, blijf reflecteren tot correct.

Samenvatting en vergelijking

In de praktijk worden deze drie vaak gecombineerd, bijvoorbeeld ReAct met een reflectiemechanisme, of Plan-and-Solve waarbij na elke stap wordt gereflecteerd.