LangChain实战快速入门笔记（六）--LangChain使用之Agent

Jack___Xue2025-12-17 22:02

LangChain实战快速入门笔记（六）--LangChain使用之Agent

文章目录

一、理解Agents

通用人工智能（AGI）将是AI的终极形态，几乎已成为业界共识。同样，构建智能体（Agent）则是AI工程应用当下的"终极形态"。

将 AI 和人类协作的程度类比自动驾驶的不同阶段：

1. Agent与Chain的区别

在Chain中行动序列是 硬编码的、固定流程的 ，像是"线性流水线"，而Agent则采用语言模型作为 推理引擎，具备一定的自主决策能力，来确定以什么样的顺序采取什么样的行动，像是"拥有大脑的机器工人"。

它可以根据任务 动态决定 ：

• 如何拆解任务

• 需要调用哪些工具

• 以什么顺序调用

• 如何利用好中间结果推进任务

2. 什么是Agent

Agent（智能体） 是一个通过动态协调 **大语言模型（LLM）**和 工具（Tools） 来完成复杂任务的智能系统。它让LLM充当"决策大脑"，根据用户输入自主选择和执行工具（如搜索、计算、数据库查询等），最终生成精准的响应。

3. Agent的核心能力/组件

作为一个智能体，需要具备以下核心能力：

1）大模型(LLM) ：作为大脑，提供推理、规划和知识理解能力。

• 比如：OpenaAI()、ChatOpenAI()

2）记忆(Memory) ：具备短期记忆（上下文）和长期记忆（向量存储），支持快速知识检索。

• 比如：ConversationBufferMemory、ConversationSummaryMemory、ConversationBufferWindowMemory等

3）工具(Tools) ：调用外部工具（如API、数据库）的执行单元

• 比如：SearchTool、CalculatorTool

4）规划(Planning)：任务分解、反思与自省框架实现复杂任务处理

5）行动(Action) ：实际执行决策的能力

• 比如：检索、推理、编程

6）协作：通过与其他智能体交互合作，完成更复杂的任务目标。

🤖问题：为什么要调用第三方工具（比如：搜索引擎或者 数据库）或借助第三方库呢？

因为大模型虽然非常强大，但是也具备一定的局限性。比如不能回答实时信息 、处理复杂数学逻辑问题仍然非常初级等等。因此，可以借助第三方工具来辅助大模型的应用。

以MCP工具为例说明：https://bailian.console.aliyun.com/?tab=mcp#/mcp-market

我们期待它不仅仅是执⾏任务的⼯具，而是⼀个能够思考、⾃主分析需求、拆解任务并逐步实现⽬标的智能实体。这种形态的智能体才更接近于⼈⼯智能的终极⽬标------AGI（通⽤⼈⼯智能），它能让类似于托尼·斯塔克的贾维斯那样的智能助⼿成为现实，服务于每个⼈。

4. 举例

举例1：[扣子平台][https://www.coze.cn/home\] 智能体演示

举例2：Manus、纳米AI 使用演示

5. 明确几个组件

Agents 模块有几个关键组件：

5.1 工具 Tool

LangChain 提供了广泛的入门工具，但也支持自定义工具 ，包括自定义描述。

在框架内，每个功能或函数被封装成一个工具（Tools），具有自己的输入、输出及处理方法。

具体使用步骤：

① Agent 接收任务后，通过大模型推理选择适合的工具处理任务。

② 一旦选定，LangChain将任务输入传递给该工具，工具处理输入生成输出。

③ 输出经过大模型推理，可用于其他工具的输入或作为最终结果返回给用户。

5.2 工具集 Toolkits

在构建Agent时，通常提供给LLM的工具不仅仅只有一两个，而是一组可供选择的工具集(Tool列表)，这样可以让 LLM 在完成任务时有更多的选择。

5.3 智能体/代理 Agent

智能体/代理（agent）可以协助我们做出决策，调用相应的 API。底层的实现方式是通过 LLM 来决定下一步执行什么动作。

5.4 代理执行器 AgentExecutor

AgentExecutor本质上是代理的运行时，负责协调智能体的决策和实际的工具执行。

AgentExecutor是⼀个很好的起点，但是当你开始拥有更多定制化的代理时，它就不够灵活了。

❗为了解决这个问题，我们构建了LangGraph，使其成为这种灵活、⾼度可控的运⾏时。

二、Agent 入门使用

1. Agent、AgentExecutor的创建

注意：这里的传统-通用非官方定义，为便于理解的个人定义版本。

2. Agent的类型

顾名思义就是某件事可以由不同的⼈去完成，最终结果可能是⼀样的，但是做的过程可能各有千秋。⽐如⼀个公司需求，普通开发 可以编写，技术经理 也可以编写，CTO也可以编写。虽然都能完成最后的需求，但是CTO做的过程可能更加直观，⾼效。

在LangChain中Agent的类型就是为你提供不同的"问题解决姿势"的。

API说明:https://python.langchain.com/v0.1/docs/modules/agents/agent_types/

Agents的核心类型有两种模式 ：

• 方式1：Funcation Call模式

• 方式2：ReAct 模式

2.1 FUNCATION_CALL模式

• 基于结构化函数调用 （如 OpenAI Function Calling）

• 直接生成工具调用参数（JSON 格式 ）

• 效率更高，适合工具明确的场景

典型 AgentType：

#第1种：

AgentType.OPENAI_FUNCTIONS

#第2种：

AgentType.OPENAI_MULTI_FUNCTIONS

工作流程示例 ：

2.2 ReAct 模式

• 基于 文本推理 的链式思考（Reasoning + Acting），具备反思和自我纠错能力。

❀ 推理（Reasoning）：分析当前状态，决定下一步行动

❀ 行动（Acting）：调用工具并返回结果

• 通过自然语言描述决策过程

• 适合需要明确推理步骤的场景。例如智能客服、问答系统、任务执行等。

典型 AgentType：

python 复制代码 
#第1种: 零样本推理(可以在没有预先训练的情况下尝试解决新的问题)
AgentType.ZERO_SHOT_REACT_DESCRIPTION

#第2种: 无记忆对话
AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION

#第3种: 带记忆对话
AgentType.CONVERSATIONAL_REACT_DESCRIPTION

工作流程示例：

① 问题：我想要查询xxx

② 思考：我需要先搜索最新信息 → 行动：调用Search工具 → 观察：获得3个结果 →

③ 思考：需要抓取第一个链接 → 行动：调用scrape_website工具...→ 观察：获得工具结果

④ 最后：获取结果

Agent两种典型类型对比表

3. AgentExecutor创建方式

传统方式：initialize_agent()

• 特点 ：

❀内置一些标准化模板（如ZERO_SHOT_REACT_DESCRIPTION）

❀Agent的创建：使用AgentType

• 优点 ：快速上手（3行代码完成配置）

• 缺点：定制化能力较弱（如提示词固定）

======================================================

代码片段：

python 复制代码 
from langchain.agents import initialize_agent

#第1步: 创建AgentExecutor
agent_executor = initialize_agent(
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    tools=[search_tool],
    verbose=True
)

#第2步: 执行
agent_executor.invoke({"input": "xxxx"})

通用方式：AgentExecutor构造方法

• 特点：

❀ Agent的创建：使用create_xxx_agent

• 优点：

❀ 可自定义提示词（如从远程hub获取或本地自定义）

❀ 清晰分离Agent逻辑与执行逻辑

• 缺点：

❀ 需要更多代码

❀ 需理解底层组件关系

• 代码片段：

python 复制代码 
from langchain import hub

prompt = hub.pull("hwchase17/react")
tools = [search_tool]

#第1步: 创建Agent实例
agent = create_react_agent(
    llm=llm,
    prompt=prompt,
    tools=tools
)

#第2步: 创建AgentExecutor实例
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools
)

#第3步: 执行
agent_executor.invoke({"input": "xxxx"})

4. 小结创建方式

三、 Agent中工具的使用

1. 传统方式

案例1：单工具使用

• 需求：今天北京的天气怎么样?

• 使用Tavily搜索工具

❀ Tavily的搜索API是一个专门为人工智能Agent(或LLM)构建的搜索引擎，可以快速提供实时、准确和真实的结果。

❀ LangChain 中有一个内置工具，可以轻松使用 Tavily 搜索引擎作为工具。

❀ TAVILY_API_KEY申请：https://tavily.com/，注册账号并登录，创建 API 密钥。

方式1：ReAct模式

• AgentType是 ZERO_SHOT_REACT_DESCRIPTION

python 复制代码 
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool
import os
import dotenv
from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search import TavilySearchResults

# 1. 设置API密钥
os.environ["TAVILY_API_KEY"] = "tvy-dev-T9zUN2xmIw6XluXnH2IXbYFZ12YD"

# 2. 初始化搜索工具
search = TavilySearchResults(max_results=3)  # max_results --只用三条搜索结果

# 3. 创建Tool的实例（本步骤可以考虑省略，直接使用search替换search_tool，但建议加上
search_tool = Tool(
    name="Search",
    func=search.run,
    description="用于搜索互联网上的信息"
)

# 4. 初始化LLM
dotenv.load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["OPENAI_BASE_URL"] = os.getenv("OPENAI_BASE_URL")
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
)

# 5. 创建AgentExecutor
agent_executor = initialize_agent(
    tools=[search_tool],
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# 5. 测试查询
query = "今天北京的天气怎么样？"
result = agent_executor.invoke(query)
print(f"查询结果: {result}")






拓展：上述程序中tool的设置也可以简化为：

python 复制代码 
# 初始化搜索工具
search = TavilySearchResults(max_results=3)

# 创建AgentExecutor
agent_executor = initialize_agent(
    tools=[search],
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)
方式2：FUNCATION_CALL模式

• AgentType是 OPENAI_FUNCTIONS

提示：只需要修改前面代码中的initialize_agent中的agent参数值。

python 复制代码 
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool
import os
import dotenv
from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search import TavilySearchResults

# 1. 设置API密钥
os.environ["TAVILY_API_KEY"] = "tvy-dev-T9zUN2xmIw6XluXnH2IXbYFZ12YD"

# 2. 初始化搜索工具
search = TavilySearchResults(max_results=3)

# 3. 创建Tool的实例
search_tool = Tool(
    name="Search",
    func=search.run,
    description="用于搜索互联网上的信息"
)

# 4. 初始化LLM
dotenv.load_dotenv()

os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["OPENAI_BASE_URL"] = os.getenv("OPENAI_BASE_URL")
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
)

# 5. 创建AgentExecutor
agent_executor = initialize_agent(
    tools=[search_tool],
    llm=llm,
    agent=AgentType.OPENAI_FUNCTIONS,  #唯一变化
    verbose=True
)

# 5. 测试查询
query = "今天北京的天气怎么样？"
result = agent_executor.invoke(query)
print(f"查询结果: {result}")



二者对比：ZERO_SHOT_REACT_DESCRIPTION和OPENAI_FUNCTIONS

案例2：多工具使用

• 需求：

❀ 计算特斯拉当前股价是多少？

❀ 比去年上涨了百分之几？（提示：调用PythonREPL实例的run方法）

• 多个（两个）工具的选择

方式1：ReAct 模式

• AgentType是 ZERO_SHOT_REACT_DESCRIPTION

python 复制代码 
# 1.导入相关依赖
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_experimental.utilities.python import PythonREPL

# 2.设置 TAVILY_API 密钥
os.environ["TAVILY_API_KEY"] = "tvy-dev-T9zUN2xmIw6XluXnH2IXbYFZ12YD" #需要替换为你的Tavily API密钥

# 3.定义搜索工具
search = TavilySearchResults(max_results=3)
search_tool = Tool(
    name="Search",
    func=search.run,
    description="用于搜索互联网上的信息，特别是股票价格和新闻"
)

# 4.定义计算工具
python_repl = PythonREPL() # LangChain封装的工具类可以进行数学计算
calc_tool = Tool(
    name="Calculator",
    func=python_repl.run,
    description="用于执行数学计算，例如计算百分比变化"
)

# 5.定义LLM
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
)

# 6.创建AgentExecutor执行对象
agent_executor = initialize_agent(
    tools=[search_tool, calc_tool],
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# 7.测试股票价格查询
query = "特斯拉当前股价是多少？比去年上涨了百分之几？"
result=agent_executor.invoke(query)
print(f"查询结果: {result}")



注意：可能会失败（查询超时）。

方式2：FUNCATION_CALL模式

• AgentType是 FUNCATION_CALL

python 复制代码 
# 1.导入相关依赖
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_experimental.utilities.python import PythonREPL

# 2.设置 TAVILY_API 密钥
os.environ["TAVILY_API_KEY"] = "tvy-dev-T9zUN2xmIw6XluXnH2IXbYFZ12YD" #需要替换为你的Tavily API密钥

# 3.定义搜索工具
search = TavilySearchResults(max_results=3)
search_tool = Tool(
    name="Search",
    func=search.run,
    description="用于搜索互联网上的信息，特别是股票价格和新闻"
)

# 4.定义计算工具
python_repl = PythonREPL() # LangChain封装的工具类可以进行数学计算
calc_tool = Tool(
    name="Calculator",
    func=python_repl.run,
    description="用于执行数学计算，例如计算百分比变化"
)

# 5.定义LLM
llm = ChatOpenAI(
    model="gpt-4",
    temperature=0,
)

# 6.创建AgentExecutor执行对象
agent_executor = initialize_agent(
    tools=[search_tool, calc_tool],
    llm=llm,
    agent=AgentType.OPENAI_FUNCTIONS, #唯一变化的位置
    verbose=True
)

# 7.测试股票价格查询
query = "特斯拉当前股价是多少？比去年上涨了百分之几？"
result=agent_executor.invoke(query)
print(f"查询结果: {result}")









注意：也有可能输出失败，但是机会小。

案例3：自定义函数与工具

需求：计算3的平方，Agent自动调用工具完成

python 复制代码 
from langchain.agents import initialize_agent, AgentType, Tool
from langchain_openai import ChatOpenAI
import langchain

# 1.定义工具 - 计算器（要求字符串输入）
def simple_calculator(expression: str) -> str:
    """
    基础数学计算工具，支持加减乘除和幂运算
    参数:
        expression: 数学表达式字符串，如 "3+5" 或 "2**3"
    返回:
        计算结果字符串或错误信息
    """
    print(f"[√]工具调用 计算表达式: {expression}")
    print("只因为在人群中多看了你一眼，确认下你调用了我^_^")
    return str(eval(expression))

# 2.创建工具对象
math_calculator_tool = Tool(
    name="Math_Calculator",  # 工具名称（Agent将根据名称选择工具）
    func=simple_calculator,  # 工具调用的函数
    description="用于数学计算，输入必须是纯数学表达式（如3+5或3**2表示平方）。不支持字母或特殊符号"  # 关键：明确输入格式要求
)

# 3.初始化大模型
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
)

# 4.初始化AgentExecutor（使用零样本React模式，增加即时设置）
agent_executor = initialize_agent(
    tools=[math_calculator_tool],  # 可用的工具列表
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,  # 简单指令模式
    verbose=True  # 关键参数！在控制台显示详细的推理过程
)

# 5.测试工具调用（添加异常捕获）
print("=== 测试，正常工具调用 ===")
response = agent_executor.invoke("计算3的平方")  # 向Agent提问
print("最终答案:", response)

2. 通用方式

需求：今天北京的天气怎么样？？

方式1：FUNCATION_CALL模式

python 复制代码 
# 1.导入相关包
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.prompts import ChatPromptTemplate
import os
from langchain_openai import ChatOpenAI

# 2.定义搜索化工具
# ① 设置TAVILY API密钥
os.environ["TAVILY_API_KEY"] = "tvy-dev-yBbK0KLV3RpGcvBXsqRelBcdMnlZR" # 需要替换为你的Tavily API密钥
# ② 定义搜索工具
search = TavilySearchResults(max_results=1)

# 3.自定义提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "您是一位乐于助人的助手, 请务必使用 tavily_search_results_json 工具来获取信息。"),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

# 4.定义LLM
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
)

# 5.创建Agent对象
agent = create_tool_calling_agent(
    llm = llm,
    tools = [search],
    prompt = prompt
)

# 6.创建AgentExecutor执行器
agent_executor = AgentExecutor(agent=agent, tools=[search], verbose=True)

# 7.测试
agent_executor.invoke({"input": "今天北京的天气怎么样？"})

注意：

定义：agent_scratchpad必须声明，它用于存储和传递Agent的思考过程。比如，在调用链式工具时（如先搜索天气再推荐行程），

作用：agent_scratchpad 保留所有历史步骤，避免上下文丢失。format方法会将intermediate_steps转换为特定格式的字符串，并赋值给agent_scratchpad变量。如果不传递 intermediate_steps参数，会导致KeyError: 'intermediate_steps'错误。

方式2：ReAct模式

体会1：使用PromptTemplate

提示词要体现可以使用的工具、用户输入和agent_scratchpad。

远程的提示词模版通过https://smith.langchain.com/hub/hwchase17获取

• 举例：https://smith.langchain.com/hub/hwchase17/react，这个模板是专为ReAct模式设计的提示模板。这个模板中已经有聊天对话键 tools 、tool_names 、agent_scratchpad

方式1：
python 复制代码 
# 1.导入相关包
from langchain.agents import AgentExecutor, create_react_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.prompts import PromptTemplate

# 2.定义搜索化工具
tools = [TavilySearchResults(max_results=1, tavily_api_key="tvy-dev-T9zUN2xmIw6XluXnH2IXbYFZ12Yd")]

# 3.自定义提示词模板
template = """Answer the following questions as best you can. You have access to the following tools:
{tools}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: {input}
Thought:{agent_scratchpad}"""

# template1 = """
# 请尽可能准确地回答以下问题, 您可以使用以下工具: {tools}
# 请您使用以下格式:
# 问题: 您必须回答的输入问题
# 思考: 您应该始终思考要做什么
# 行动: 要采取的行动, 应为 [{tool_names}] 中的一个
# 行动输入: 行动的输入
# 观察: 行动的结果
# ...... (此思考/行动/行动输入/观察可重复 N 次)
# 思考: 我现在知道最终答案了
# 最终答案: 对原始输入问题的最终答案
# 开始!
# 问题: {question}
# 思考: {agent_scratchpad}
# ""

prompt = PromptTemplate.from_template(template)

# 4.定义LLM
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
)

# 5.创建Agent对象
agent = create_react_agent(llm, tools, prompt)

# 6.创建AgentExecutor执行器
agent_executor = AgentExecutor(agent=agent, tools=tools,
verbose=True,handle_parsing_errors=True)

# 7.测试
agent_executor.invoke({"input": "今天北京的天气怎么样？"})


方式2：
python 复制代码 
# 1.导入相关包
from langchain.agents import AgentExecutor, create_react_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.prompts import PromptTemplate
from langchain import hub
from langchain_openai import ChatOpenAI

# 2.定义搜索化工具
tools = [TavilySearchResults(max_results=1,tavily_api_key="tvy-dev-T9zUN2xmIw6XluXnH2IXbYFZ12Yd")]

# 3.使用LangChain Hub中的官方ReAct提示模板 直接调用网址上的提示词，换一种方式而已
prompt = hub.pull("hwchase17/react")

# 4.定义LLM
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
)

# 5.创建Agent对象
agent = create_react_agent(llm, tools, prompt)

# 6.创建AgentExecutor执行器
agent_executor = AgentExecutor(agent=agent, tools=tools,
verbose=True,handle_parsing_errors=True)

# 7.测试
agent_executor.invoke({"input": "今天北京的天气怎么样？"})
体会2：使用ChatPromptTemplate

提示词中需要体现使用的工具、用户输入和agent_scratchpad。

python 复制代码 
from langchain.agents import create_react_agent
from langchain_core.prompts import ChatPromptTemplate

# 获取Tavily搜索的实例
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, AgentType, create_tool_calling_agent, AgentExecutor
from langchain.tools import Tool
import os
import dotenv
from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search import TavilySearchResults
dotenv.load_dotenv()

# 读取配置文件的信息
os.environ["TAVILY_API_KEY"] = "tvy-dev-Yvg0XmzpzBueEMnXV3KGuNvQxkKW2"

# 获取Tavily搜索工具的实例
search = TavilySearchResults(max_results=3)

# 获取一个搜索的工具
searchTool = Tool(
    func=search.run,
    name="Search",
    description="用于检索互联网上的信息，尤其是天气情况"
)

# 获取大语言模型
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["OPENAI_BASE_URL"] = os.getenv("OPENAI_BASE_URL")
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
)

# 提供提示词模板（以ChatPromptTemplate为例）
# prompt_template = ChatPromptTemplate.from_messages([
#     ("system", "你是一个人工智能的助手, 在用户提出需求以后, 必须要调用Search工具进行联网搜索。"),
#     ("system", "这是你可以使用的工具列表{tools}, 每次Action时调用{tool_names}, 并根据工具输出的网络结果回答用户的问题。"),
#     ("system", """工具调用格式（必须严格遵守）:
# Thought: 分析需要做什么（例如: 需要查询明天北京的天气）
# Action: 工具名称（只能是{tool_names}中的一个）
# Action Input: 工具的输入内容（例如: 北京明天天气）
# 若工具返回内容:
# Observation: 工具返回的结果
# 当我知道了足够的信息之后就说明输出:
# Thought: 我知道答案了
# FinalAnswer: 经过整理后的最终答案！"""),
#     ("system", "{agent_scratchpad}"),
#     ("human", "我的问题是: {question}"),
# ])

prompt_template = ChatPromptTemplate.from_messages([
    ("system", "你是一个人工智能的助手, 在用户提出需求以后, 必须要调用Search工具进行联网搜索。"),
    ("system", """Answer the following questions as best you can. You have access to the following tools:
{tools}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!
执行过程建议使用中文
"""),
    ("system", "当前思考: {agent_scratchpad}"), # 必须在提示词模板中提供agent_scratchpad参数。
    ("human", "我的问题是: {question}"),
])

# 获取Agent的实例: create_tool_calling_agent()
agent = create_react_agent(
llm=llm,
prompt=prompt_template,
tools=[searchTool]
)

# 获取AgentExecutor的实例
agent_executor = AgentExecutor(
agent=agent,
tools=[searchTool],
verbose=True,
handle_parsing_errors=True,
max_iterations=6 # 可选: 限制最大迭代次数, 防止无限循环
)

# 通过AgentExecutor的实例调用invoke()得到响应
result = agent_executor.invoke({"question": "查询今天北京的天气情况"})
# 处理响应
print(result)

执行结果：

上述执行可能会报错。

错误原因:

• 使用 ReAct 模式时，要求 LLM 的响应必须遵循严格的格式（如包含 Thought:、Action: 等标记）。

• 但 LLM 直接返回了自由文本（非结构化），导致解析器无法识别。

修改:

• 任务不变，添加 handle_parsing_errors=True。用于控制 Agent 在解析工具调用或输出时发生错误的容错行为。

handle_parsing_errors=True 的作用

• 自动捕获错误并修复：当解析失败时，Agent 不会直接崩溃，而是将错误信息传递给 LLM，让 LLM 自行修正并重试 。

• 降级处理：如果重试后仍失败，Agent 会返回一个友好的错误消息（如 "I couldn't process that request."），而不是抛出异常。

小结：

小结:

1、传统方式，相较于通用方式来讲，不用提供提示词模板。

2、对于通用方式来讲，FUNCTION_CALL 模式：在创建 Agent 时，推荐大家使用 ChatPromptTemplateReAct 模式：在创建 Agent 时，大家可以使用ChatPromptTemplate、PromptTemplate。但相较来讲，推荐大家使用 PromptTemplate

四、Agent嵌入记忆组件

1. 传统方式

比如：北京明天的天气怎么样？上海呢？ （通过两次对话实现）

举例：以REACT模式为例

python 复制代码 
# 1. 导入依赖包
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, AgentType
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.memory import ConversationBufferMemory
import os
import dotenv

dotenv.load_dotenv()

# 2. 设置API密钥
os.environ["TAVILY_API_KEY"] = "tvy-dev-T9zUN2xmIw6XluXnH2IXbYFZf12Yd"

# 3. 定义搜索工具
search_tool = TavilySearchResults(max_results=2)

# 4. 定义LLM
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY1")
os.environ["OPENAI_BASE_URL"] = os.getenv("OPENAI_BASE_URL")
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0
)

# 5. 定义记忆组件(以ConversationBufferMemory为例)
memory = ConversationBufferMemory(
    memory_key="chat_history", # 必须是此值, 通过initialize_agent()的源码追踪得到
    return_messages=True
)

# 6. 创建AgentExecutor
agent_executor = initialize_agent(
    tools=[search_tool],
    llm=llm,
    agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memory, #在AgentExecutor中声明
    verbose=True
)

# 7. 测试对话
# 第一个查询
query1 = "北京明天的天气怎么样？"
result1 = agent_executor.invoke(query1)
print(f"查询结果: {result1}")

# print("\n=== 继续对话 ===")
query2 = "上海呢"
result2 = agent_executor.invoke(query2)
print(f"分析结果: {result2}")

上述执行可能会报错。

错误原因:

• 使用 ReAct 模式时，要求 LLM 的响应必须遵循严格的格式（如包含 Thought:、Action: 等标记）。

• 但 LLM 直接返回了自由文本（非结构化），导致解析器无法识别。

修改:

• 任务不变，添加 handle_parsing_errors=True。用于控制 Agent 在解析工具调用或输出时发生错误的容错行为。

handle_parsing_errors=True 的作用

• 自动捕获错误并修复：当解析失败时，Agent 不会直接崩溃，而是将错误信息传递给 LLM，让 LLM 自行修正并重试。

• 降级处理：如果重试后仍失败，Agent 会返回一个友好的错误消息（如 "I couldn't process that request."），而不是抛出异常。

小结：

代码修改为：

python 复制代码 
# 1. 导入依赖包
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_experimental.utilities.python import PythonREPL
from langchain.memory import ConversationBufferMemory

# 2. 设置API密钥
os.environ["TAVILY_API_KEY"] = "tvy-dev-T9zUN2xmIw6XluXnH2IXbYFZf12Yd"

# 3. 定义搜索工具
search_tool = TavilySearchResults(max_results=2)

# 5. 定义LLM
llm = ChatOpenAI(
    model="gpt-4",
    temperature=0
)

# 6. 定义记忆组件(以ConversationBufferMemory为例)
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# 7. 创建AgentExecutor
agent_executor = initialize_agent(
    tools=[search_tool],
    llm=llm,
    agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
    memory=memory,
    handle_parsing_errors=True,
    verbose=True
)

# 8. 测试对话
# 第一个查询
query1 = "北京明天的天气怎么样？"
result1 = agent_executor.invoke(query1)
print(f"查询结果: {result1}")

# print("\n=== 继续对话 ===")
query2 = "上海呢"
result2=agent_executor.invoke(query2)
print(f"分析结果: {result2}")




再例：

2. 通用方式

通用方式，相较于传统方式，可以提供自定义的提示词模板

举例1：FUNCATION_CALL模式

如果使用的是FUNCTION_CALL方式，则创建Agent时，推荐使用ChatPromptTemplate

python 复制代码 
# 1. 导入依赖包
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, AgentType, create_tool_calling_agent
from langchain.tools import Tool
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_experimental.utilities.python import PythonREPL
from langchain.memory import ConversationBufferMemory
from langchain_core.prompts import ChatPromptTemplate
import os

# 2. 设置TAVILY API密钥
os.environ["TAVILY_API_KEY"] = "tvy-dev-T9zUN2xmIw6XluXnH2IXbYFZf12Yd"

# 3. 定义搜索工具
search = TavilySearchResults(max_results=2)
search_tool = Tool(
    name="Search",
    func=search.run,
    description="用于互联网信息的检索"
)
tools = [search_tool]
# 或者
search = TavilySearchResults(max_results=2)
tools = [search]

# 4. 定义LLM
llm = ChatOpenAI(
    model="gpt-4",
    temperature=0
)

# 5. 定义提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个聪明的助手，可以调用工具。"),
    ("human", "{input}"),
    # 思考: 如果想让Agent记住历史记录, 则需要将chat_history传入
    ("placeholder", "{agent_scratchpad}")
])

# 6. 定义记忆组件(以ConversationBufferMemory为例)
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# 7. 创建Agent
agent = create_tool_calling_agent(llm, tools, prompt)

# 8. 创建AgentExecutor执行器(注意: memory参数需写在AgentExecutor类中)
agent_executor = AgentExecutor(agent=agent,memory=memory, tools=tools,verbose=True)

# 9. 测试对话
# 第一个查询
result1 = agent_executor.invoke({"input": "北京的天气多少"})
print(f"查询结果: {result1}")

# print("\n=== 继续对话 ===")
result2=agent_executor.invoke({"input": "上海呢"})
print(f"分析结果: {result2}")






🤖拓展1：如果ChatPromptTemplate.from_messages()中没有提供("placeholder", "{chat_history}")这样操作，会怎样呢？

输出如下？

🤖拓展2：如果删除AgentExecutor构造方法中的memory参数，又会如何呢？

举例2：ReAct 模式

ReAct模式下，创建Agent时，可以使用ChatPromptTemplate、PromptTemplate

python 复制代码 
# 1.导入相关包
from langchain.agents import AgentExecutor, create_react_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_core.prompts import PromptTemplate
import os

# 2.定义搜索化工具
# ① 设置TAVILY API密钥
os.environ["TAVILY_API_KEY"] = "tvy-dev-T9zUN2xmIw6XluXnH2IXbYFZf12Yd" # 需要替换为你的Tavily API密钥
# ② 定义搜索工具
search = TavilySearchResults(max_results=1)
# ③ 设置工具集
tools = [search]

# 3.自定义提示词模板
template = ("Assistant is a large language model trained by OpenAI.\n"
    "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n"
    "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n"
    "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist!\n\n"
    "TOOLS:\n"
    "-----\n"
    "Assistant has access to the following tools:\n"
    "{tools}\n\n"
    "To use a tool, please use the following format:\n"
    "\n"
    "Thought: Do I need to use a tool? Yes\n"
    "Action: the action to take, should be one of [{tool_names}]\n"
    "Action Input: the input to the action\n"
    "Observation: the result of the action\n"
    "\n"
    "When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the format:\n"
    "\n"
    "Thought: Do I need to use a tool? No\n"
    "Final Answer: your response here\n"
    "\n\n"
    "Begin!\n\n"
    "Previous conversation history:\n"
    "{chat_history}\n\n"
    "New input: {input}\n"
    "{agent scratchpad}")
    
# template = '''助手是由 OpenAI 训练的一个大型语言模型。\n
# 助手是由 OpenAI 训练的一个大型语言模型。\n
# 助手旨在能够协助您完成各种各样的任务，从回答简单的问题到对各种主题进行深入的解释和讨论。作为语言模型，助手能够根据接收到的输入生成类似人类的文本，从而能够进行自然流畅的对话，并提供与当前主题相关且连贯的回答。\n
# 助手在不断学习和改进，其能力也在不断发展。它能够处理和理解大量的文本，并利用这些知识为各种问题提供准确且信息丰富的回答。此外，助手还能够根据接收到的输入生成自己的文本，从而能够参与讨论，并提供解释和描述。\n
# 总的来说，助手是一个强大的工具，能够帮助完成各种各样的任务，并在各种主题上提供有价值的见解和信息。无论您是需要解答某个具体问题，还是只是想就某个特定话题进行交流，助手都在这里为您提供帮助。\n\n
# 工具：\n-----
# {tools}\n
# 若要使用某个工具，请使用以下格式：\n
# '''
# 思考：我是否需要使用工具？是\n
# 行动：要采取的行动，应为 [{tool_names}] 中的一个\n
# 行动输入：行动的输入\n
# 观察：行动的结果\n
# '''\n\n
# 当您有回复要对人类说，或者不需要使用工具时，您必须使用以下格式：\n
# '''\n
# 思考：我是否需要使用工具？否\n
# 最终答案：您的回复\n
# '''\n
# 开始！\n
# 之前的对话历史：\n
#{chat_history}\n
# 新的输入: {input}
# {agent_scratchpad}
# 
# '''

prompt = PromptTemplate.from_template(template)

# 4.定义LLM
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
)

# 5. 定义记忆组件(以ConversationBufferMemory为例)
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# 6.创建Agent对象
agent = create_react_agent(llm, tools, prompt)

# 7.创建AgentExecutor执行器
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True,memory=memory)

# 8.测试
agent_executor.invoke({"input": "我的名字叫Bob"})
python 复制代码 
agent_executor.invoke({"input": "我的名字叫什么?"})


举例3：远程获取提示词模版

• 以通用方式create_xxx_agent的ReAct模式为例，FUNCATION_CALL一样

• 远程的提示词模版通过https://smith.langchain.com/hub/hwchase17获取

❀ 举例：https://smith.langchain.com/hub/hwchase17/react-chat，这个模板是专为聊天场景设计的ReAct提示模板。这个模板中已经有聊天对话键 chat_history、agent_scratchpad

python 复制代码 
# 1.导入相关依赖
from langchain_core.messages import AIMessage, HumanMessage
from langchain import hub
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain.memory import ConversationBufferMemory
import os

# 2.定义搜索工具
# ① 设置TAVILY_API密钥
os.environ["TAVILY_API_KEY"] = "tvy-dev-T9zUN2xmIw6XluXnH2IXbYFZf12Yd" # 需要替换为你的Tavily API密钥
# ② 定义搜索工具
search = TavilySearchResults(max_results=1)
# ③ 设置工具集
tools = [search]

# 3.获取提示词
prompt = hub.pull("hwchase17/react-chat")

# 4.定义LLM
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
)

# 5. 定义记忆组件(以ConversationBufferMemory为例)
memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# 6.创建Agent、AgentExecutor
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory, verbose=True)

# 7.执行
agent_executor.invoke({"input": "北京明天的天气怎么样？"})


python 复制代码 
agent_executor.invoke({"input": "上海的呢？"})


总结

记得关注么么哒

相关推荐
零度@2 小时前
SQL 调优全解：从 20 秒到 200 ms 的 6 步实战笔记（附脚本）
数据库·笔记·sql
im_AMBER3 小时前
Leetcode 78 识别数组中的最大异常值 | 镜像对之间最小绝对距离
笔记·学习·算法·leetcode
其美杰布-富贵-李3 小时前
HDF5文件学习笔记
数据结构·笔记·学习
CloudJourney4 小时前
从Unix到OpenEuler及其关键协议解析
服务器·unix
百年渔翁_肯肯4 小时前
Linux 与 Unix 的核心区别（清晰对比版）
linux·运维·unix
d111111111d5 小时前
在STM32函数指针是什么，怎么使用还有典型应用场景。
笔记·stm32·单片机·嵌入式硬件·学习·算法
静小谢5 小时前
前后台一起部署，vite配置笔记base\build
前端·javascript·笔记
ask_baidu5 小时前
Doris笔记
android·笔记
IMPYLH7 小时前
Lua 的 IO （输入/输出）模块
开发语言·笔记·后端·lua
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03Linux下V2Ray安装配置指南04【AutoGLM部署】本地私有化部署AI手机Agent05在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）06Open-AutoGLM Windows 安装部署教程07Cursor 又偷偷更新，这个功能太实用：Visual Editor for Cursor Browser08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09BongoCat - 跨平台键盘猫动画工具10Labelme从安装到标注：零基础完整指南