LangChain Agent开发_系列10

转载：小红书 AI产品赵哥

前言🔖

这是 LangChain 系列笔记的第十篇。如果说 RAG 解决了大模型记性不好的问题，那么 Agent 解决的就是大模型手脚笨拙和不会思考的问题。

很多产品经理在看完 RAG 那一篇后会觉得：“这不就是个高级搜索引擎吗？” 但当你真正看懂了 Agent，你会感到后背有冷风吹过 —— 这东西未来有可能替代人类岗位的。

在 LangChain 的语境下，Agent 是一个使用 LLM 来决定采取什么行动以及按什么顺序采取行动的系统。之前的 Chain（链）是硬编码的序列：步骤 A → 步骤 B → 步骤 C。产品经理和开发在代码里把流程 HardCoding 了。

而 Agent 是动态的推理引擎：它自己看情况。也许是 A → B，也许是 A → A → C → B。

今天咱继续聊实操的东西，直接用 LangChain 从零开发一个 Agent。我会带你通过代码看看它是咋运作的，以及在产品设计中必须注意的关键点。

一、Agent 的核心思想：从 “链” 到 “体”🔖

在我们聊技术细节之前，我们得在概念层面，理解 Chain 和 Agent 的根本区别。

Chain（链）：是一个固定的、预设的流水线。你事先定义好第一步做什么，第二步做什么，第三步做什么。它的执行路径是确定的。例如，Prompt → LLM → Output Parser。
Agent（智能体）：是一个动态的、自主的决策系统。你只给它一个最终目标和一堆可用的工具。至于先用哪个工具，后用哪个工具，拿到结果后下一步怎么办，完全由 Agent 自己循环往复地决定。

这个 “循环往复地决定” 的过程，就是 Agent 的灵魂。这个灵魂，在 LangChain（以及大多数 Agent 框架）中，被一个叫做 ReAct 的著名思想所主导。

🔹ReAct: Agent 的 “思考 – 行动” 循环

ReAct 是 “Reasoning and Acting” 的缩写，即推理与行动。它复刻了人类解决问题时的思考过程。当面对一个任务时，Agent 会进入一个循环，每一步都包含三个核心要素：

Thought（思考）：Agent 首先会对自己说：“我现在面临什么问题？我的目标是什么？我手头有哪些工具？根据当前情况，我下一步应该做什么？” 这一步是 LLM 在进行自我对话和推理。
Action（行动）：基于思考，Agent 决定调用一个具体的工具，并确定调用这个工具需要什么参数。例如，决定调用 search 工具，参数是 “LangChain 是什么”。
Observation（观察）：Agent 执行了行动（调用了工具），并得到了一个结果。这个结果就是 “观察”。例如，搜索引擎返回了一段关于 LangChain 的维基百科介绍。
- 拿到这个 Observation 之后，Agent 并不会结束。它会带着这个新的信息，重新进入下一个循环，开始新一轮的 Thought：
- - Thought（新一轮）：“好了，我已经知道 LangChain 是一个 AI 开发框架了。但是用户的问题是‘如何用它开发 Agent’。我手头的信息还不够。下一步，我应该搜索‘LangChain Agent 开发教程’。”
- - Action（新一轮）：调用 search 工具，参数是 “LangChain Agent 开发教程”。
- - Observation（新一轮）：得到了一篇教程链接。
- - …… 这个循环会一直持续下去，直到 Agent 在某一次的 Thought 中认为：“我已经收集到了足够的信息，可以回答用户的原始问题了。” 这时，它才会生成最终的答案，并结束循环。

这就是 Agent 厉害的地方：它把一个大问题，通过 LLM 的自我推理，分解成了一系列可执行的小步骤，并利用工具去逐个完成。

🔹构成 Agent 的三大核心组件

现在我们知道了 Agent 的工作原理。在 LangChain 中，要组装一个 Agent，你需要三个东西：

LLM（大脑）：这不是任何 LLM 都行。这个 LLM 必须足够聪明，能够进行有效的多步推理，并且要经过专门的微调，能很好地理解工具调用的指令。GPT5、Claude 4 系列是目前的首选。
Tools（手脚）：一个工具的列表。它可以是任何东西：一个搜索引擎、一个计算器、一个数据库查询接口、一个发送邮件的 API，甚至是另一个 Chain。你给 Agent 提供的工具，决定了它能力的边界。
Agent Executor（中枢神经系统）：这是 LangChain 提供的一个核心控制器。它负责把 LLM 和 Tools 粘合在一起，忠实地执行上面所说的 ReAct 循环。它会把用户的输入和历史记录交给 LLM，得到 LLM 的Thought和Action，然后去调用对应的Tool，再把Observation反馈给 LLM，周而复始。

二、实战推演：构建你的第一个 “研究员” Agent🔖

理论说完了，我们立刻动手。我们将构建一个简单的研究员 Agent，它的目标是回答一个需要结合搜索和计算才能解决的问题。

目标任务：“目前苹果公司的股价是多少？如果我用 10000 美元，能买多少股？”

这个问题，单一的 LLM 无法回答，因为它不知道实时的股价（需要搜索），也可能算不准除法（需要计算）。这正是 Agent 的用武之地。

🔹第一步：准备工具箱（Tools）

我们需要两个工具：一个搜索引擎，一个计算器。LangChain 的langchain-community和langchain-openai等库里，已经内置了很多可以直接使用的工具。

from langchain_community.tools import TavilySearchResults
from langchain.tools import tool

# 工具一：搜索引擎
# Tavily是一个专为LLM Agent优化的搜索引擎，效果比传统搜索好。
# 你需要一个Tavily API Key，并设置环境变量。
# 或者，你也可以用DuckDuckGo等免费工具：from langchain_community.tools.ddg_search import DuckDuckGoSearchRun
search_tool = TavilySearchResults()

# 工具二：计算器
# 我们用 @tool 装饰器快速创建一个自定义的计算器工具
@tool
def calculator(expression: str) -> float:
    """当需要进行数学计算时，使用此工具。输入应该是一个可以被Python `eval()` 函数执行的有效数学表达式。"""
    # 注意：在生产环境中使用eval()有安全风险，这里仅为演示
    try:
        return eval(expression)
    except Exception as e:
        return f"计算错误: {e}"

# 把工具放入列表
tools = [search_tool, calculator]

💡 产品同学 insight：calculator 工具的文档字符串非常关键。它告诉了 Agent，什么时候该用这个工具，以及输入应该是什么格式，这里一定要认真编写。

🔹第二步：选择大脑 (LLM) 并设计 Prompt

我们需要一个支持工具调用的强大 LLM。

from langchain_openai import ChatOpenAI

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

接下来是 Prompt 的设计。Agent 的 Prompt 比普通的 Prompt 要复杂一些，它通常包含几个特殊的变量（下面例子中的agent_scratchpad），由AgentExecutor在运行时自动填充。

from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder

# 这是LangChain为ReAct Agent设计的一个标准Prompt结构
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个强大的研究助手。"),

("user", "{input}"),
# MessagesPlaceholder是Agent思考和观察过程的"暂存区"。
# AgentExecutor会把每一步的Thought, Action, Observation都填在这里。
MessagesPlaceholder(variable_name="agent_scratchpad"),
])

🔹第三步：组装并运行 Agent Executor

现在，把大脑、手脚和 Prompt 粘合在一起，创建 Agent，并把它交给 “中枢神经系统”AgentExecutor来驱动。

from langchain.agents import create_openai_tools_agent, AgentExecutor

# 1. 创建Agent
# `create_openai_tools_agent`是LangChain提供的工厂函数，
# 它能将LLM、工具和Prompt组合成一个遵循OpenAI工具调用规范的Agent。
agent = create_openai_tools_agent(llm, tools, prompt)

# 2. 创建Agent Executor
# `verbose=True`是你的"透视眼镜"，能让你看到Agent每一步的思考过程！

agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 3. 运行！
question = "目前苹果公司的股价是多少？如果我用10000美元，能买多少股？"
response = agent_executor.invoke({"input": question})

print("\n--- Agent的最终回答 ---")
print(response["output"])

Agent 的内部心声（verbose=True 的输出解读）

当你运行上面的代码，你会看到一段 Agent 的内心独白：

> Entering new AgentExecutor chain...

Thought: The user wants to know the current stock price of Apple (AAPL) and how many shares they can buy with $10,000.
I need to perform two steps:
1. Find the current stock price of Apple. I can use the search tool for this.
2. Calculate the number of shares. I will need the stock price from step 1 and the user's amount ($10,000). I can use the calculator tool for this.

First, I'll search for the stock price.

Action:
{
  "tool": "tavily_search_results_json",
  "tool_input": {
    "query": "current stock price of Apple Inc. (AAPL)"
  }
}

Observation: [{"url": "...", "content": "As of the latest data, Apple Inc. (AAPL) is trading at approximately 273.40."}]

Thought: Great, I have the current stock price, which is 273.40.
Now I need to calculate how many shares can be bought with $10,000.
The calculation is 10000 / 273.40.
I will use the calculator tool for this.

Action:
{
  "tool": "calculator",
  "tool_input": {
    "expression": "10000 / 273.40"
  }
}

Observation: 36.57573335200009

Thought: I have performed both steps.
1. The stock price is 273.40.
2. With $10,000, one can buy approximately 36.57 shares.
I can now provide the final answer to the user.

Final Answer: 根据最新数据，苹果公司（AAPL）的当前股价约为 273.40 美元。用10000美元，您大约可以购买 36.57 股。

💡 产品同学 insight：这段日志，是你理解、调试和优化 Agent 的最宝贵资料。它清晰地展示了 Agent 是如何将一个复杂任务分解、并按部就班地执行的。当 Agent 行为不符合预期时，第一件事就是来复盘这份 “思想日志”。

三、LangChain 中的 Agent 类型：不止一种思考模式🔖

我们上面使用的是基于 OpenAI 工具调用能力的 Agent，这是目前主流且最稳定的方式。但 LangChain 的历史上，以及为了适应不同的 LLM，还提供了其他几种 Agent 类型。作为产品经理，你不需要掌握它们的实现细节，但需要了解它们的设计思想和适用场景。

OpenAI Tools Agent：我们刚才用的就是。它依赖模型本身强大的、内置的工具调用能力。LLM 会返回一个特殊的 JSON 结构，明确指出要调用哪个工具和用什么参数。这是目前构建 Agent 的首选，因为它最可靠。
XML Agent：主要为 Claude 这类模型设计。它的工作方式类似，只是模型返回的是一个 XML 格式的指令，而不是 JSON。
ReAct Agent：这是更古典的一种 Agent。它不依赖模型内置的工具调用功能。相反，它要求 LLM 在它的 Thought 后面，自己生成一段特定格式的文本，比如 Action: search[query]。然后，AgentExecutor 需要用正则表达式去解析这段文本，来弄明白 LLM 想干嘛。
- 优点：它对 LLM 的要求更低，理论上任何一个足够聪明的 LLM 都能通过 Prompt 引导来使用。
- 缺点：因为依赖文本解析，所以比较脆弱。如果 LLM 的输出格式稍有偏差，解析就会失败，Agent 就会卡住。
Self-Correction Agent (自我修正 Agent)：这是一个更高级的东西。Agent 在执行完一步后，不仅会观察结果，还会对自己刚才的行动进行批判性反思。比如，它搜索完后，会想：“我刚才的搜索词是不是太宽泛了？我应该用更具体的关键词再搜一次。” 这种 Agent 通常会包含一个批评家（Critic）的角色，让 Agent 的决策过程更棒。

选择哪种 Agent，很大程度上取决于你选择的 LLM。如果你用的是 OpenAI 或 Anthropic 的最新模型，那么就用它们对应的官方工具调用 Agent。如果用的是某些开源模型，你可能就需要退回到更基础的 ReAct 模式。

四、Agent 开发中的坑🔖

这里总结三个最典型的，产品经理在验收时一定要注意。

🔹1. 陷入死循环

现象：Agent 反复调用同一个工具，或者在两个工具之间反复横跳，直到 Token 耗尽或触发超时。

原因：

工具返回的结果太模糊，Agent 没看懂，于是决定再查一次。
Prompt 没写好，没有告诉 Agent 何时应该停止。

解法：

设置最大迭代次数：在 AgentExecutor 中设置 max_iterations，通常设为 5 到 10。
优化工具的返回值：工具返回的不仅仅是数据，最好带上描述。例如不要只返回 404，要返回 错误：未找到数据，请检查拼写或尝试其他查询条件。

🔹2. 格式解析错误

现象：模型想调用工具，但生成的 JSON 格式少了个括号，或者参数类型不对（把数字变成了字符串）。

原因：

选用的模型不够聪明（如 Llama 3 8B），或者参数结构太复杂。
尽量用 Pydantic 强类型定义工具参数。
在 AgentExecutor 中开启 handle_parsing_errors=True。这样当解析失败时，LangChain 会自动把错误信息喂回给模型，让模型自我修正重试。

🔹3. 上下文超限 (Context Window Exceeded)

现象：任务跑了一半，报错 “Token limit reached”。

原因：agent_scratchpad 里记录了每一次工具调用的输入和输出。如果有一个工具返回了 5000 字的文档，搞个两轮，Token 就爆了。

解法：

工具输出截断：在自定义工具内部，限制返回值的长度。如果内容太长，只返回摘要，或者返回 “内容太长，请分段读取”。
记忆清理：定期清理早期的思考步骤，只保留最近的 N 步。

五、对 AI 产品经理说几句🔖

🔹5.1. AI 产品经理在 Agent 开发中的核心价值

看到这里，你可能会觉得 Agent 的开发非常技术化。但实际上，一个 Agent 的成败，产品经理在其中扮演着至关重要的、不可替代的角色。我们不能只是 “需求提出者”，而是 “系统设计师”。

你的核心工作，体现在以下四个方面：

1. 工具的策划与设计
- Agent 的能力边界，完全由你为它选择的工具决定。你的首要工作，就是思考：“为了完成这个宏大的业务目标，我的 Agent 需要具备哪些原子能力？”
- 你要和开发团队一起，盘点公司现有的 API，或者设计新的 API，然后将它们封装成 Agent 可以理解的 Tool。
- 对于每个工具，你必须亲自撰写或审核它的description（这一点至关重要）。这个描述，就是 Agent 的工具使用说明书，是你向 AI 提需求的最直接方式。一个模糊的描述，会导致 Agent 在关键时刻选择困难。

2. 系统提示的设计
- Agent 的系统提示，就是这个智能体的底层定义。它定义了 Agent 的身份、性格、终极目标、行为准则，以及在遇到困难时的处理策略。
- 比如，你可以规定：“你是一个极其注重成本的助手，在调用任何昂贵的工具前，必须先用免费工具确认必要性。” 或者，“你必须时刻保护用户隐私，在任何情况下都不能索要或记录个人身份信息。”
- 这份《说明书》的撰写，是纯粹的产品设计工作。

3. 失败案例的分析与迭代
- Agent 一定会犯错。它可能会选错工具，可能会陷入死循环，可能会错误地解析工具的输出。
- 你的工作，就是和开发一起，一头扎进 LangSmith 的日志里，去复盘那些失败的 Trace。你得阅读 Agent 的日志，找到它在哪一步犯了错误。
- 是因为工具描述有歧义？还是系统提示有漏洞？还是 LLM 本身能力不足？找到根因，然后迭代你的工具描述或系统提示，就是你驱动 Agent 不断进化的核心方法。

4. 定义成功的标准：如何衡量一个 Agent 的好坏？最终答案的正确性只是其中之一。你还需要定义一系列过程指标：
- 任务完成率 (Task Completion Rate)：在多少比例的情况下，Agent 能够独立完成任务而不需要人工干预？
- 执行步数 (Number of Steps)：完成一个任务平均需要多少步？步数越少，通常意味着效率越高，成本越低。
- 工具选择准确率 (Tool Selection Accuracy)：Agent 选择工具的决策是否总是最优的？
- 成本效益 (Cost-Effectiveness)：完成一次任务的平均 API 调用成本是多少？

🔹5.2. 产品经理的设计心法

开发 Agent 不仅仅是写代码，更多的是设计认知流程。作为 PM，你在写 Agent 的 PRD 时，不要只写 “实现一个查询助手”。你要定义：

工具边界：明确 Agent 能干什么，不能干什么。给工具的 Description 越清晰，Agent 越聪明。
错误兜底：当 Agent 查不到数据时，是直接回复 “不知道”，还是引导用户换个问法？
权限控制：涉及修改数据（增删改）的操作，必须加入 Human-in-the-loop（人类确认）环节。

总结：欢迎来到 “智能体为王” 的时代🔖

LangChain 的 Agent 开发其实就是 “Prompt 工程 + 工具函数开发 + 循环控制” 的组合。

现在的 Agent 还处于 “实习生” 阶段，你必须给它明确的手册（Prompt）、趁手的工具（Tools）和严格的监督（Guardrails），它才能从一个只会聊天的 Chatbot，进化成真正能解决问题的数字员工。

92IT

Just love IT.

LangChain Agent开发_系列10