1. 引言

随着大语言模型（LLM）能力的飞速提升，AI Agent（智能体）已成为人工智能领域最热门的方向之一。Agent 不再是简单的“问答机器人”，而是能够感知环境、自主规划、使用工具并执行复杂任务的智能系统。对于刚接触 Agent 开发的开发者来说，理解其背后的核心概念是入门的第一步。本文将为你梳理 Agent 开发中必懂的 10 个核心概念，帮助你快速建立起对 Agent 系统的整体认知。

2. Agent（智能体）

Agent 是能够自主感知环境、做出决策并采取行动以实现特定目标的实体。在 AI 领域，Agent 的核心特征包括：

• 自主性：无需人类持续干预，能独立运作。
• 感知能力：通过传感器或数据接口获取环境信息。
• 决策能力：基于内部策略（如 LLM 推理）选择下一步行动。
• 行动能力：通过执行器或 API 调用影响环境。

一个典型的 LLM Agent 工作流程是：接收用户指令 → 理解任务 → 规划步骤 → 调用工具执行 → 观察结果 → 调整计划 → 最终完成目标。

下面是一个使用 LangChain 构建的最简 Agent 示例：

from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.tools import tool

# 1. 定义一个简单的工具
@tool
def get_weather(city: str) -> str:
    """查询指定城市的天气情况"""
    return f"{city} 今天天气晴朗，气温 25°C"

# 2. 初始化 LLM
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# 3. 创建 Agent
tools = [get_weather]
agent = create_tool_calling_agent(llm, tools)

# 4. 包装为执行器
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 5. 运行 Agent
result = agent_executor.invoke({"input": "北京今天天气怎么样？"})
print(result["output"])

运行这段代码，Agent 会自动识别需要调用 get_weather 工具，传入参数 "北京"，然后基于返回结果生成自然语言回答。

下面是 Agent 工作流程的可视化：

3. 工具（Tool）

工具是 Agent 与外部世界交互的接口。没有工具的 Agent 只能"纸上谈兵"，而有了工具，Agent 就能执行实际任务。常见的工具类型包括：

• 代码解释器：执行 Python 代码，进行数据分析、计算。
• 搜索引擎：检索实时信息，弥补 LLM 知识截止问题。
• API 调用：调用第三方服务，如发送邮件、查询天气、操作数据库。
• 文件操作：读写本地或云端文件。

在开发中，工具通常被定义为一个函数，并附有清晰的描述（Description），LLM 通过理解描述来决定何时以及如何使用该工具。

下面演示如何定义多个工具并让 Agent 自主选择：

from langchain.tools import tool
import requests

@tool
def search_web(query: str) -> str:
    """搜索互联网获取最新信息，参数 query 为搜索关键词"""
    # 这里以模拟为例，实际可接入 SerpAPI 等
    return f"关于「{query}」的最新结果：AI Agent 框架在 2025 年迎来爆发式增长。"

@tool
def calculate(expression: str) -> str:
    """执行数学计算，参数 expression 为数学表达式，如 '2 + 3 * 4'"""
    try:
        result = eval(expression)
        return f"计算结果：{result}"
    except Exception as e:
        return f"计算错误：{str(e)}"

@tool
def send_email(recipient: str, subject: str, body: str) -> str:
    """发送邮件，参数 recipient 为收件人邮箱，subject 为邮件主题，body 为正文"""
    # 实际项目中接入 SMTP 或邮件 API
    return f"邮件已成功发送至 {recipient}，主题：{subject}"

# 将工具列表传给 Agent
tools = [search_web, calculate, send_email]

# Agent 会根据用户问题自动选择工具
# 例如用户问 "2 的 10 次方是多少？" → 调用 calculate("2 ** 10")
# 用户问 "帮我查一下最新的 AI 新闻" → 调用 search_web("AI 最新新闻")

工具定义的关键要素：

要素	说明	示例
函数名	工具的唯一标识	search_web
参数注解	参数名和类型，LLM 据此填充参数	query: str
文档字符串	描述工具功能和参数含义，LLM 据此决定何时调用	搜索互联网获取最新信息
返回值	工具执行结果，LLM 据此生成回答	str

4. 规划（Planning）

规划是 Agent 的核心智能体现。面对复杂任务，Agent 需要将其分解为可执行的子步骤。常见的规划策略有：

• ReAct（Reasoning + Acting）：交替进行推理和行动。Agent 先思考当前状态和下一步计划，然后执行一个动作，观察结果后再继续推理。这是最流行的 Agent 范式之一。
• Plan-and-Solve：先制定一个完整的执行计划，再逐步执行。适合步骤明确、依赖关系清晰的任务。
• 任务分解（Task Decomposition）：将大任务拆解为多个小任务，可以顺序执行或并行执行。

下面用代码演示 ReAct 模式的规划过程：

from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import tool
from langchain import hub

# 获取 ReAct 提示模板
prompt = hub.pull("hwchase17/react")

@tool
def search_knowledge(query: str) -> str:
    """搜索知识库获取信息"""
    knowledge_base = {
        "Python 列表推导式": "列表推导式是一种简洁创建列表的方式，如 [x**2 for x in range(10)]",
        "装饰器": "装饰器是修改函数或方法行为的高阶函数，使用 @ 语法糖",
    }
    return knowledge_base.get(query, f"未找到关于「{query}」的信息")

@tool
def code_interpreter(code: str) -> str:
    """执行 Python 代码并返回结果"""
    try:
        local_vars = {}
        exec(code, {}, local_vars)
        return str(local_vars.get("result", "代码执行成功"))
    except Exception as e:
        return f"执行错误：{str(e)}"

tools = [search_knowledge, code_interpreter]
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Agent 会输出类似下面的思考过程：
# Thought: 用户想知道列表推导式的用法，我需要先搜索相关知识
# Action: search_knowledge
# Action Input: "Python 列表推导式"
# Observation: 列表推导式是一种简洁创建列表的方式...
# Thought: 现在我可以给出示例代码并执行验证
# Action: code_interpreter
# Action Input: "result = [x**2 for x in range(5)]"
# Observation: [0, 1, 4, 9, 16]
# Thought: 我已经得到了结果，可以给出最终回答
# Final Answer: ...

ReAct 模式的决策流程如下：

Plan-and-Solve 模式则先规划再执行：

# Plan-and-Solve 风格的伪代码
def plan_and_solve(task: str, tools: list, llm) -> str:
    # 第一步：制定计划
    planning_prompt = f"""
    任务：{task}
    可用工具：{[t.name for t in tools]}
    请制定一个分步执行计划，每步指定使用的工具和输入。
    """
    plan = llm.invoke(planning_prompt)
    
    # 第二步：按计划逐步执行
    for step in plan.steps:
        tool = find_tool(step.tool_name)
        result = tool.run(step.input)
        print(f"步骤完成：{step.description} → {result}")
    
    # 第三步：汇总结果
    return llm.invoke(f"基于以下执行结果，回答用户问题：{plan.results}")

5. 记忆（Memory）

记忆让 Agent 具备"上下文感知"能力，避免重复犯错或丢失信息。Agent 的记忆通常分为两类：

• 短期记忆：当前对话或任务中的上下文信息，通常通过 LLM 的上下文窗口（Context Window）实现。
• 长期记忆：跨会话、跨任务的知识积累，通常借助外部存储（如向量数据库）实现。Agent 可以将重要信息写入长期记忆，并在需要时检索。

记忆管理是 Agent 开发中的关键挑战，尤其是在处理超长对话或复杂任务时。

下面演示如何在 LangChain 中为 Agent 添加记忆功能：

from langchain.memory import ConversationBufferMemory
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_openai import ChatOpenAI
from langchain.tools import tool

# 创建记忆对象
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True,
    max_token_limit=2000  # 限制记忆长度
)

@tool
def get_user_preference(topic: str) -> str:
    """获取用户对某个主题的偏好"""
    # 实际项目中从数据库读取
    return f"用户对 {topic} 的偏好：喜欢简洁的代码示例"

tools = [get_user_preference]
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
agent = create_tool_calling_agent(llm, tools)

agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    memory=memory,  # 注入记忆
    verbose=True
)

# 第一轮对话
agent_executor.invoke({"input": "我叫小明，喜欢 Python"})
# Agent 记住了用户信息

# 第二轮对话 - Agent 还记得用户的名字
agent_executor.invoke({"input": "我刚刚说了我叫什么？"})
# 输出：您叫小明

对于长期记忆，可以使用向量数据库：

from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain.memory import VectorStoreRetrieverMemory

# 初始化向量存储
embeddings = OpenAIEmbeddings()
vector_store = FAISS.from_texts(
    ["用户偏好：喜欢 Python 和数据分析", "用户项目：正在开发一个聊天机器人"],
    embedding=embeddings
)

# 创建基于检索的长期记忆
long_term_memory = VectorStoreRetrieverMemory(
    retriever=vector_store.as_retriever(search_kwargs={"k": 3}),
    memory_key="long_term_memory"
)

# 当 Agent 需要回忆过去的知识时，会自动从向量库中检索相关内容

记忆架构示意图：

6. 思维链（Chain-of-Thought, CoT）

思维链是一种提示技术，引导 LLM 在给出最终答案前，先展示中间推理步骤。在 Agent 开发中，CoT 被广泛用于提升 Agent 的推理能力。

例如，不直接问"北京和上海哪个更大？"，而是让 Agent 先思考：“我需要比较北京和上海的面积。北京的面积是 16,410 平方公里，上海的面积是 6,340 平方公里。因此北京更大。”

CoT 可以显著提升 Agent 在数学、逻辑、多步推理等任务上的表现。

下面演示如何在代码中实现 CoT 提示：

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# 不使用 CoT - 直接提问
direct_prompt = """
一个商店有 15 个苹果，卖出了 7 个，然后又进货了 3 箱，每箱 12 个。
现在商店有多少个苹果？
"""
direct_result = llm.invoke(direct_prompt)
print("直接回答：", direct_result.content)

# 使用 CoT - 引导逐步推理
cot_prompt = """
一个商店有 15 个苹果，卖出了 7 个，然后又进货了 3 箱，每箱 12 个。
现在商店有多少个苹果？

请逐步推理：
1. 先计算卖出后剩余的数量
2. 再计算进货的总数量
3. 最后计算最终数量
"""
cot_result = llm.invoke(cot_prompt)
print("CoT 回答：", cot_result.content)

在 Agent 中集成 CoT 的完整示例：

from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import tool
from langchain import hub
from langchain_openai import ChatOpenAI

# 自定义 CoT 风格的 Agent 提示
COT_PROMPT = """你是一个擅长逐步推理的 AI 助手。

在回答每个问题前，请按以下步骤思考：
1. 理解问题：明确用户想要什么
2. 分解问题：将复杂问题拆解为简单子问题
3. 逐步推理：每一步都要说明你的推理过程
4. 验证答案：检查答案是否合理

可用工具：
{tools}

工具名称列表：
{tool_names}

你的思考过程要用 "Thought:" 开头，行动用 "Action:" 开头。

{chat_history}
Question: {input}
{agent_scratchpad}"""

@tool
def get_product_price(product: str) -> str:
    """获取商品价格"""
    prices = {"苹果": 5, "香蕉": 3, "牛奶": 15}
    return f"{product} 的价格是 {prices.get(product, '未知')} 元"

@tool
def calculate_discount(price: float, discount: float) -> str:
    """计算折扣后的价格，price 为原价，discount 为折扣率（如 0.8 表示八折）"""
    final_price = price * discount
    return f"折扣后价格：{final_price} 元"

tools = [get_product_price, calculate_discount]
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# 使用自定义 CoT 提示创建 Agent
agent = create_react_agent(llm, tools, COT_PROMPT)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 测试多步推理
result = agent_executor.invoke({
    "input": "我想买 3 斤苹果，现在打八折，需要多少钱？"
})
print(result["output"])
# Agent 会先查苹果单价，再计算总价，最后应用折扣

CoT 与普通推理的对比：

7. 多智能体协作（Multi-Agent Collaboration）

单个 Agent 的能力有限，多个 Agent 协作可以完成更复杂的任务。多智能体系统通常包含：

• 主控 Agent（Orchestrator）：负责任务分配和协调。
• 专业 Agent（Specialist）：各自擅长特定领域，如代码生成、数据分析、内容审核。
• 通信协议：Agent 之间如何交换信息，通常通过消息队列或共享内存实现。

典型的应用场景包括：软件开发团队（产品经理 Agent + 开发 Agent + 测试 Agent）、客服系统（前台 Agent + 售后 Agent + 技术 Agent）。

8. 反馈循环（Feedback Loop）

Agent 不是“一次性”执行任务的。它需要不断从环境中获取反馈，并根据反馈调整自己的行为。反馈循环是 Agent 实现自我改进的基础。

• 内部反馈：Agent 自我评估执行结果是否符合预期。
• 外部反馈：来自用户、环境或其他 Agent 的明确反馈。
• 错误恢复：当某个步骤失败时，Agent 应能识别错误并尝试替代方案，而不是直接崩溃。

9. 安全与对齐（Safety & Alignment）

Agent 拥有自主行动能力，因此安全问题是重中之重。核心关注点包括：

• 指令注入：防止恶意用户通过输入诱导 Agent 执行危险操作。
• 权限控制：Agent 应遵循最小权限原则，只拥有完成任务所需的最小工具权限。
• 价值观对齐：确保 Agent 的行为符合人类的伦理和价值观，不产生有害输出。
• 可解释性：Agent 的决策过程应可追溯、可审计。

10. 评估（Evaluation）

如何衡量一个 Agent 的好坏？传统的指标（如准确率、F1 分数）往往不够。Agent 评估需要关注：

• 任务完成率：Agent 是否成功完成了用户指定的目标。
• 效率：完成任务所需的步骤数、调用工具的次数、总耗时。
• 鲁棒性：面对异常输入、工具故障、信息缺失时的表现。
• 成本：LLM API 调用次数和 Token 消耗。

常用的评估框架包括 AgentBench、GAIA 等，它们提供了标准化的测试场景和评分体系。

11. 总结

Agent 开发是一个融合了 LLM、规划、工具使用、记忆管理和安全对齐的综合性领域。掌握以上 10 个核心概念，你就具备了构建一个基础 Agent 系统的理论框架。下一步，建议你选择一个成熟的 Agent 框架（如 LangChain、AutoGPT、CrewAI）动手实践，将理论转化为代码，真正开启你的 Agent 开发之旅。