AI Agent 原理与实战：从零理解智能体架构

林夕07

338人浏览 · 2026-05-16 09:00:00

林夕07 · 2026-05-16 09:00:00 发布

AI Agent 原理与实战：从零理解智能体架构

作者：林夕07 | 发布于：CSDN

一、引言

2024 年以来，“AI Agent” 一词以前所未有的频率出现在技术社区、产品发布会和学术论文中。从 AutoGPT 的爆火到各大厂纷纷推出 Agent 平台，我们正在见证一个范式转移——AI 正在从"对话"走向"行动"，从"回答问题"走向"解决问题"。

但面对铺天盖地的概念和框架，很多开发者仍然困惑：AI Agent 到底和传统 Chatbot 有什么区别？一个 Agent 是怎么"思考"和"行动"的？我该怎么从零构建一个？

本文将用深入浅出的方式，从原理到架构再到代码实现，带你完整理解 AI Agent 的核心机制。无论你是想为自己的项目接入 Agent 能力，还是想理解这个技术浪潮的本质，这篇文章都能帮到你。

二、什么是 AI Agent？

2.1 一句话定义

AI Agent = LLM + 感知 + 记忆 + 工具 + 规划 + 行动

用一个类比来理解：如果说 ChatGPT 是一个博学的顾问——你问它问题，它给出建议，但仅此而已；那么 AI Agent 就是一个全能的管家——它不仅能提建议，还能理解你的意图，拆解任务，调用各种工具（查日历、发邮件、写代码），并根据反馈不断调整策略，直到把事情办成。

2.2 Agent vs Chatbot：关键区别

维度	传统 Chatbot	AI Agent
交互模式	一问一答，被动响应	主动规划，自主执行
能力边界	仅限文本生成	可调用外部工具和 API
记忆	通常无跨轮记忆	具备短期/长期记忆机制
任务处理	单轮对话解决	多步分解，循环执行
自主性	低，完全依赖用户指令	高，能自主决策和反思
典型代表	早期 ChatGPT	AutoGPT、Manus、Devin

简单来说，Chatbot 是"你问我答"，Agent 是"你说目标，我来干活"。

三、核心组件解析

一个完整的 AI Agent 系统由以下核心组件构成：

3.1 感知（Perception）

感知是 Agent 与外部世界交互的入口。它负责收集和理解来自环境的信息，包括：

用户输入：自然语言指令、语音、图片等
环境反馈：工具调用的返回结果、API 响应、错误信息
系统状态：当前任务进度、已执行步骤、可用资源

类比来说，感知就像人类的"五感"——它不负责决策，但它为决策提供原材料。

3.2 规划（Planning）

规划是 Agent 的"战略层"，负责将复杂任务拆解为可执行的步骤序列。常见的规划策略包括：

任务分解（Task Decomposition）：

ReAct（Reason + Act）：交替进行推理和行动，每一步都先思考再执行
Plan-and-Execute：先制定完整计划，再逐步执行
Tree of Thoughts：探索多条推理路径，选择最优方案

3.3 行动（Action）

行动是 Agent 将计划付诸实践的环节。最关键的能力是 工具调用（Tool Use / Function Calling）——Agent 不只是生成文本，而是实际去"做事"：

🔍 搜索：查询数据库、搜索引擎、知识库
📝 读写：创建文件、编辑文档、操作代码
🌐 API 调用：发送邮件、操作日历、调用第三方服务
💻 代码执行：编写并运行 Python/JS 代码
🖱️ UI 操作：点击按钮、填写表单（Browser Use）

3.4 反思（Reflection）

反思是 Agent 区别于简单自动化流水线的关键能力。在执行完一个或多个步骤后，Agent 会自我评估：

当前结果是否符合预期？
是否需要调整策略？
是否需要回退并尝试其他方法？

这形成了一个闭环反馈系统，让 Agent 具备了类似人类的"纠错能力"。

3.5 核心循环：Agent Loop

把以上组件串联起来，Agent 的运行本质上是一个循环：

感知 → 规划 → 行动 → 反思 → 感知 → … → 完成

这个循环持续运转，直到任务完成或达到最大步数限制。理解了这个循环，你就理解了 Agent 的本质。

四、架构模式详解

4.1 ReAct 架构：推理与行动交织

ReAct（Reasoning + Acting）是当前最流行的 Agent 架构模式。其核心思想是：每一步都先推理（Thought），再行动（Action），然后观察结果（Observation）。

ReAct 的优势在于其透明性——每一步推理过程都是可追溯的，这让调试和优化变得容易。

4.2 Plan-and-Execute 架构：先谋后动

适合需要全局规划的复杂任务。先由规划器制定完整方案，再由执行器逐步执行。

4.3 多 Agent 协作架构

当任务足够复杂时，单一 Agent 往往力不从心。此时可以引入多 Agent 协作，让不同专长的 Agent 各司其职：

典型的协作模式包括：

主从模式：一个 Manager 负责调度，多个 Worker 负责执行
对等模式：Agent 之间平等协商，通过消息传递协作
流水线模式：按顺序依次处理，前一个的输出是后一个的输入

五、记忆机制：让 Agent 拥有"大脑"

记忆是 Agent 实现持续交互和学习的基础。类比人类记忆系统：

记忆类型	对应概念	作用	实现方式
感知记忆	当前输入	处理即时信息	原始输入文本
短期记忆	对话上下文	维持当前会话的连贯性	上下文窗口 / 滑动窗口
长期记忆	知识与经验	跨会话的知识积累	向量数据库 / 外部存储

长期记忆的典型实现：将历史交互和知识文档通过 Embedding 模型转化为向量，存入向量数据库（如 Chroma、Pinecone），在需要时通过语义检索召回相关内容，注入到 LLM 的上下文中。

六、工具调用：Function Calling 深度解析

工具调用是 Agent 从"只能说"进化为"能做事"的关键。其本质是 LLM 结构化地输出工具调用指令，由外部系统执行后将结果回传。

工作流程

定义工具：用 JSON Schema 描述工具的名称、功能和参数
LLM 决策：模型根据用户请求决定是否调用工具、调用哪个工具、传什么参数
执行工具：外部系统解析调用指令并执行
结果回传：执行结果返回给 LLM，由模型生成最终回复

工具定义示例（OpenAI 格式）

{
  "type": "function",
  "function": {
    "name": "get_weather",
    "description": "获取指定城市的当前天气信息",
    "parameters": {
      "type": "object",
      "properties": {
        "city": {
          "type": "string",
          "description": "城市名称，如：北京"
        }
      },
      "required": ["city"]
    }
  }
}

七、实战：用 Python 从零实现一个 ReAct Agent

理论讲够了，来看代码。以下是一个极简但完整的 ReAct Agent 实现，不依赖任何 Agent 框架，只用 OpenAI API：

"""
一个极简的 ReAct Agent 实现
仅依赖 openai 库，清晰展示 Agent 的核心循环
"""

import json
from openai import OpenAI

client = OpenAI()

# ========== 1. 定义工具集 ==========
tools = [
    {
        "type": "function",
        "function": {
            "name": "search",
            "description": "在知识库中搜索信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "搜索关键词"
                    }
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "执行数学计算",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "数学表达式，如 '2 + 3 * 4'"
                    }
                },
                "required": ["expression"]
            }
        }
    }
]

# ========== 2. 工具执行器 ==========
def execute_tool(name: str, arguments: dict) -> str:
    """根据工具名称执行对应逻辑"""

    if name == "search":
        # 模拟搜索（实际项目中接入真实搜索引擎）
        mock_db = {
            "python": "Python 是一种高级编程语言，由 Guido van Rossum 于 1991 年创建。",
            "ai agent": "AI Agent 是能自主感知环境、做出决策并执行行动的智能系统。",
        }
        query = arguments.get("query", "")
        return mock_db.get(query, f"未找到与 '{query}' 相关的结果")

    elif name == "calculate":
        try:
            # ⚠️ 注意：eval() 存在安全风险，生产环境请使用安全的表达式解析库
            # 推荐：simpleeval、asteval、或自定义解析器
            result = eval(arguments.get("expression", "0"))
            return f"计算结果：{result}"
        except Exception as e:
            return f"计算错误：{e}"

    return f"未知工具：{name}"

# ========== 3. ReAct 核心循环 ==========
def run_react_agent(user_query: str, max_steps: int = 5):
    """ReAct Agent 主循环"""

    system_prompt = """你是一个 ReAct Agent。请按以下格式思考和行动：

Thought: 分析当前情况，决定下一步该做什么
Action: 选择要调用的工具
Observation: 工具返回的结果

重复以上步骤直到能给出最终答案，然后输出：
Answer: 最终回答"""

    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": user_query}
    ]

    print(f"🤖 用户提问：{user_query}")
    print("=" * 50)

    for step in range(max_steps):
        print(f"\n--- 第 {step + 1} 轮 ---")

        # 调用 LLM
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )

        msg = response.choices[0].message

        # 情况1：模型决定调用工具
        if msg.tool_calls:
            messages.append(msg)

            for tool_call in msg.tool_calls:
                func_name = tool_call.function.name
                func_args = json.loads(tool_call.function.arguments)

                print(f"🔧 调用工具：{func_name}({func_args})")

                # 执行工具
                result = execute_tool(func_name, func_args)
                print(f"👁️ 观察结果：{result}")

                # 将结果回传给 LLM
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": result
                })

        # 情况2：模型直接给出最终回答
        else:
            print(f"\n✅ 最终回答：{msg.content}")
            return msg.content

    print("⚠️ 达到最大步数限制")
    return None

# ========== 4. 运行示例 ==========
if __name__ == "__main__":
    run_react_agent("什么是 AI Agent？帮我算一下如果每天学 2 小时，一个月能学多少小时？")

运行输出示例：

🤖 用户提问：什么是 AI Agent？帮我算一下如果每天学 2 小时，一个月能学多少小时？
==================================================

--- 第 1 轮 ---
🔧 调用工具：search({"query": "ai agent"})
👁️ 观察结果：AI Agent 是能自主感知环境、做出决策并执行行动的智能系统。

--- 第 2 轮 ---
🔧 调用工具：calculate({"expression": "2 * 30"})
👁️ 观察结果：计算结果：60

--- 第 3 轮 ---
✅ 最终回答：AI Agent 是能自主感知环境、做出决策并执行行动的智能系统。
如果你每天学习 2 小时，一个月（30天）可以学习 60 小时！

关键点：整个过程只有 3 个核心步骤——定义工具、执行器、ReAct 循环。Agent 自主决定了先搜索再计算，以及用什么参数调用工具。这就是 Agent 的"智能"所在。

八、主流 Agent 框架对比

如果你不想从零造轮子，以下是目前最主流的三个 Agent 框架：

框架概览

特性	LangChain	AutoGen	CrewAI
定位	通用 LLM 应用框架	多 Agent 对话框架	多 Agent 协作框架
核心理念	Chain（链式调用）	Conversation（对话驱动）	Crew（角色协作）
学习曲线	中等偏高	中等	低
多 Agent 支持	✅ LangGraph	✅ 原生支持	✅ 原生支持
工具生态	⭐⭐⭐⭐⭐ 最丰富	⭐⭐⭐	⭐⭐⭐
适合场景	复杂工作流编排	多角色对话模拟	角色分工明确的团队任务
社区活跃度	极高	高	中高

各框架的 Agent 定义对比

LangChain（Agent + Tools）：

from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_openai import ChatOpenAI
from langchain.tools import tool
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

@tool
def search(query: str) -> str:
    """搜索信息"""
    return f"搜索结果：{query}"

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个有用的 AI 助手。"),
    ("user", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

llm = ChatOpenAI(model="gpt-4o")
agent = create_openai_tools_agent(llm, [search], prompt)
executor = AgentExecutor(agent=agent, tools=[search])
executor.invoke({"input": "什么是 AI Agent？"})

CrewAI（角色驱动）：

from crewai import Agent, Task, Crew
from crewai_tools import SerperDevTool  # 搜索工具

search_tool = SerperDevTool()

researcher = Agent(
    role="研究员",
    goal="深入调研 AI Agent 技术趋势",
    backstory="你是一位资深的 AI 研究员",
    tools=[search_tool]
)

writer = Agent(
    role="技术作家",
    goal="将技术内容转化为通俗易懂的文章",
    backstory="你是一位技术博客作者"
)

task1 = Task(description="调研 AI Agent 最新进展", agent=researcher)
task2 = Task(description="撰写技术分析文章", agent=writer)

crew = Crew(agents=[researcher, writer], tasks=[task1, task2])
crew.kickoff()