PAGE 09 · PHASE 4

🧩 Agent 设计模式

四大核心设计模式——ReAct、Plan-and-Execute、Reflection、Multi-Agent，从理论原理到代码实现全面掌握

进阶 核心架构
01

🌐Agent 设计模式总览

什么是 Agent 设计模式？

Agent 设计模式是指导 LLM 智能体如何思考、如何行动、如何改进的架构范式。不同模式适用于不同复杂度的任务：简单问答用 ReAct，复杂规划用 Plan-and-Execute，需要自我纠错用 Reflection，超大任务用 Multi-Agent。

理解这些模式是构建生产级 Agent 系统的基础。Andrew Ng 在 2024 年将这四大模式称为"Agentic Design Patterns"，认为它们是 AI 应用的关键架构选择。

⚡

ReAct

推理 + 行动循环，边想边做，适合工具调用场景

📋

Plan-and-Execute

先规划后执行，适合多步骤复杂任务

🪞

Reflection

自我反思与纠错，提升输出质量

👥

Multi-Agent

多个专家 Agent 协作，分工完成大任务

02

⚡ReAct 模式

⚡

ReAct — Reasoning + Acting

思考-行动-观察循环 | 最经典的 Agent 模式
核心模式

ReAct 由 Shunyu Yao 等人在 2022 年提出（论文："ReAct: Synergizing Reasoning and Acting in Language Models"），核心思想是让 LLM 在 推理（Thought）和行动（Action）之间交替循环。

执行流程

📥 用户问题
💭 Thought：我需要先搜索相关信息
🔧 Action：调用 search("LangChain 最新版本")
👁️ Observation：搜索结果显示 v0.3...
🧠 判断：信息足够了吗？
📤 Final Answer：最终回答

代码实现

from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search import TavilySearchResults

model = ChatOpenAI(model="gpt-4o")
tools = [TavilySearchResults(max_results=3)]

# 一行代码创建 ReAct Agent
agent = create_react_agent(model, tools)

# 执行
result = agent.invoke({
    "messages": [("human", "2026年最流行的AI框架是什么？")]
})

# 流式输出 Thought → Action → Observation 过程
for chunk in agent.stream(
    {"messages": [("human", "比较 LangChain 和 LlamaIndex")]}
):
    print(chunk)
💡
适用场景：需要实时查询外部信息的问答、工具调用任务（搜索、计算、API 调用）。大多数简单 Agent 都可以用 ReAct 模式实现。
03

📋Plan-and-Execute 模式

📋

Plan-and-Execute — 先规划后执行

分离规划与执行 | 适合复杂多步任务
高级模式

来源于 Wang et al. 2023 论文 "Plan-and-Solve Prompting"，核心思想是将任务分为两阶段：Planner 生成分步计划，Executor 逐步执行。计划可以动态调整（re-plan）。

与 ReAct 的关键区别

维度ReActPlan-and-Execute
思考粒度每步即时思考先全局规划
适合任务简单、1-3步复杂、5步以上
执行方式边想边做先定计划再执行
纠错能力下一步纠正Re-plan 调整全局
Token 消耗较低较高（需规划步骤）

代码实现

from langgraph.graph import StateGraph, START, END
from typing import TypedDict, Annotated
import operator

class PlanExecuteState(TypedDict):
    input: str
    plan: list[str]
    current_step: int
    results: Annotated[list, operator.add]
    final_answer: str

# Planner：生成执行计划
async def planner(state: PlanExecuteState):
    plan_prompt = f"""为以下任务制定分步执行计划：
任务：{state['input']}
返回 JSON 格式的步骤列表。"""
    response = await llm.ainvoke(plan_prompt)
    return {"plan": parse_plan(response), "current_step": 0}

# Executor：执行当前步骤
async def executor(state: PlanExecuteState):
    step = state["plan"][state["current_step"]]
    result = await react_agent.ainvoke({"messages": [("human", step)]})
    return {
        "results": [result],
        "current_step": state["current_step"] + 1
    }

# Re-planner：根据执行结果调整计划
async def re_planner(state: PlanExecuteState):
    if state["current_step"] >= len(state["plan"]):
        return {"final_answer": synthesize(state["results"])}
    # 检查是否需要调整计划...
    return {}

# 构建图
graph = StateGraph(PlanExecuteState)
graph.add_node("planner", planner)
graph.add_node("executor", executor)
graph.add_node("re_planner", re_planner)

graph.add_edge(START, "planner")
graph.add_edge("planner", "executor")
graph.add_edge("executor", "re_planner")
graph.add_conditional_edges("re_planner", should_continue)
04

🪞Reflection 反思模式

🪞

Reflection — 自我反思与迭代改进

生成-批评-改进循环 | 显著提升输出质量
高级模式

Reflection 模式的核心是让 Agent 审视自己的输出并迭代改进。论文来源包括 Shinn et al. 2023 "Reflexion: Language Agents with Verbal Reinforcement Learning" 和 Madaan et al. 2023 "Self-Refine"。

三种 Reflection 变体

🔄

Self-Refine

同一个 LLM 先生成、再自我批评、然后改进

👥

Critic Agent

独立的批评者 Agent 审查输出，提出改进建议

🧪

Tool-based Verify

用代码执行、单元测试等工具验证输出正确性

代码实现：Self-Refine

from langgraph.graph import StateGraph, START, END

class ReflectionState(TypedDict):
    task: str
    draft: str
    critique: str
    iteration: int
    final: str

async def generate(state):
    """生成初始草稿"""
    draft = await llm.ainvoke(f"完成任务：{state['task']}")
    return {"draft": draft.content, "iteration": 1}

async def reflect(state):
    """反思并批评"""
    critique = await llm.ainvoke(
        f"""审查以下内容并指出问题：
草稿：{state['draft']}
请列出具体的改进建议。"""
    )
    return {"critique": critique.content}

async def improve(state):
    """基于反思改进"""
    improved = await llm.ainvoke(
        f"""根据批评意见改进：
原稿：{state['draft']}
批评：{state['critique']}
生成改进版本。"""
    )
    return {
        "draft": improved.content,
        "iteration": state["iteration"] + 1
    }

def should_continue(state):
    if state["iteration"] >= 3:  # 最多 3 轮
        return "finalize"
    return "reflect"

graph = StateGraph(ReflectionState)
graph.add_node("generate", generate)
graph.add_node("reflect", reflect)
graph.add_node("improve", improve)
graph.add_node("finalize", lambda s: {"final": s["draft"]})

graph.add_edge(START, "generate")
graph.add_conditional_edges("generate", should_continue)
graph.add_edge("reflect", "improve")
graph.add_conditional_edges("improve", should_continue)
graph.add_edge("finalize", END)
📊
Reflexion 论文实验显示，在 HumanEval 代码生成任务上，加入 Reflection 后准确率从 80% 提升到 91%，在 AlfWorld 任务上从 75% 提升到 97%。
05

👥Multi-Agent 多智能体模式

👥

Multi-Agent — 多 Agent 协作

专业分工 + 协调机制 | 解决超大规模任务
前沿模式

Multi-Agent 模式将一个大任务分配给多个专业化 Agent，每个 Agent 负责特定领域。核心挑战在于通信协议、任务分配和冲突解决。

四种协作架构

📡

Supervisor 模式

一个主管 Agent 负责调度和分配任务给子 Agent

🔄

Round-Robin 模式

Agent 按顺序轮流处理，每个 Agent 改进前一个的输出

💬

Debate 模式

多个 Agent 辩论讨论，在分歧中逼近正确答案

🏗️

Hierarchical 模式

多层级 Agent 树，高层规划、低层执行

LangGraph 实现 Supervisor

from langgraph.graph import StateGraph, START, END
from langgraph.prebuilt import create_react_agent

# 定义专业 Agent
researcher = create_react_agent(llm, [search_tool],
    prompt="你是研究员，负责搜索和收集信息")

writer = create_react_agent(llm, [write_tool],
    prompt="你是写作专家，负责撰写内容")

reviewer = create_react_agent(llm, [],
    prompt="你是审稿人，负责审查和改进文稿")

# Supervisor 决策
async def supervisor(state):
    decision = await llm.ainvoke(
        f"""你是项目主管。根据当前状态决定下一步：
可选 Agent: researcher, writer, reviewer, FINISH
当前进度: {state['progress']}
输出 JSON: {{"next": "agent_name"}}"""
    )
    return {"next": parse_next(decision)}

# 构建 Supervisor 图
graph = StateGraph(TeamState)
graph.add_node("supervisor", supervisor)
graph.add_node("researcher", researcher_node)
graph.add_node("writer", writer_node)
graph.add_node("reviewer", reviewer_node)

graph.add_edge(START, "supervisor")
graph.add_conditional_edges("supervisor", route_to_agent)
06

🔧Tool Use 模式

工具使用的核心机制

Tool Use（Function Calling）是几乎所有 Agent 模式的基础——让 LLM 能够调用外部工具获取信息或执行操作。

  • 工具描述：用自然语言或 JSON Schema 告诉 LLM 每个工具的功能和参数
  • 工具选择：LLM 根据任务需求决定调用哪个工具
  • 参数生成：LLM 生成结构化的工具调用参数
  • 结果处理：将工具返回值注入对话上下文

Tool Use 的演进

阶段方式代表
文本解析LLM 输出特定格式文本，正则解析早期 ReAct
Function Calling模型原生支持结构化工具调用GPT-3.5/4 Function Calling
Tool Calling统一的工具调用协议，支持并行GPT-4o, Claude 3
MCP 协议标准化工具发现和调用协议Anthropic MCP (2024)
07

📊模式对比与选型指南

四大模式全面对比

维度ReActPlan-ExecuteReflectionMulti-Agent
复杂度⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐
适合任务简单查询+工具多步骤规划代码/文档生成大型项目
Token 成本低中中-高高
延迟低中高（多轮迭代）中（可并行）
输出质量一般好优优
可控性有限好好复杂但灵活
典型框架LangGraphLangGraphLangGraphCrewAI, AutoGen

选型决策树

🌳
任务是否需要工具？
→ 否：直接用 Chain（LCEL）
→ 是：步骤数 ≤ 3？
  → 是：ReAct
  → 否：需要高质量输出？
    → 是：Plan-Execute + Reflection
    → 否：需要多领域专业知识？
      → 是：Multi-Agent
      → 否：Plan-and-Execute
08

🚀实战：组合模式构建研究助手

项目目标

构建一个能够接受研究主题、自动搜索资料、撰写报告、自我审查并改进的研究助手，融合 Plan-Execute + Reflection + Multi-Agent 三种模式。

架构设计

📝 输入研究主题
📋 Planner：制定研究计划
🔍 Researcher Agent：搜索资料
✍️ Writer Agent：撰写报告
🪞 Reviewer Agent：审查反馈
通过审查？
📄 输出最终报告
✅
生产建议：在实际项目中，建议从最简单的 ReAct 模式开始，随着需求增长逐步引入 Plan-Execute 和 Reflection。不要一开始就上 Multi-Agent——过早优化是万恶之源。

📚 参考资料与出处

  1. Yao et al. (2022) "ReAct: Synergizing Reasoning and Acting in Language Models" — arXiv:2210.03629
  2. Wang et al. (2023) "Plan-and-Solve Prompting" — arXiv:2305.04091
  3. Shinn et al. (2023) "Reflexion: Language Agents with Verbal Reinforcement Learning" — arXiv:2303.11366
  4. Madaan et al. (2023) "Self-Refine: Iterative Refinement with Self-Feedback" — arXiv:2303.17651
  5. Andrew Ng (2024) "Agentic Design Patterns" — deeplearning.ai
  6. LangGraph Agent Architectures — langchain-ai.github.io/langgraph