小菜鸟

java菜鸟号正在起航

0%

让 AI 学会“三思而后行”：用 Plan-and-Execute 架构构建复杂任务智能体

发表于 分类于 阅读次数： Valine：
本文字数： 5.1k 阅读时长 ≈ 5 分钟

让 AI 学会“三思而后行”：用 Plan-and-Execute 架构构建复杂任务智能体

一、为什么需要 Plan-and-Execute？

传统的 ReAct 模式（Reasoning + Acting）虽然强大，但面对复杂任务时存在一个明显的缺陷：模型往往是“边想边做”，走一步看一步。这就像一个人在没有地图的情况下蒙眼走路——遇到岔路容易迷失方向，尤其是当任务包含多个依赖步骤时。

举个例子，用户提出这样的需求：

“请帮我获取关于 AI 的英文文章摘要，并把它翻译成中文。”

这个任务天然包含两个有依赖关系的步骤：

  1. 必须先获取英文摘要（get_article_summary）
  2. 然后再翻译成中文（translate_text）

如果让普通 Agent 来处理，它可能会：

  • 直接调用翻译工具（但还没有拿到原文）
  • 或者先获取摘要后忘记翻译
  • 或者在多步之间陷入混乱

Plan-and-Execute 架构正是为了解决这个问题而生的。它的核心理念是：

先规划（Plan），后执行（Execute） —— 就像项目经理先制定蓝图，再分配给团队成员执行。

二、架构原理：把 Agent 拆成“大脑”和“双手”

Plan-and-Execute 架构将传统的 Agent 一分为二：

组件 英文名 职责 类比
规划器 Planner 分析复杂任务，拆解成有序的步骤列表 项目经理
执行器 Executor 拿着工具列表，逐步执行计划 一线工程师

工作流程：

1
用户输入 → Planner（生成步骤列表）→ Executor（逐步执行）→ 返回结果

这种分离带来的好处：

  • 逻辑清晰：规划阶段不执行，执行阶段不思考
  • 可追溯：可以看到每一步的执行计划
  • 容错性强：某一步失败可以重新规划

三、完整代码解析

3.1 环境准备

1
pip install langchain langchain-openai langchain-experimental

注意：langchain-experimental 包含了 Plan-and-Execute 的实现

3.2 初始化大模型

1
2
3
4
5
6
7
8
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="qwen3-max",  # 推荐使用 qwen-plus 或 qwen-max，规划阶段需要强逻辑能力
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
    api_key="your-api-key",
    temperature=0  # 保持确定性输出
)

为什么推荐 Qwen-Max？ 规划阶段需要对任务进行语义理解和逻辑拆解，这对模型的推理能力要求很高。Qwen-Max 在这一方面表现优异。

3.3 定义有依赖关系的工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from langchain.tools import tool

@tool
def get_article_summary(topic: str) -> str:
    """获取指定主题的英文科技文章摘要。参数 topic 为文章主题（如 AI, Blockchain）。"""
    mock_articles = {
        "AI": "Artificial Intelligence is rapidly transforming industries by automating complex tasks and providing deep insights from data.",
        "Blockchain": "Blockchain is a decentralized ledger technology that ensures secure, transparent, and tamper-proof transactions."
    }
    return mock_articles.get(topic, f"Sorry, no article summary found for topic: {topic}")

@tool
def translate_text(text: str) -> str:
    """将指定的英文文本翻译成流畅的中文。参数 text 为需要翻译的英文段落。"""
    if "Artificial Intelligence" in text:
        return "人工智能正在通过自动化复杂任务和提供深度的数据洞察，迅速改变各个行业。"
    elif "Blockchain" in text:
        return "区块链是一种去中心化的账本技术，能够确保交易的安全、透明和防篡改。"
    else:
        return f"[模拟翻译结果]：{text}"

关键设计：

  • 这两个工具天然存在依赖关系：translate_text 需要的 text 参数，必须由 get_article_summary 提供
  • 清晰的 docstring 帮助 Planner 理解每个工具的功能

3.4 组装 Plan-and-Execute 架构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from langchain_experimental.plan_and_execute import (
    PlanAndExecute, 
    load_agent_executor, 
    load_chat_planner
)

# 创建规划器：负责拆解任务
planner = load_chat_planner(llm)

# 创建执行器：负责执行计划
executor = load_agent_executor(
    llm, 
    tools=[get_article_summary, translate_text], 
    verbose=True  # 打印执行过程
)

# 组合成完整的智能体
agent = PlanAndExecute(
    planner=planner, 
    executor=executor, 
    verbose=True
)

3.5 下达复杂指令并观察执行过程

1
2
3
4
complex_task = "请帮我获取关于 AI 的英文文章摘要，并把它翻译成中文。"
result = agent.invoke({"input": complex_task})

print(f"最终结果: {result['output']}")

四、运行效果：亲眼见证“先想后做”

当您运行代码时，会看到类似如下的输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
👤 用户指令: 请帮我获取关于 AI 的英文文章摘要，并把它翻译成中文。

> Entering new PlanAndExecute chain...
> Steps:

1. 使用 get_article_summary 工具获取关于 AI 的英文文章摘要。
2. 将上一步获取到的英文摘要，使用 translate_text 工具翻译成中文。
3. 输出最终翻译结果。

> Executing step 1: 使用 get_article_summary 工具获取关于 AI 的英文文章摘要。
Action: get_article_summary
Action Input: "AI"
Observation: "Artificial Intelligence is rapidly transforming industries..."

> Executing step 2: 将上一步获取到的英文摘要，使用 translate_text 工具翻译成中文。
Action: translate_text
Action Input: "Artificial Intelligence is rapidly transforming industries..."
Observation: "人工智能正在通过自动化复杂任务和提供深度的数据洞察，迅速改变各个行业。"

> Executing step 3: 输出最终翻译结果。

🤖 最终结果: 人工智能正在通过自动化复杂任务和提供深度的数据洞察，迅速改变各个行业。

五、Plan-and-Execute vs 传统 Agent

对比维度 传统 ReAct Agent Plan-and-Execute
思考方式 边想边做，逐步推理 先整体规划，再执行
多步依赖处理 容易出错，可能遗漏步骤 天然支持，步骤有序
可解释性 黑盒，难以追踪 白盒，步骤清晰可见
执行效率 每次决策都要调用 LLM 规划一次，批量执行
适用场景 简单对话式任务 复杂的多步任务

选择建议：

  • 简单问答、单步工具调用 → 传统 Agent
  • 数据分析流水线、自动化报告生成 → Plan-and-Execute

六、进阶改进：让架构更强大

6.1 添加重规划（Re-planning）能力

当某一步执行失败时，可以让 Planner 重新规划：

1
2
3
4
5
6
7
8
from langchain_experimental.plan_and_execute import PlanAndExecute

agent = PlanAndExecute(
    planner=planner,
    executor=executor,
    re_plan=True,  # 开启重规划
    verbose=True
)

6.2 添加更多工具

1
2
3
4
5
6
7
8
9
10
11
12
13
@tool
def search_web(query: str) -> str:
    """搜索网络信息"""
    # 调用搜索 API
    pass

@tool
def send_email(recipient: str, content: str) -> str:
    """发送邮件"""
    # 发送邮件逻辑
    pass

tools = [get_article_summary, translate_text, search_web, send_email]

6.3 自定义 Planner 的提示词

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from langchain.prompts import PromptTemplate

planner_prompt = PromptTemplate.from_template("""
你是一个任务规划专家。请将以下用户需求拆解成可执行的步骤列表。

用户需求：{input}

拆解规则：
1. 每个步骤必须使用可用的工具完成
2. 步骤之间要标注依赖关系
3. 输出格式：Step 1: ...; Step 2: ...

可用工具：{tools}

请开始规划：
""")

七、常见问题与解决方案

Q1: Planner 拆解出的步骤顺序不对怎么办？

  • 在工具的 docstring 中明确说明前置条件
  • 使用更强大的模型（如 qwen-max）

Q2: Executor 执行时参数传递失败？

  • 检查工具函数的参数名是否清晰
  • 在 docstring 中给出参数示例

Q3: 如何保存执行历史以便调试？

1
2
3
4
5
6
7
8
agent = PlanAndExecute(
    planner=planner,
    executor=executor,
    return_intermediate_steps=True,  # 返回中间步骤
    verbose=True
)
result = agent.invoke({"input": task})
print(result["intermediate_steps"])  # 查看执行历史

八、总结

Plan-and-Execute 架构通过分离规划与执行，赋予了 AI 智能体“三思而后行”的能力。这种架构特别适合：

  • 需要多步推理的复杂任务
  • 步骤之间有明确依赖关系的场景
  • 对过程可追溯性有要求的企业应用

核心要点回顾：

  • Planner 负责“想”：拆解任务成步骤列表
  • Executor 负责“做”：调用工具执行每一步
  • 分离带来的是更强的逻辑性和可解释性

思考题

如果用户的需求变成：

“帮我找一篇关于区块链的文章，翻译成中文，然后发送到 my@email.com”

你会如何扩展这个 Agent？欢迎在评论区分享你的设计思路！

相关文章

欢迎关注我的其它发布渠道