五种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)

执行流程：

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的区别：

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)

协作流程：

模式对比与选型指南

选型建议：

组合模式示例：

# 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

关键工程考量：

参考来源

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