五种Agent架构：ReAct、CodeAct等实战解析

以下是五种主流 AI Agent 设计模式的详细解析与代码案例。

1. ReAct (Reasoning + Acting)

核心思想 ：将推理（Reason）与行动（Act）交替进行，形成"思考-行动-观察"的循环，直至任务完成 。

适用场景：需要多步骤工具调用、且过程需可解释的任务，如复杂问答、数据分析。

代码案例 (Python + LangChain)：

from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI
from langchain.chains import LLMMathChain

# 1. 定义工具
llm_math = LLMMathChain(llm=OpenAI(temperature=0))
tools = [
    Tool(
        name="Calculator",
        func=llm_math.run,
        description="用于数学计算"
    ),
    Tool(
        name="Search",
        func=lambda q: "检索结果: " + q,  # 模拟搜索
        description="用于信息检索"
    )
]

# 2. 初始化ReAct Agent
agent = initialize_agent(
    tools,
    OpenAI(temperature=0),
    agent="react-docstore",  # ReAct代理类型 verbose=True
)

# 3. 执行任务
response = agent.run("计算圆的面积，已知半径为5，然后搜索'圆周率的历史'")
print(response)

执行流程：

1. Agent 接收问题："计算圆的面积..."
2. 推理 ：决定先调用 Calculator 工具计算面积（π * 5²）
3. 行动 ：执行计算，得到结果 78.54
4. 观察：确认计算完成
5. 推理：决定调用 Search 工具检索"圆周率的历史"
6. 行动：执行检索，返回结果
7. 循环结束，整合答案关键点：需设置最大循环次数防止无限循环 。

---

2. CodeAct (Code as Action)

核心思想 ：Agent 将任务转化为可执行代码（如 Python），在沙箱中运行并返回结果 。

适用场景：数据计算、文件处理、自动化脚本生成等需精确执行的任务。

代码案例 (Python + LangChain Experimental)：

from langchain_experimental.agents.agent_toolkits import create_python_agent
from langchain_experimental.tools import PythonREPLToolfrom langchain.llms import OpenAI

# 1. 创建Python Agent（本质是CodeAct模式）
agent = create_python_agent(
    llm=OpenAI(temperature=0, max_tokens=2000),
    tool=PythonREPLTool(),  # Python代码执行工具 verbose=True
)

# 2. 执行代码生成任务
task = """
请分析以下数据：
1. 计算列表 [15, 30, 45, 60, 75] 的平均值和标准差。
2. 将结果保存到文件 result.txt 中。
"""
response = agent.run(task)
print(response)

生成的典型代码：

import numpy as np
import json

data = [15, 30, 45, 60, 75]
mean = np.mean(data)
std = np.std(data)

result = {"mean": mean, "std": std}
with open("result.txt", "w") as f:
    json.dump(result, f)

print(f"平均值: {mean}, 标准差: {std}")

安全要求：必须在 Docker 等隔离沙箱中运行，防止恶意代码 。

---

3. Agentic RAG (Active Retrieval Augmented Generation)

核心思想 ：在传统 RAG 基础上，Agent 主动决定检索时机、策略及结果验证，形成检索-生成闭环 。

适用场景：知识库问答、动态信息获取等需高准确性的场景。

代码案例 (Python + LangChain + 向量数据库)：

from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
from langchain.agents import Tool, AgentExecutor
from langchain.agents import initialize_agent

# 1. 准备知识库documents = ["LangChain是LLM应用开发框架", "ReAct结合推理与工具调用"]
vectorstore = Chroma.from_texts(documents, OpenAIEmbeddings())
retriever = vectorstore.as_retriever()

# 2. 创建主动检索工具
qa_chain = RetrievalQA.from_chain_type(
    llm=OpenAI(),
    retriever=retriever,
    chain_type="stuff"
)

def active_retriever(query):
    """Agentic RAG核心：主动判断是否需要检索及验证结果"""
    # 步骤1: 判断查询是否需要检索    if "不知道" in query or "最新" in query:
        return "需要检索外部知识"
 # 步骤2: 执行检索 result = qa_chain.run(query)
    
    # 步骤3: 验证结果可信度（简化的置信度检查）
    if len(result) < 10:
        return "检索结果不充分，需要进一步查询"
    return result

# 3. 集成到Agent
tools = [Tool(name="知识库检索", func=active_retriever, description="用于检索最新或不确定的知识")]
agent = initialize_agent(tools, OpenAI(temperature=0),                        agent="react-docstore", verbose=True)

# 4. 执行主动检索任务
response = agent.run("LangChain是什么？如果不知道ReAct，请检索相关信息")
print(response)

与传统RAG的区别：

维度	传统 RAG	Agentic RAG
检索时机	固定流程	Agent 动态决定
检索策略	静态相似度搜索	可调整查询、多路召回
结果处理	直接拼接给 LLM	验证、重排、去重
闭环反馈	无	根据生成质量触发二次检索

---

4. Self-Reflection (自我反思)

核心思想 ：Agent 生成答案后，启动反思步骤检查错误、矛盾或不完整处，并迭代修正 。

适用场景：代码生成、报告撰写等对准确性要求极高的任务。

代码案例 (Python + 自定义反思链)：

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

class SelfReflectionAgent:
    def __init__(self):
        self.llm = OpenAI(temperature=0.7)
        self.max_iterations = 3
        
    def reflect(self, question, current_answer):
        """反思当前答案的潜在问题"""
        reflection_prompt = PromptTemplate(
            input_variables=["question", "answer"],
            template="""
            请对以下答案进行批判性反思：
            问题：{question}
            当前答案：{answer}
请列出：
            1. 答案中的事实错误2. 逻辑矛盾3. 缺失的关键信息
            4. 改进建议反思结果：
            """
        )
        chain = LLMChain(llm=self.llm, prompt=reflection_prompt)
        return chain.run(question=question, answer=current_answer)
    
    def improve(self, question, answer, reflection):
        """基于反思改进答案"""
        improve_prompt = PromptTemplate(
            input_variables=["question", "answer", "reflection"],
            template="""
            根据反思改进答案：
            问题：{question}
            原答案：{answer}
            反思：{reflection}
            
            改进后的答案：
            """
        )
        chain = LLMChain(llm=self.llm, prompt=improve_prompt)
        return chain.run(question=question, answer=answer, reflection=reflection)
    
    def run(self, question):
        """执行反思迭代"""
        answer = self.llm(question)  # 初始答案
        print(f"初始答案: {answer}")
 for i in range(self.max_iterations):
            reflection = self.reflect(question, answer)
            print(f"
第{i+1}次反思: {reflection}")
            
            new_answer = self.improve(question, answer, reflection)
            if new_answer == answer:  # 答案不再变化
                break answer = new_answer print(f"改进后答案: {answer}")
 return answer

# 使用示例
agent = SelfReflectionAgent()
final_answer = agent.run("解释量子计算的基本原理")
print(f"
最终答案: {final_answer}")

反思内容示例：

• 事实检查："这个公式是否正确？"
• 逻辑验证："推理步骤是否连贯？"
• 完整性评估："是否遗漏了重要前提？"
• 表达优化："表述是否清晰易懂？"

---

5. Multi-Agent Planner (多智能体规划器)

核心思想 ：多个专用 Agent 协作，由 Planner 分解任务，Executor 执行，Reviewer 审核 。

适用场景：复杂项目开发、跨领域问题求解、大规模系统运维。

代码案例 (Python + CrewAI 框架)：

from crewai import Agent, Task, Crew, Process
from langchain.llms import OpenAI

# 1. 定义角色Agent
planner = Agent(
    role='项目规划师',
    goal='将复杂任务分解为可执行的子任务',
    backstory='擅长任务分解和资源分配',
    llm=OpenAI(temperature=0.3),
    verbose=True
)

researcher = Agent(
    role='技术研究员',
    goal='收集和验证技术信息',
    backstory='专注技术调研和数据分析',
    llm=OpenAI(temperature=0.5),
    verbose=True
)

coder = Agent(
    role='高级工程师',
    goal='编写高质量代码',
    backstory='拥有10年全栈开发经验',
    llm=OpenAI(temperature=0.2),
    verbose=True
)

reviewer = Agent(
    role='代码审查员',
    goal='确保代码质量和安全性',
    backstory='严谨的代码审查专家',
    llm=OpenAI(temperature=0.1),
    verbose=True
)

# 2. 创建任务链
plan_task = Task(
    description='规划一个Web爬虫项目，用于监测商品价格',
    agent=planner,
    expected_output='详细的项目计划书，包含模块划分和技术选型'
)

research_task = Task(
    description='调研最适合的Python爬虫框架和反爬策略',
    agent=researcher,
    expected_output='技术调研报告，包含框架对比和推荐方案'
)

code_task = Task(
    description='根据规划和研究结果，实现核心爬虫模块',
    agent=coder,
    expected_output='可运行的Python代码，包含错误处理和日志'
)

review_task = Task(
    description='审查代码的质量、安全性和可维护性',
    agent=reviewer,
    expected_output='代码审查报告，包含修改建议'
)

# 3. 组建多智能体团队
crew = Crew(
    agents=[planner, researcher, coder, reviewer],
    tasks=[plan_task, research_task, code_task, review_task],
    process=Process.sequential,  # 顺序执行
    verbose=2
)

# 4. 执行协作任务
result = crew.kickoff()
print("多智能体协作结果:")
print(result)

协作流程：

1. Planner 接收任务："开发价格监测爬虫"
2. Planner 输出计划：[数据采集模块, 解析模块, 存储模块]
3. Researcher 调研：推荐 Scrapy + Selenium 方案
4. Coder 实现核心代码
5. Reviewer 检查代码漏洞
6. 循环迭代直至任务完成

---

模式对比与选型指南

模式	核心优势	典型场景	技术复杂度	计算成本
ReAct	过程透明、灵活可解释	客服机器人、分步指导	中	中
CodeAct	结果精确、可复现	数据分析、自动化脚本	高（需沙箱）	低
Agentic RAG	信息准确、动态适应	知识库问答、研究助手	高	高
Self-Reflection	输出可靠、减少幻觉	代码生成、报告撰写	中	高（多轮）
Multi-Agent	处理复杂任务、扩展性强	项目开发、系统运维	很高	很高

选型建议：

1. 简单工具调用 → ReAct
2. 精确计算/自动化 → CodeAct（配安全沙箱）
3. 知识密集型任务 → Agentic RAG
4. 高准确性要求 → Self-Reflection 或 ReAct+Reflection 组合
5. 超复杂系统工程 → Multi-Agent Planner

组合模式示例：

# ReAct + Self-Reflection 组合def react_with_reflection(question):
    # 第一步：ReAct执行
    react_result = react_agent.run(question)
    
    # 第二步：Self-Reflection优化 reflection = reflection_agent.reflect(question, react_result)
    final_result = reflection_agent.improve(question, react_result, reflection)
 return final_result

关键工程考量：

1. 成本控制：Self-Reflection 和 Multi-Agent 会显著增加 Token 消耗
2. 延迟优化：Agentic RAG 需缓存检索结果，ReAct 需限制循环次数
3. 错误处理：CodeAct 需完善的沙箱隔离和超时机制
4. 评估体系：建立基于任务成功率的评估指标，而非单纯响应速度

---

参考来源

• Agent 设计模式：从 ReAct、CodeAct 到 Agentic Rag 与多智能体
• ReAct到Multi-Agent Planner：五大Agent设计范式
• Agent开发核心：ReAct、CodeAct、Agentic RAG全解析
• 5 种 Agent 设计模式全景解析：从 ReAct 到多智能体协作
• Agent设计模式对比：ReAct vs Planuing哪个更强