深入理解 AI Agent（智能体）：从核心原理到代码实战

在当下的大模型时代，“Agent”无疑是最火爆的词汇之一。很多人简单地认为 Agent 就是“大模型调用 API”，但这只是对其最浅层的认知 。本文将带你拨开迷雾，深入硬核地了解真正的 Agent 究竟是什么，它的工作模式有哪些，以及如何用代码真正实现它。

---

一、 到底什么是 Agent？

目前国内常将 Agent 翻译为“智能体”，但从英文本意来看，它更准确的含义是“代理” 。简单来说，Agent 就是让大模型代理或模拟人的行为，使用特定工具或功能来完成特定任务的过程 。

业内有两个非常经典的 Agent 定义：

1. OpenAI 的经典公式

OpenAI 给出了一套非常实用的技术落地定义：

Agent = 大模型 (LLM) + 规划 (Planning) + 记忆 (Memory) + 工具使用 (Tool Use) 要实现一个 Agent，它必须基于大模型，具备思考下一步动作的规划能力，拥有短期和长期记忆，并能熟练调用外部工具 。

2. 复旦大学的“三模块”框架

复旦大学在相关研究中指出，Agent 概念框架包含三个核心组件：

大脑 (Brain)：作为控制器，承担记忆、思考和决策等基本任务 。

感知 (Perception)：从外部环境感知并处理多模态信息 。

行动 (Action)：使用工具执行任务并影响周围环境 。

---

二、 Agent 的 5 种常见工作流 (Patterns)

根据任务的复杂程度，Agent 有以下几种常见的工作流：

1. Reflection Pattern (反思模式)：大模型生成初始回答后，根据用户的反馈不断进行自我反思和修正迭代，直至用户满意 。

2. Tool Use Pattern (工具使用模式)：大模型接收查询后，主动调用外部的向量数据库或 API 工具获取额外信息，从而生成更准确的响应 。

3. ReAct Pattern (推理与行动模式)：将“推理 (Reason)”与“行动 (Action)”结合。模型先分析查询生成计划，然后调用工具执行，环境反馈结果后再由模型生成最终响应 。

4. Planning Pattern (规划模式)：计划器（Planner）将用户任务拆解为一系列子任务，交由执行者（Agent）逐个完成，全部完成后汇总结果 。

5. Multi-agent Pattern (多智能体模式)：引入 PM 代理、DevOps 代理、开发代理等多个不同角色的 Agent，通过分工协同处理极为复杂的任务 。

💻 实战代码：使用 LangChain 实现 ReAct Agent

以下是使用 LangChain 框架构建一个基础 ReAct Agent 的代码示例 ：

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

# 1. 定义工具
@tool
def magic_function(i: int) -> int:
    """Applies a magic function to an input."""
    return i + 2

tools = [magic_function]

# 2. 定义 REACT 风格的 Prompt,需包含思考步骤引导
prompt = ChatPromptTemplate.from_messages([
    ("system", "Use reasoning and tools to solve the problem step by step."),
    ("human", "{input}"),
    # 关键:加入思考步骤的占位符
    ("placeholder", "{agent_scratchpad}"),
])

# 3. 使用 ReActDocstoreAgent (或自定义 ReAct 逻辑)
agent = ReActDocstoreAgent.create(
    model=ChatOpenAI(model="gpt-4o-mini"),
    tools=tools,
    prompt=prompt
)

# 4. 执行 Agent
agent_executor = AgentExecutor(agent=agent, tools=tools)
result = agent_executor.invoke({"input": "what is the value of magic_function(3)?"})
print(result)

# 大模型思考与执行过程示例：
# Thought: 用户需要计算 magic_function(3), 工具 magic_function 可解决此问题, 调用它。
# Action: magic_function(3)
# Observation: 5
# Final Answer: 结果是 5

---

三、 Tool Use 深度解析：Function Call 与 MCP

工具使用（Tool Use）是 Agent 走向现实世界的抓手。目前最核心的技术是 Function Call（函数调用）。

什么是 Function Call？

Function Call 的本质是 大语言模型指导 AI 应用调用预设函数，而非模型直接执行函数 。它遵循一个闭环逻辑：【应用定义函数 -> 模型判断调用 -> 应用执行函数 -> 模型生成答案】 。

💻 实战代码：Function Call 完整 4 步流程

步骤 1：定义实际执行的工具函数（业务逻辑） 这是真正在系统里干活的函数，比如记账、查天气等 。

import openai
import json
from typing import Optional

def record_expense(category: str, amount: float, payment_method: str) -> dict:
    """实际执行“记录消费”的函数,可扩展为写入数据库等真实逻辑"""
    # 这里仅做示例返回
    return {
        "status": "success",
        "message": f"记录成功:{category} 消费 {amount}元(支付方式:{payment_method})"
    }

步骤 2：定义 Function Calling 元信息（给 LLM 的说明书） 告诉模型“有什么工具可用，怎么传参” 。

tools = [
    {
        "type": "function",
        "function": {
            "name": "record_expense", # 工具函数名,必须与实际函数名一致
            "description": "用于记录日常消费明细,需填写消费类别、金额、支付方式", # 让 LLM 判断何时调用
            "parameters": { # 定义参数规则
                "type": "object",
                "properties": {
                    "category": {
                        "type": "string",
                        "description": "消费类别,如餐饮、交通、购物" 
                    },
                    "amount": {
                        "type": "number",
                        "description": "消费金额(单位:元,需为数字)"
                    },
                    "payment_method": {
                        "type": "string",
                        "enum": ["支付宝", "微信", "现金", "信用卡"], # 限定可选值
                        "description": "支付方式,需从枚举中选择"
                    }
                },
                "required": ["category", "amount"] # 必填参数
            }
        }
    }
]

步骤 3：发送请求，让 LLM 决定是否调用工具

# 构造用户提问
user_question = "今天在星巴克喝咖啡花了52元,用支付宝付款"

try:
    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": user_question}],
        tools=tools, # 传入工具元信息
        tool_choice="auto" # 让 LLM 自动判断
    )
    
    message = response.choices[0].message
    if message.tool_calls:
        tool_call = message.tool_calls[0]
        print(f"LLM 决定调用工具:{tool_call.function.name}")
        print(f"调用参数: {tool_call.function.arguments}")
    else:
        print("LLM 直接回答:\n", message.content)
except Exception as e:
    print(f"API调用异常: {str(e)}")

步骤 4：执行工具函数，让 LLM 生成最终回答 把本地函数执行的结果发回给大模型，让它用人类的语言输出最终结果 。

try:
    if message.tool_calls:
        tool_call = message.tool_calls[0]
        if tool_call.function.name == "record_expense":
            # 解析 LLM 传的参数并执行本地函数
            args = json.loads(tool_call.function.arguments)
            result = record_expense(**args)
            print(f"工具执行结果:{result}")
            
            # 二次请求: 把工具结果发回给 LLM
            final_response = openai.chat.completions.create(
                model="gpt-4o",
                messages=[
                    {"role": "user", "content": user_question}, # 原始问题
                    {"role": "assistant", "tool_calls": [tool_call]}, # LLM最初的指令
                    {
                        "role": "tool",
                        "content": json.dumps(result), # 工具执行结果
                        "tool_call_id": tool_call.id # 关联工具调用
                    }
                ]
            )
            
            final_answer = final_response.choices[0].message.content
            print(f"最终回答:{final_answer}")
            # 输出示例：记录成功:餐饮 52元(支付宝)。
        else:
            print("未匹配到预期工具")
except json.JSONDecodeError:
    print("参数解析失败,请检查函数结构")
except Exception as e:
    print(f"二次请求异常:{str(e)}")

从 Function Call 到 MCP

Function Call 虽然强大，但各家厂商封装方式不同，且以代码函数为核心，不易于分发和部署 。

为此，MCP (Model Context Protocol，模型上下文协议) 应运而生。它将函数封装成标准化的服务（Server），引入了非常清晰的模块划分 。

MCP Host：用户对话的界面程序（如 VS Code、Claude Desktop） 。

MCP Client：负责与外部 Server 建立并维护连接 。

MCP Server：实际提供工具能力和上下文的程序（如天气服务器、高德地图服务器） 。

MCP 的通信流程与 Function Call 类似，但它允许 Server 独立部署在本地或云端，像下载 App 一样方便地被大模型插拔使用 。

---

四、 框架推荐与开发建议

在开发 Agent 时，目前市面上有诸多框架可供选择 ：

可视化编排平台：Dify（开源，可私有化部署）、Coze（闭源，有免费额度）、workflow 。

全代码框架：Langchain、AutoGen、CrewAI 。

💡 避坑建议： 对于专业的算法研发人员，建议在初期尽量“手搓”底层逻辑，而不是重度依赖 Langchain 等高度封装的框架 。手写代码虽然前期耗时稍长，但在后期应对公司各种复杂的定制化需求时，修改和拓展会游刃有余得多 。