AI Agent 架构设计：从 ReAct 到多智能体

对于有经验的 Java/后端工程师而言，构建一个服务意味着定义清晰的 API、设计可扩展的微服务架构以及管理有状态或无状态的数据流。当我们进入 AI Agent 的世界时，这些工程思维依然至关重要，但核心组件变成了推理引擎、工具执行器和记忆系统。本文将带你深入 AI Agent 的架构核心，从单智能体的基础范式 ReAct 出发，一直探讨到复杂多智能体系统的设计与生产级考量。我们将不止于概念，而是通过代码、架构图和对比分析，为你构建一个从理论到实践的完整知识框架。

引言：为什么需要 Agent 架构？

传统的 AI 模型（如分类器、生成模型）是“被动”的：给定输入，产生输出。然而，现实世界的问题往往是开放性的、多步骤的、需要与外部环境交互的。例如，“分析我上季度的业务数据，生成一份报告，并通过邮件发送给团队”——这无法通过单一 API 调用完成。

AI Agent 应运而生。它是一个能够感知环境、进行推理、规划并执行动作以实现目标的自治系统。其核心价值在于将大语言模型（LLM）强大的推理和生成能力，与确定性工具（如代码解释器、数据库、API）的执行能力结合起来，形成闭环。从单智能体到多智能体，架构的演进本质上是为了应对日益复杂的任务需求，其设计思想与我们熟悉的分布式系统、面向服务架构（SOA）有着深刻的共鸣。

核心概念：ReAct 范式与工具调用

1. ReAct：推理与行动的循环

ReAct（Reasoning + Acting）是 Yao 等人于 2022 年提出的范式，它为大语言模型赋予了类似人类“思考-行动”的循环能力。其核心循环如下：

1. 思考（Think）：基于当前任务和观察，推理下一步应该做什么。这通常以自然语言链式思考（Chain-of-Thought）的形式呈现。
2. 行动（Act）：根据思考的结果，调用一个具体的工具（Action），或直接给出最终答案（Finish）。
3. 观察（Observe）：获取工具执行的结果（Observation），作为下一轮循环的输入。

这个循环将不确定的 LLM 推理与确定的工具执行清晰地分离开。LLM 负责高层的规划和决策（“做什么”），而工具负责底层的、精确的执行（“怎么做”）。这种解耦极大地提升了系统的可靠性和可解释性。

下图展示了一个经典的单 Agent ReAct 系统架构：

graph TD
    subgraph “单Agent ReAct系统”
        A[“用户输入/任务目标”] --> B[“Agent 核心 (LLM)”]
        B --> C{“推理步骤”}
        C -->|“思考(Thought)”| D[“规划器/推理模块”]
        D -->|“决定行动(Action)”| E[“工具调用模块”]
        E -->|“调用”| F[“工具集 Tool 1..N”]
        F -->|“返回结果(Observation)”| G[“观察处理器”]
        G --> B
        C -->|“最终答案”| H[“输出最终结果”]
    end

    style B fill:#e1f5fe
    style F fill:#f1f8e9

2. 工具调用：Agent 的“手脚”

工具调用（Function Calling/Tool Use）是 Agent 与外部世界交互的桥梁。从工程角度看，一个工具就是一个具有明确定义输入输出、可被可靠执行的函数或 API。

生产级考量：

• 工具描述：必须为 LLM 提供清晰、结构化、包含示例的工具描述（名称、功能、参数 schema）。这类似于为微服务编写 API 文档。
• 错误处理：工具执行可能失败（网络超时、参数错误）。Agent 必须能处理这些错误，并可能重试或调整策略。
• 安全与权限：工具可能具有破坏性（如删除文件、发送邮件）。必须设计严格的权限控制层，确保 Agent 只能在授权范围内行动。

实战代码：构建一个基础的单 Agent 系统

让我们使用 LangChain 框架（AI 应用开发的“Spring Framework”）来构建一个简单的数据分析 Agent。它能够理解用户关于 CSV 文件的问题，并通过 Python 代码执行分析。

import pandas as pd
import langchain
from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import Tool
from langchain_community.tools import PythonREPLTool
from langchain_openai import ChatOpenAI
from langchain import hub

# 1. 定义专用工具：加载 CSV 文件
def load_csv_tool(file_path: str) -> str:
    """加载指定路径的CSV文件并返回其基本信息。"""
    try:
        df = pd.read_csv(file_path)
        return f"文件加载成功。形状: {df.shape}， 列名: {list(df.columns)}， 前几行数据:\n{df.head().to_string()}"
    except Exception as e:
        return f"加载文件失败: {str(e)}"

# 2. 将函数封装为 LangChain Tool 对象
tools = [
    Tool(
        name="LoadCSV",
        func=load_csv_tool,
        description="用于加载和分析CSV文件。输入应为文件的绝对路径。"
    ),
    PythonREPLTool() # 内置的 Python 代码执行工具
]

# 3. 初始化 LLM 和 ReAct 提示词模板
llm = ChatOpenAI(model="gpt-4-turbo-preview", temperature=0)
prompt = hub.pull("hwchase17/react") # 获取标准的 ReAct 提示模板

# 4. 创建 Agent 和执行器
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# 5. 运行 Agent
if __name__ == "__main__":
    # 假设我们有一个销售数据文件
    file_path = "/path/to/your/sales_data.csv"
    
    result = agent_executor.invoke({
        "input": f"请先加载并查看文件 {file_path} 的内容，然后计算总销售额和平均订单金额。"
    })
    print("\n=== 最终输出 ===")
    print(result["output"])

代码解析：

1. 我们定义了两个工具：一个自定义的 LoadCSV 工具和一个通用的 PythonREPLTool。
2. create_react_agent 将 LLM、工具和 ReAct 提示模板绑定在一起，形成了一个遵循 ReAct 循环的 Agent 逻辑。
3. AgentExecutor 是运行时引擎，负责管理思考-行动-观察的循环，直到 Agent 决定结束或达到最大迭代次数。
4. 当用户提问时，LLM 会生成类似 Thought: 我需要先查看文件内容。Action: LoadCSV[/path/to/your/sales_data.csv] 的文本。执行器解析出动作并调用对应工具，将结果作为观察送回 LLM，进行下一轮思考。

对比表格：单 Agent vs 多 Agent 架构

当任务复杂度升级时，单 Agent 可能力不从心。多 Agent 系统通过分工协作来解决这一问题。下表从多个维度对比了两种架构：

架构图：一个基于“管理者-工作者”模型的多 Agent 系统

graph TB
    User[“用户/任务请求”] --> Manager[“管理者 Agent”]
    
    subgraph “工作者 Agent 池”
        direction LR
        Specialist_1[“领域专家 A”]
        Specialist_2[“领域专家 B”]
        Specialist_3[“代码专家”]
        Specialist_4[“审核员”]
    end
    
    Manager -->|“分解任务 & 分配”| Specialist_1
    Manager -->|“分解任务 & 分配”| Specialist_2
    Specialist_1 -->|“提交结果 & 协作请求”| Coordinator[“协调层/共享工作区”]
    Specialist_2 -->|“提交结果 & 协作请求”| Coordinator
    Coordinator -->|“通知待审核”| Specialist_4
    Specialist_4 -->|“反馈修改意见”| Coordinator
    Coordinator -->|“汇总信息 & 触发下一步”| Manager
    Manager -->|“整合最终结果”| User
    
    style Manager fill:#ffecb3
    style Coordinator fill:#d1c4e9

在这个架构中，管理者 Agent 负责任务分解、调度和结果整合；各个工作者 Agent 是领域专家；协调层（可以是消息队列或共享状态）处理通信和中间状态存储。这类似于微服务架构中的 API 网关和服务网格。

最佳实践：Agent 的记忆系统设计

没有记忆的 Agent 就像无状态的 HTTP 服务，每次交互都是全新的。生产级 Agent 必须拥有记忆，这分为三个层次，与计算机体系结构中的存储层次有异曲同工之妙：

1. 工作记忆（Working Memory）：
   • 功能：存储当前任务循环的完整上下文，包括所有的思考、行动、观察序列。这是 LLM 每次推理的直接输入。
   • 实现：通常由 Agent 框架（如 AgentExecutor）自动管理，保存在内存中，并受模型上下文窗口长度限制。
   • 生产考量：需要上下文压缩策略。当对话或任务历史很长时，不能简单截断，而应进行智能摘要（Summary），将冗长的过去交互提炼成简洁的要点保留在工作记忆中。
2. 短期记忆（Short-term Memory）：
   • 功能：维持跨越多个独立任务或会话轮次的状态。例如，记住用户在本对话中提到的偏好或已执行的操作。
   • 实现：通常使用向量数据库（如 Redis, Chroma, Pinecone）存储对话的嵌入向量，支持基于语义相似度的快速检索。
   • 生产考量：实现检索增强生成（RAG）。当用户提出新问题时，先从短期记忆中检索最相关的历史片段，注入工作记忆，使 Agent 能进行连贯的、个性化的对话。
3. 长期记忆（Long-term Memory）：
   • 功能：存储 Agent 的“永久性”知识、经验教训、用户档案、领域知识库等。这是 Agent 进行持续学习和个性化的基础。
   • 实现：结合关系型数据库（存储结构化档案）和向量数据库（存储非结构化经验知识）。可能需要定期的知识融合与去重。
   • 生产考量：设计记忆写入策略。并非所有交互都应进入长期记忆，需要设定规则（如重要决策、验证过的知识、用户明确指示）来触发记忆的持久化。

示例：为 Agent 添加短期记忆（对话历史）

from langchain.memory import ConversationBufferMemory
from langchain.agents import AgentExecutor, create_react_agent

# 创建带有记忆的 Agent
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

# 需要调整提示词模板，使其包含 `chat_history` 变量
prompt_with_memory = hub.pull("hwchase17/react-chat")
agent_with_memory = create_react_agent(llm, tools, prompt_with_memory)
agent_executor_with_memory = AgentExecutor(
    agent=agent_with_memory,
    tools=tools,
    memory=memory,
    verbose=True
)

# 现在 Agent 可以记住之前的对话
agent_executor_with_memory.invoke({"input": “上个季度销售额最高的产品是什么？”})
# ... 一段时间后
agent_executor_with_memory.invoke({"input": “与它相比，这个季度的数据有什么变化？”}) # Agent 能理解“它”指代什么

总结

从 ReAct 到多智能体，AI Agent 的架构设计是一场从“单体应用”向“分布式系统”的演进。对于后端工程师而言，理解这一演进背后的逻辑——解耦、分工、状态管理、通信协议——能够让我们更快地掌握 AI Agent 的核心。

• 起点是 ReAct：它将不确定的推理与确定的执行分离，是构建任何可靠 Agent 的基石。
• 进化到多 Agent：当任务复杂到超越单个“大脑”的规划能力时，引入角色分工和协作机制是必然选择，这带来了鲁棒性、专业性和可扩展性，但也引入了协调复杂度。
• 基石是记忆系统：无论是单 Agent 还是多 Agent，分层的记忆系统是实现连贯性、个性化和持续学习的关键，其设计需要综合考虑上下文管理、检索效率和存储成本。

展望未来，Agent 架构将继续融合更多软件工程的最佳实践，如流式处理、容错模式、可观测性等。作为开发者，我们的任务是将 LLM 强大的认知潜能，通过扎实的工程架构，转化为稳定、高效、可信赖的智能系统。

参考资料

1. Yao, S., et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629.
2. Wu, Q., et al. (2023). AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation. arXiv:2308.08155.
3. LangChain Documentation: Agents, Memory.
4. Microsoft Autogen Framework Documentation.
5. “Patterns for Building LLM-Based Systems & Products”. Andrej Karpathy’s Talk.