AI Agents with LangChain & Autonomous Workflows · 课时

ReAct 与规划执行型智能体

了解并实现结合推理与行动的高级智能体架构，以完成复杂任务

ReAct 与规划执行型智能体 是 CoddyKit 上的免费 AI Agents with LangChain & Autonomous Workflows 课时。这是第 1 节课，共 6 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 AI Agents with LangChain & Autonomous Workflows 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 AI Agents with LangChain & Autonomous Workflows 课程共包含 6 节课。

本课时的部分内容尚未翻译，以英文显示。

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!

常见问题解答

「ReAct 与规划执行型智能体」课时是免费的吗？

是的 — 「ReAct 与规划执行型智能体」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 AI Agents with LangChain & Autonomous Workflows 课程的其余内容，请升级到 CoddyKit PRO。 AI Agents with LangChain & Autonomous Workflows 课程共包含 6 节课。

「ReAct 与规划执行型智能体」这节课中我会学到什么？

了解并实现结合推理与行动的高级智能体架构，以完成复杂任务你通过在浏览器中直接运行的动手代码来练习 AI Agents with LangChain & Autonomous Workflows，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 AI Agents with LangChain & Autonomous Workflows 需要有经验吗？

无需任何先前经验。CoddyKit 上的 AI Agents with LangChain & Autonomous Workflows 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 1 节课，共 6 节。

「ReAct 与规划执行型智能体」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 AI Agents with LangChain & Autonomous Workflows 课中编写并运行代码吗？

能。每节 AI Agents with LangChain & Autonomous Workflows 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 AI Agents with LangChain & Autonomous Workflows