从零构建AI Agent：基于LangChain与ReAct框架的智能体开发实战
最近在项目里尝试接入大模型时，发现一个普遍现象：很多开发者热衷于讨论AI Agent的宏大前景，但真要动手实现一个能调用工具、处理复杂任务的智能体时，却往往不知从何下手。市面上的Coze、Dify等平台虽然降低了门槛，但如果不理解其背后的工作机制，一旦遇到定制化需求或线上问题，排查起来会非常困难。
本文将从零开始，带你深入理解AI Agent的核心机制——ReAct，并基于LangChain框架，手把手构建一个能自主调用工具、完成复杂任务的智能体。无论你是想为现有业务增加AI能力，还是单纯对Agent技术好奇，这篇文章都将提供一套可运行、可调试的完整方案。
1. 什么是AI Agent？从概念到本质
在深入代码之前，我们有必要先厘清几个核心概念。很多人将AI Agent简单理解为“聊天机器人升级版”，这种理解虽然直观，但不够准确。
AI Agent（智能体） 的本质是一个能够感知环境、自主决策并执行行动以达成目标的系统。我们可以用一个简单的类比来理解：如果把大语言模型（LLM）看作一个人的“大脑”，那么AI Agent就是这个配备了“大脑”的完整“机器人”。这个机器人不仅会思考（推理），还拥有“手”和“眼睛”（工具），可以与环境互动。
一个典型的AI Agent通常包含以下几个核心组件：
- 规划模块（Planner） ：负责分解任务、制定步骤。例如，当用户问“帮我订一张明天北京到上海的机票”时，规划模块会将其分解为：查询航班、比价、选择航班、填写信息、确认支付等子任务。
- 记忆模块（Memory） ：存储对话历史、工具调用结果、用户偏好等，为后续决策提供上下文。
- 工具集（Tools） ：Agent可以调用的外部能力，如计算器、搜索引擎、数据库查询API、代码执行环境等。
- 行动模块（Action） ：根据规划调用具体的工具。
- 反思模块（Reflection） ：评估行动结果，判断是否达成目标，是否需要调整策略。
而 LangChain ，正是将这些组件标准化、模块化，并提供了一套优雅编排框架的“脚手架”。它不是一个具体的Agent实现，而是一个让你能够快速构建、测试和部署Agent的开发工具包。
那么，如何让LLM这个“大脑”知道在什么情况下该调用哪个“工具”呢？这就是 ReAct机制 要解决的核心问题。
2. ReAct机制：让LLM学会“三思而后行”
ReAct（Reasoning + Acting）是一种让大模型将“推理”和“行动”结合起来解决复杂任务的框架。其灵感来源于人类的思考过程：我们遇到问题时，通常会先思考（分析问题、制定计划），然后行动（执行计划），再根据行动结果观察反馈，并进一步思考调整。
2.1 为什么需要ReAct？
大模型虽然知识渊博，但存在两个固有局限：
- 知识滞后性 ：训练数据有截止日期，无法获取最新信息（如今天的天气、股价）。
- 专业能力不足 ：不擅长精确计算、实时查询、操作外部系统等。
ReAct通过让LLM主动调用外部工具，完美地弥补了这些缺陷。它让LLM从“全知但被动”的知识库，转变为“会思考、会求助”的智能体。
2.2 ReAct的核心工作流程
ReAct的工作流程是一个典型的循环： 推理（Reason）→ 行动（Act）→ 观察（Observe）→ 再推理... ，直到任务完成。
我们通过一个具体例子来拆解这个过程。假设用户提问：“ 2024年周杰伦上海演唱会门票多少钱？ ”
一个基于ReAct的Agent处理流程如下：
- 推理1 ：用户需要查询2024年周杰伦上海演唱会的门票价格。这是一个需要实时信息的问题，我的内部知识无法回答，需要调用网络搜索工具。
- 行动1 ：调用
网络搜索工具，关键词为“2024 周杰伦 上海 演唱会 门票 价格”。 - 观察1 ：工具返回了搜索结果列表，其中包含几个票务网站链接和新闻页面。
- 推理2 ：搜索结果较多，需要提取关键信息。第一个结果是“大麦网-周杰伦2024上海演唱会”，这很可能是一个官方票务平台，应优先查看。
- 行动2 ：调用
网页内容提取工具，访问第一个结果的URL。 - 观察2 ：工具返回了网页内容，显示演唱会时间为2024年8月10日，看台票价格从580元到1680元不等，内场票从2280元起。
- 推理3 ：已获取到用户所需的价格信息。需要整理并清晰地呈现给用户，同时注明信息来源和不同档位的价格。
- 最终回答 ：根据观察2的信息，组织语言回复用户。
可以看到，ReAct通过一步步的“思考-行动-观察”，引导LLM像人类一样使用工具解决问题，而不是盲目地生成可能错误的答案。
2.3 ReAct在LangChain中的实现形式
在LangChain中，ReAct机制通常通过 Agent 类来实现。LangChain的Agent不是一个预先训练好的模型，而是一个 决策框架 。它包含以下几个关键部分：
- Agent ：决策核心，根据当前对话历史和工具描述，决定下一步是直接回答，还是调用某个工具。
- Tools ：可供调用的工具列表，每个工具都有名称和功能描述。
- Toolkit ：工具集合。
- AgentExecutor ：驱动Agent运行的执行器，负责循环运行“推理-行动-观察”的流程，直到Agent决定结束任务。
3. 环境准备与项目搭建
理论讲得再多，不如一行代码。接下来，我们开始动手搭建环境，实现第一个AI Agent。
3.1 环境与依赖
本项目基于Python，建议使用Python 3.8及以上版本。我们将使用LangChain框架，并接入一个开源的LLM API作为“大脑”。
首先，创建项目目录并初始化虚拟环境：
mkdir my_first_ai_agent && cd my_first_ai_agent
python -m venv venv
# Windows
venv\Scripts\activate
# Linux/Mac
source venv/bin/activate
然后，安装核心依赖。LangChain生态正在快速发展，包名可能有变化，以下是当前（请注意版本可能更新）的稳定安装方式：
pip install langchain langchain-community langchain-openai
langchain: LangChain核心框架。langchain-community: 社区维护的第三方工具、模型集成。langchain-openai: OpenAI模型官方集成（我们也可以使用其他兼容OpenAI API的模型服务）。
由于我们需要调用大模型，这里以使用一个兼容OpenAI API的国内服务为例（请注意，你需要自行获取可用的API Key和Base URL）。我们同时安装 python-dotenv 来管理敏感信息：
pip install python-dotenv requests
3.2 项目结构规划
一个清晰的目录结构有助于后续开发和维护：
my_first_ai_agent/
├── .env # 环境变量，存放API密钥等敏感信息
├── requirements.txt # 项目依赖
├── src/
│ ├── __init__.py
│ ├── tools/ # 自定义工具目录
│ │ ├── __init__.py
│ │ ├── calculator.py # 计算器工具
│ │ └── searcher.py # 搜索工具（示例）
│ ├── agents/ # Agent定义目录
│ │ ├── __init__.py
│ │ └── react_agent.py # ReAct Agent核心逻辑
│ └── main.py # 主程序入口
└── README.md
创建基础文件：
mkdir -p src/tools src/agents
touch .env requirements.txt src/main.py src/agents/__init__.py src/agents/react_agent.py src/tools/__init__.py src/tools/calculator.py
在 .env 文件中配置你的API信息（请替换为你的实际信息）：
# .env
OPENAI_API_KEY=sk-your-api-key-here
OPENAI_API_BASE=https://api.your-llm-provider.com/v1
MODEL_NAME=gpt-3.5-turbo # 或 gpt-4, qwen-plus等
4. 实战第一步：打造你的第一个工具
工具（Tool）是Agent能力的延伸。我们从一个最简单的工具开始——一个能进行精确计算的工具。
为什么需要这个工具？ 因为大语言模型（尤其是早期版本）在数学计算上并不精确，它们可能生成看似合理但实际错误的答案。将计算任务交给专门的工具，能保证结果的准确性。
创建文件 src/tools/calculator.py ：
# src/tools/calculator.py
from langchain.tools import BaseTool
from typing import Union, Optional, Type
from pydantic import BaseModel, Field
# 定义工具的输入参数模型
class CalculatorInput(BaseModel):
"""计算器工具的输入参数。"""
a: Union[int, float] = Field(description="第一个数字")
b: Union[int, float] = Field(description="第二个数字")
operator: str = Field(description="运算符，支持 '+', '-', '*', '/', '**'")
class CalculatorTool(BaseTool):
"""一个能执行基础算术运算的计算器工具。"""
name = "calculator"
description = """
当需要执行精确的数学计算时使用此工具。
支持加法(+)、减法(-)、乘法(*)、除法(/)、乘方(**)。
输入必须是数字和运算符。
"""
args_schema: Optional[Type[BaseModel]] = CalculatorInput
def _run(self, a: Union[int, float], b: Union[int, float], operator: str) -> str:
"""执行计算。"""
try:
if operator == '+':
result = a + b
elif operator == '-':
result = a - b
elif operator == '*':
result = a * b
elif operator == '/':
if b == 0:
return "错误：除数不能为零。"
result = a / b
elif operator == '**':
result = a ** b
else:
return f"错误：不支持的运算符 '{operator}'。支持的操作符为：+, -, *, /, **"
# 返回格式化的结果，便于Agent理解
return f"计算结果：{a} {operator} {b} = {result}"
except Exception as e:
return f"计算过程中发生错误：{str(e)}"
async def _arun(self, a: Union[int, float], b: Union[int, float], operator: str) -> str:
"""异步执行计算（本例中与同步相同）。"""
return self._run(a, b, operator)
代码解析：
- 继承
BaseTool：所有LangChain工具都必须继承自BaseTool类。 - 定义工具元信息 ：
name: 工具的唯一标识，Agent通过这个名字来调用它。description: 工具的功能描述。 这是最关键的部分 。LLM根据这个描述来判断是否以及何时调用该工具。描述要清晰、准确，说明工具的用途、输入和输出。
- 定义输入模式（
args_schema） ：使用Pydantic模型CalculatorInput来严格定义工具的输入参数。这能帮助LangChain将Agent的自然语言决策解析成结构化的参数。 - 实现
_run方法 ：这是工具的核心逻辑，执行具体的操作并返回结果。 - 实现
_arun方法 ：异步版本，用于支持异步调用。
5. 构建你的第一个ReAct Agent
有了工具，我们就可以组装Agent了。我们将使用LangChain提供的 create_react_agent 函数，它封装了标准的ReAct逻辑。
创建文件 src/agents/react_agent.py ：
# src/agents/react_agent.py
import os
from dotenv import load_dotenv
from langchain import hub
from langchain.agents import create_react_agent, AgentExecutor
from langchain.agents.format_scratchpad import format_log_to_str
from langchain.agents.output_parsers import ReActSingleInputOutputParser
from langchain.tools.render import render_text_description
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.prompts import PromptTemplate
# 导入我们自定义的工具
from src.tools.calculator import CalculatorTool
# 加载环境变量
load_dotenv()
def build_react_agent():
"""构建并返回一个配置了ReAct Agent的执行器。"""
# 1. 初始化LLM
# 使用环境变量中的配置
llm = ChatOpenAI(
model=os.getenv("MODEL_NAME", "gpt-3.5-turbo"),
openai_api_key=os.getenv("OPENAI_API_KEY"),
openai_api_base=os.getenv("OPENAI_API_BASE"),
temperature=0, # 温度设为0，使输出更确定，更适合工具调用
streaming=False,
)
# 2. 准备工具集
tools = [CalculatorTool()]
# 将工具列表转换为格式化的字符串描述，供提示词使用
tool_names = ", ".join([tool.name for tool in tools])
tool_descriptions = render_text_description(tools)
# 3. 定义提示词（Prompt）
# ReAct Agent的提示词比较复杂，我们从LangChain Hub拉取一个社区维护的优秀版本
# 也可以自定义，但Hub上的版本经过大量测试，更稳定
prompt = hub.pull("hwchase17/react")
# 提示词中需要动态替换的部分，我们通过Partial来提前填充
prompt = prompt.partial(
tools=tool_descriptions,
tool_names=tool_names,
)
# 4. 构建Agent
# create_react_agent 将LLM、提示词、工具绑定在一起，形成决策逻辑
agent = create_react_agent(
llm=llm,
tools=tools,
prompt=prompt,
)
# 5. 配置记忆（Memory）
# 让Agent能记住对话历史，处理多轮对话
memory = ConversationBufferMemory(
memory_key="chat_history",
return_messages=True,
output_key="output"
)
# 6. 创建Agent执行器（AgentExecutor）
# 这是驱动Agent运行的核心引擎，负责循环执行“思考-行动-观察”
agent_executor = AgentExecutor.from_agent_and_tools(
agent=agent,
tools=tools,
memory=memory,
verbose=True, # 设为True可以看到Agent详细的思考过程，调试时非常有用
handle_parsing_errors=True, # 优雅处理Agent输出解析错误
max_iterations=10, # 限制最大迭代次数，防止死循环
early_stopping_method="generate", # 当Agent连续两次生成最终答案时停止
)
return agent_executor
if __name__ == "__main__":
# 本地测试
agent_executor = build_react_agent()
print("AI Agent 已启动！输入'退出'或'quit'结束对话。\n")
while True:
try:
user_input = input("\n您: ")
if user_input.lower() in ["退出", "quit", "exit"]:
print("再见！")
break
if not user_input.strip():
continue
# 调用Agent执行器
response = agent_executor.invoke({"input": user_input})
print(f"\nAgent: {response['output']}")
except KeyboardInterrupt:
print("\n\n程序被中断。")
break
except Exception as e:
print(f"\n发生错误: {e}")
关键点解析：
-
AgentvsAgentExecutor：这是初学者最容易混淆的概念。Agent：是一个 决策函数 。它接收用户输入和对话历史，输出一个AgentAction（表示要调用哪个工具及参数）或AgentFinish（表示任务完成，输出最终答案）。AgentExecutor：是 运行引擎 。它循环调用Agent，执行Agent决定的工具调用，将结果（Observation）作为新的输入反馈给Agent，直到Agent输出AgentFinish。
- 提示词（Prompt） ：ReAct Agent的提示词模板非常关键，它定义了Agent的“思考格式”。我们从LangChain Hub拉取
hwchase17/react这个经过验证的模板，它已经内置了ReAct的标准格式（Thought, Action, Observation）。 - 记忆（Memory） ：
ConversationBufferMemory将对话历史保存在内存中，使Agent具备上下文感知能力。 -
verbose=True：在开发阶段，务必开启这个选项。它会打印出Agent完整的思考链（Chain of Thought），让你清晰地看到它是如何推理、决定调用工具、以及如何处理工具返回结果的。这是调试和理解Agent行为的最重要手段。 - 安全限制 ：
max_iterations和early_stopping_method是防止Agent陷入死循环或无限递归的重要保障。
6. 运行与测试：见证Agent的思考过程
现在，让我们运行这个Agent，看看它是如何工作的。
首先，确保你的 .env 文件已正确配置API信息。然后，运行主程序：
python src/agents/react_agent.py
你会看到类似以下的启动信息，然后进入交互模式。
测试场景1：数学计算
您: 请帮我计算一下 3.1415926 乘以 2.7182818 等于多少？
开启 verbose=True 后，你将在控制台看到Agent的详细思考过程：
> 进入新的AgentExecutor链...
思考：用户要求进行乘法计算。我有一个计算器工具可以处理这个。我需要使用计算器工具。
行动：调用计算器工具。
行动输入：{"a": 3.1415926, "b": 2.7182818, "operator": "*"}
观察：计算结果：3.1415926 * 2.7182818 = 8.53973422232268
思考：我已经得到了计算结果，可以回答用户了。
最终答案：3.1415926 乘以 2.7182818 等于 8.53973422232268。
Agent: 3.1415926 乘以 2.7182818 等于 8.53973422232268。
关键观察 ：Agent识别出这是一个计算任务，自动选择了 calculator 工具，并正确地将自然语言问题解析成了工具调用参数 (a=3.1415926, b=2.7182818, operator='*') 。
测试场景2：无需工具的一般对话
您: 你好，请介绍一下你自己。
思考过程：
> 进入新的AgentExecutor链...
思考：用户让我自我介绍。这是一个简单的问候和介绍，不需要使用任何工具。我可以直接回答。
最终答案：你好！我是一个基于LangChain和ReAct框架构建的AI助手。我可以通过调用工具（比如计算器）来帮助你处理一些需要精确计算的任务。有什么我可以帮你的吗？
Agent: 你好！我是一个基于LangChain和ReAct框架构建的AI助手。我可以通过调用工具（比如计算器）来帮助你处理一些需要精确计算的任务。有什么我可以帮你的吗？
关键观察 ：Agent正确判断出这个问题不需要调用工具，直接利用LLM的知识生成了回答。这体现了ReAct机制的智能性—— 按需调用工具 ，而非盲目调用。
测试场景3：多轮对话（依赖记忆）
您: 我们刚才计算的结果是多少？
思考过程（假设紧接着场景1的对话）：
> 进入新的AgentExecutor链...
思考：用户问“刚才计算的结果”。我需要查看聊天历史来理解上下文。从历史记录看，我们刚才计算了3.1415926 * 2.7182818，结果是8.53973422232268。这个问题不需要使用工具。
最终答案：刚才我们计算了3.1415926乘以2.7182818，结果是8.53973422232268。
Agent: 刚才我们计算了3.1415926乘以2.7182818，结果是8.53973422232268。
关键观察 ： ConversationBufferMemory 发挥了作用，Agent能够访问之前的对话历史，从而理解“刚才”的指代，给出准确的回答。
7. 扩展能力：集成更多工具
一个只有计算器的Agent显然不够强大。让我们为它添加一个“获取当前时间”的工具，模拟与外部世界的交互。
创建 src/tools/current_time.py ：
# src/tools/current_time.py
from langchain.tools import BaseTool
from datetime import datetime
from typing import Optional, Type
from pydantic import BaseModel, Field
class CurrentTimeInput(BaseModel):
"""获取当前时间的输入参数（本例中无需参数，但结构保留）。"""
timezone: Optional[str] = Field(default="Asia/Shanghai", description="时区，例如'Asia/Shanghai', 'UTC'")
class CurrentTimeTool(BaseTool):
"""一个获取当前日期和时间的工具。"""
name = "get_current_time"
description = """
当用户询问当前时间、今天日期或类似关于时间的问题时使用此工具。
此工具返回系统的当前日期和时间。
可以指定时区，默认为'Asia/Shanghai'。
"""
args_schema: Optional[Type[BaseModel]] = CurrentTimeInput
def _run(self, timezone: str = "Asia/Shanghai") -> str:
"""获取指定时区的当前时间。"""
try:
# 这是一个简化版，实际应用中应使用pytz或zoneinfo处理时区
# 这里仅作演示
now_utc = datetime.utcnow()
if timezone == "Asia/Shanghai":
# 模拟UTC+8
now_local = now_utc.replace(hour=now_utc.hour+8)
else:
now_local = now_utc
return f"当前时间（{timezone}）: {now_local.strftime('%Y-%m-%d %H:%M:%S')}"
except Exception as e:
return f"获取时间失败: {str(e)}"
async def _arun(self, timezone: str = "Asia/Shanghai") -> str:
return self._run(timezone)
修改 src/agents/react_agent.py 中的工具列表：
# 在 build_react_agent 函数中，修改工具准备部分
from src.tools.calculator import CalculatorTool
from src.tools.current_time import CurrentTimeTool # 新增导入
def build_react_agent():
# ... 前面的代码不变 ...
# 2. 准备工具集 (现在有两个工具了！)
tools = [CalculatorTool(), CurrentTimeTool()] # 修改这行
# ... 后面的代码不变 ...
重启Agent并进行测试：
您: 现在几点了？
思考过程：
> 进入新的AgentExecutor链...
思考：用户询问当前时间。我有一个获取当前时间的工具。
行动：调用 get_current_time 工具。
行动输入：{"timezone": "Asia/Shanghai"}
观察：当前时间（Asia/Shanghai）: 2024-05-27 14:30:15
思考：我已经得到了当前时间，可以回答用户了。
最终答案：现在是北京时间2024年5月27日下午2点30分15秒。
Agent: 现在是北京时间2024年5月27日下午2点30分15秒。
现在，你的Agent已经具备了两种不同的能力。通过这种方式，你可以不断集成新的工具，如：
- 网络搜索工具 ：查询实时信息。
- 数据库查询工具 ：访问内部业务数据。
- 代码执行工具 ：运行Python代码片段。
- 文件操作工具 ：读写本地文件。
- API调用工具 ：与任何外部服务通信。
8. 核心机制深度解析：LangChain Agent如何工作？
通过上面的实践，我们已经看到了Agent的运行效果。现在，让我们深入LangChain内部，理解其工作机制。下图展示了LangChain Agent的核心工作流程：
用户输入
│
▼
[ AgentExecutor ]
│
▼
[ 格式化输入 ] (结合用户输入、工具描述、对话历史)
│
▼
[ LLM调用 ] (生成包含Thought/Action的文本)
│
▼
[ 输出解析器 ] (解析LLM输出为AgentAction或AgentFinish)
│
├───────────── 如果是 AgentFinish ──────────────┐
│ ▼
│ [ 返回最终答案 ]
│ │
│ ▼
│ 用户收到回复
│
▼
[ 提取工具名和参数 ]
│
▼
[ 调用对应工具 ]
│
▼
[ 获取观察结果 ]
│
▼
[ 将观察加入历史 ]
│
└─────────────────────────────────────────────┘
循环
关键组件详解：
-
提示词模板的魔力 ：ReAct提示词模板通常包含以下部分：
你是一个有帮助的助手，可以使用以下工具： {tool_descriptions} 使用格式： 思考：你需要思考现在要做什么 行动：要调用的工具名 行动输入：工具的输入 观察：工具返回的结果 ... (这个循环可以重复多次) 最终答案：给用户的最终回复 开始！ 之前的对话： {chat_history} 用户：{input} {agent_scratchpad}{tool_descriptions}: 被替换为所有工具的详细描述。{chat_history}: 被替换为之前的对话记录。{agent_scratchpad}: 这是一个特殊变量，在运行过程中，它会动态填充之前步骤的“思考-行动-观察”记录，让LLM知道已经发生了什么。
-
输出解析器（Output Parser） ：LLM生成的是文本（如“思考：... 行动：calculator ...”），
ReActSingleInputOutputParser负责将这段文本解析成结构化的AgentAction对象（包含tool和tool_input）或AgentFinish对象（包含最终答案）。 -
工具调用与观察 ：
AgentExecutor根据解析出的AgentAction，找到对应的工具实例，传入参数并执行。工具的返回结果被包装成Observation，然后和之前的记录一起，被格式化成新的agent_scratchpad，送入下一轮LLM调用。
这个循环会一直持续，直到LLM输出“最终答案：”开头的文本，被解析器识别为 AgentFinish ，循环结束。
9. 常见问题与排查指南
在开发AI Agent的过程中，你一定会遇到各种问题。以下是几个最常见的问题及其解决方案：
9.1 Agent不调用工具，直接胡编乱造
现象 ：对于明显应该使用工具的问题（如计算、查询时间），Agent直接用LLM的知识生成一个可能错误的答案。 可能原因及解决方案 ：
- 工具描述不清晰 ：检查工具的
description字段。描述必须清晰、无歧义，明确指出工具的用途和适用场景。例如，“用于数学计算”比“一个工具”要好得多。 - 提示词模板不匹配 ：确保你使用的提示词模板（如
hwchase17/react）是专为ReAct Agent设计的。错误的模板可能无法引导LLM正确格式化输出。 - LLM温度（Temperature）过高 ：在工具调用场景下，建议将
temperature设为0或接近0的值，以减少输出的随机性，使Agent更稳定地遵循指令。 - 工具描述过长或过短 ：描述需要精炼且包含关键词。可以进行A/B测试，调整描述看效果。
9.2 Agent陷入死循环或达到最大迭代次数
现象 ：Agent反复调用同一个工具，或者在不同工具间来回切换，始终无法输出最终答案。 可能原因及解决方案 ：
- 工具返回结果格式不佳 ：工具返回的观察（Observation）应该是清晰、简洁的文本。如果返回了过于复杂或混乱的JSON/HTML，LLM可能无法理解，导致决策错误。确保工具输出是纯文本且信息明确。
- 任务过于复杂或定义不清 ：LLM可能无法规划出清晰的解决路径。尝试将用户问题拆解得更简单，或者为复杂任务设计专门的“规划工具”。
- 调整
max_iterations和early_stopping_method：可以适当增加max_iterations（例如到15），或尝试不同的停止方法。 - 在提示词中加强指令 ：在系统提示词中明确加入“如果你认为已经得到足够信息来回答问题，请输出‘最终答案：’”之类的指令。
9.3 解析错误： Parsing LLM output produced both final answer and actions
现象 ：控制台报错，提示无法解析LLM的输出。 可能原因及解决方案 ：
- LLM输出格式不符合预期 ：ReAct要求严格的“思考：... 行动：... 行动输入：...”格式。有时LLM会自由发挥。确保提示词模板正确，并考虑使用能力更强的模型（如GPT-4）。
- 启用
handle_parsing_errors=True：正如我们在代码中做的，这个参数能让AgentExecutor在解析失败时尝试修复或给出友好错误，而不是直接崩溃。
9.4 如何调试Agent的思考过程？
最佳实践 ：
- 设置
verbose=True：这是最重要的调试手段，所有中间步骤一览无余。 - 记录日志 ：将Agent的运行日志（包括思考、行动、观察）保存到文件，便于离线分析。
- 使用LangSmith ：如果你有LangChain的商业版LangSmith，它提供了强大的Agent跟踪和可视化调试工具。
10. 工程实践与进阶建议
当你掌握了基础构建方法后，以下建议可以帮助你将AI Agent应用到实际项目中：
10.1 工具设计原则
- 单一职责 ：每个工具只做一件事，并把它做好。避免创建“瑞士军刀”式的工具。
- 清晰的输入输出 ：使用Pydantic模型严格定义输入，输出应为结构化的字符串。
- 健壮的错误处理 ：工具内部必须处理异常，并返回对人类和LLM都友好的错误信息。
- 添加语义描述 ：在
description中尽可能使用自然语言描述工具能解决哪类“用户问题”，而不仅仅是技术功能。
10.2 提示词工程优化
- Few-Shot示例 ：在提示词中加入几个工具调用的完整示例（Thought/Action/Observation循环），能显著提升Agent的格式遵循能力和决策质量。
- 系统角色设定 ：在提示词开头明确Agent的角色和能力边界，例如“你是一个专业的数学和查询助手，擅长使用工具来获取精确信息。”
- 约束指令 ：明确告诉Agent什么不能做，例如“不要猜测信息，如果不知道或需要最新数据，请使用搜索工具。”
10.3 生产环境部署考量
- 超时与重试 ：为工具调用和LLM调用设置合理的超时和重试机制。
- 限流与降级 ：对LLM API和关键工具进行限流，防止过度调用。在工具失败时，有降级方案（如返回缓存数据或友好提示）。
- 可观测性 ：记录每一次Agent运行的完整轨迹（包括工具调用、耗时、结果），这对于监控、审计和优化至关重要。
- 安全性 ：
- 工具权限隔离 ：危险操作（如文件删除、数据库写入）的工具需要更严格的权限控制和用户确认。
- 输入验证与清理 ：对所有用户输入和工具输入进行严格的验证和清理，防止注入攻击。
- 敏感信息过滤 ：在日志和观察结果中过滤掉API密钥、个人信息等敏感数据。
10.4 探索更强大的Agent类型
LangChain提供了多种Agent类型，适用于不同场景：
-
create_react_agent：标准ReAct，适合大多数需要推理和工具调用的场景。 -
create_structured_chat_agent：使用聊天模型，支持更复杂的多工具调用和参数结构，是当前的主流推荐。 -
create_json_agent：要求LLM输出JSON格式的动作，解析更稳定。 -
create_openai_tools_agent：专为OpenAI的Function Calling功能优化，兼容性最好。
你可以根据需求尝试不同的Agent类型，观察其表现差异。
从理解ReAct的核心思想，到用LangChain构建第一个能调用工具的AI Agent，我们完成了一次从理论到实践的完整穿越。关键在于，AI Agent不是魔法，而是一套设计良好的系统，它将LLM的推理能力与外部工具的执行能力通过ReAct这样的机制有机结合。
真正的挑战往往在后续：如何设计更智能的工具？如何优化提示词以提升稳定性？如何将多个Agent组合成复杂的工作流？这些问题，就留待你在具体的项目中去探索和解决了。
更多推荐
12
0- 0
已为社区贡献6条内容
所有评论(0)