Agenti ReAct e Plan-and-Execute
Comprenda e implementi architetture avanzate di agenti che combinano ragionamento e azione per portare a termine attività complesse.
Agenti ReAct e Plan-and-Execute è una lezione AI Agents with LangChain & Autonomous Workflows gratuita su CoddyKit. Questa è la lezione 1 di 6. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Agents with LangChain & Autonomous Workflows, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Agents with LangChain & Autonomous Workflows include 6 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
Beyond Simple AI Agents
Welcome to Advanced Agent Architectures! So far, you've learned about basic agents and chains in LangChain. These are great for straightforward tasks.
However, real-world problems can be complex. They often require agents to reason, make decisions, and perform multiple steps to achieve a goal. This is where advanced architectures come in.
Introducing ReAct Agents
One powerful advanced architecture is ReAct, which stands for Reasoning and Acting. It's inspired by how humans solve problems.
- Reasoning: The agent thinks about the problem, current state, and what to do next.
- Acting: The agent then performs an action, often by using a tool.
This cycle allows agents to dynamically adapt and solve complex tasks.
The ReAct Loop: Thought, Action, Observation
ReAct agents operate in an iterative loop:
- Thought: The agent generates a thought, explaining its reasoning and what it plans to do.
- Action: Based on the thought, the agent chooses a tool and its input (e.g., 'search', 'calculator').
- Observation: The agent receives the result from the tool's execution.
This loop continues until the agent believes it has enough information to provide a final answer.
ReAct in Action: A Simple Flow
Let's see a simplified Python example of how a ReAct agent's logic might flow. Notice how it thinks, acts, and observes to reach a conclusion.
def run_react_agent(query):
print(f"User Query: {query}")
print("Thought: I need to find the population of London. I will use a search tool.")
print("Action: Use 'search_tool' with query 'population of London'")
# Simulate tool output
observation = "Observation: The population of London is ~9 million (2023 est.)."
print(observation)
print("Thought: I have the information. I can now answer the user.")
print("Action: Respond with the observed information.")
return observation.replace("Observation: ", "")
if __name__ == "__main__":
result = run_react_agent("What is the population of London?")
print(f"\nFinal Answer: {result}")Understanding Plan-and-Execute
Another powerful architecture is Plan-and-Execute. Unlike ReAct, which is more reactive, Plan-and-Execute agents first create a comprehensive plan.
They are particularly effective for tasks that are complex, multi-step, and where a clear sequence of actions can be determined upfront.
The Planner and Executor Components
Plan-and-Execute agents typically consist of two main parts:
- The Planner: This component takes the initial goal and breaks it down into a sequence of smaller, manageable steps. It focuses on strategy.
- The Executor: This component then takes each step from the plan and carries it out, often by using specific tools. It focuses on execution.
This separation helps manage complexity and ensures a structured approach.
Plan-and-Execute: A Structured Flow
Here's a simplified Python example illustrating the Plan-and-Execute flow. Notice how the goal is first planned, then each step is executed in order.
def planner(goal):
print(f"Goal: {goal}")
print("Planner: Breaking down the goal into steps...")
plan = [
"Step 1: Find today's date.",
"Step 2: Get the weather forecast for New York City for today.",
"Step 3: Summarize the date and weather information."
]
print(f"Plan created: {plan}")
return plan
def executor(step):
print(f"Executing: {step}")
if "date" in step:
return "Observation: Today's date is October 26, 2023."
elif "weather" in step:
return "Observation: New York weather: Sunny, 60°F."
elif "summarize" in step:
return "Observation: Summary: Oct 26, 2023, NYC is Sunny, 60°F."
return "Observation: Step completed."
if __name__ == "__main__":
my_goal = "Tell me today's date and weather in New York City."
plan_steps = planner(my_goal)
print("\n--- Execution Phase ---")
for step in plan_steps:
res = executor(step)
print(res)ReAct vs. Plan-and-Execute
Both are powerful, but suited for different scenarios:
- ReAct: More dynamic and reactive. Best for tasks where the path isn't clear upfront, requiring exploration and iterative decision-making (e.g., complex research questions).
- Plan-and-Execute: More structured and systematic. Best for tasks where a clear sequence of steps can be defined (e.g., booking a flight with known steps: search, select, confirm).
Choosing the Right Architecture
When deciding between ReAct and Plan-and-Execute, consider:
- Task Complexity: Is it a clear, sequential task (Plan-and-Execute) or an exploratory, problem-solving one (ReAct)?
- Predictability: Can you easily predict the steps needed (Plan-and-Execute) or will the agent need to adapt dynamically (ReAct)?
- Error Handling: Plan-and-Execute can sometimes be easier to debug due to defined steps, while ReAct's dynamic nature can be harder to trace.
Quick Check: Agent Architectures
An AI agent needs to solve a complex, multi-step problem where the exact sequence of actions is not known beforehand, and it might need to explore different options and react to intermediate results.
Recap: Advanced Agent Architectures
Great job! In this lesson, you explored two advanced agent architectures:
- ReAct (Reasoning and Acting): Agents that iteratively think, act, and observe, suitable for dynamic, exploratory tasks.
- Plan-and-Execute: Agents that first create a detailed plan and then execute each step, ideal for structured, multi-step workflows.
Understanding these patterns helps you build more robust and intelligent AI agents for complex challenges. Next, we'll look at agents that can self-correct!
Domande Frequenti
La lezione «Agenti ReAct e Plan-and-Execute» è gratuita?
Sì — il testo completo di «Agenti ReAct e Plan-and-Execute» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Agents with LangChain & Autonomous Workflows, passa a CoddyKit PRO. Il corso AI Agents with LangChain & Autonomous Workflows include 6 lezioni in totale.
Cosa imparerò in «Agenti ReAct e Plan-and-Execute»?
Comprenda e implementi architetture avanzate di agenti che combinano ragionamento e azione per portare a termine attività complesse. Eserciti AI Agents with LangChain & Autonomous Workflows con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare AI Agents with LangChain & Autonomous Workflows?
Non è richiesta alcuna esperienza precedente. AI Agents with LangChain & Autonomous Workflows su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 6.
Quanto tempo richiede la lezione «Agenti ReAct e Plan-and-Execute»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione AI Agents with LangChain & Autonomous Workflows?
Sì. Ogni lezione AI Agents with LangChain & Autonomous Workflows include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Agenti ReAct e Plan-and-Execute
- Progettazione gerarchica degli agenti
- Agenti di autocorrezione e riflessione
- Architetture cognitive per gli agenti
- Pattern di collaborazione tra più agenti
- Sistemi di agenti ibridi