Agent 开发入门必懂的 10 个核心概念

ITmaster0731

232人浏览 · 2026-07-03 15:12:41

ITmaster0731 · 2026-07-03 15:12:41 发布

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 开发之旅。