第六章: LangGraph的工具调用代理-Tool Calling Agent

2 阅读18分钟

LangGraph 的工具调用代理 - Tool Calling Agent

一、为什么需要 Tool Calling Agent

在 LangGraph 支持的代理架构中,路由代理(Router Agent)是基础形态:它通过 add_conditional_edges 搭配 Router Function,让大模型借助"结构化输出"在少数几个预设分支之间做选择。

但 Router Agent 有一个明显的局限:大模型通常只能控制单个决策,分支数量是写死的。比如我们只定义了"插入数据库"这一个分支,一旦希望接入网络搜索、RAG、天气查询等一堆各式各样的工具,难道要在每个工具下再套一层 Router Function 做分支判断吗?虽然可行,但显然不是高效的做法。

由此引出本文的主角——工具调用代理(Tool Calling Agent)。它是在 Router Agent 基础上的升级:大模型可以自主选择并使用工具库中的多种工具来完成某个分支中的任务。

它的核心思想一句话概括:

让大模型根据用户的自然语言输入,自动判断应该调用哪个工具、生成什么参数 → 实际执行工具 → 把工具返回结果交给大模型 → 结合原始问题生成最终回答。

即一次完整的工具调用循环是:

用户输入 → 大模型(决定调用哪个工具 + 填充参数 tool_calls)
        → 工具节点(执行工具,得到 ToolMessage 结果)
        → 大模型(结合工具结果 + 原始问题,生成自然语言回复)

二、使用 ToolNode 接入工具

2.1 ToolNode 是什么

ToolNode 是 LangGraph 提供的预构建工具节点,其内部实现原理和我们手动实现 Function Calling 的思路一致,核心逻辑等价于下面这段源码:

# tools_by_name:把工具列表转成 "工具名 -> 工具对象" 的字典,方便按名字查找
tools_by_name = {tool.name: tool for tool in tools}

def tool_node(state: dict):
    result = []
    # 遍历最后一条 AIMessage 中大模型决定的所有工具调用请求
    for tool_call in state["messages"][-1].tool_calls:
        # 1. 根据工具名找到对应的工具对象
        tool = tools_by_name[tool_call["name"]]
        # 2. 用大模型生成的参数执行工具
        observation = tool.invoke(tool_call["args"])
        # 3. 把执行结果包装成 ToolMessage(必须携带对应的 tool_call_id)
        result.append(ToolMessage(content=observation, tool_call_id=tool_call["id"]))
    # 返回状态更新,消息列表追加工具执行结果
    return {"messages": result}

ToolNode 接收一个工具列表 ToolNode(tools),返回一个 LangChain Runnable 对象。它以图状态(包含消息列表)作为输入,输出状态更新以及工具调用的结果。因此它既可以单独手动调用,也可以和 StateGraph 中的任何组件(包括预构建的 ReAct 代理)搭配使用。

2.2 使用 ToolNode 的三个必要条件

  1. 状态必须包含消息列表(messages 键);
  2. 消息列表的最后一条消息必须是 AIMessage;
  3. 该 AIMessage 必须填充了 tool_calls(即大模型已经决定了要调用哪些工具)。

2.3 实现步骤

步骤一:定义工具函数,并用 @tool 装饰器包装

普通的 Python 函数只需加上 @tool 装饰器,就能变成 ToolNode 可以使用的工具。函数的 docstring 会被自动提取为工具的 description,这个描述非常重要——大模型就是靠它来判断"什么情况下该调用这个工具"。

import requests
import json
from langchain_core.tools import tool

# @tool 装饰器会把普通函数包装成 LangChain 的 StructuredTool
# 函数名 -> 工具名;docstring -> 工具描述;函数参数 -> 工具参数 schema
@tool
def fetch_real_time_info(query):
    """Get real-time Internet information"""  # docstring 会成为工具描述,大模型据此决定是否调用
    url = "https://google.serper.dev/search"
    payload = json.dumps({
        "q": query,   # 搜索关键词,由大模型根据用户输入自动填充
        "num": 1,     # 返回 1 条结果
    })
    headers = {
        'X-API-KEY': 'YOUR_SERPER_API_KEY',   # 替换成自己的 Serper API Key
        'Content-Type': 'application/json'
    }
    response = requests.post(url, headers=headers, data=payload)
    data = json.loads(response.text)  # 将返回的 JSON 字符串转换为字典
    if 'organic' in data:
        # 返回搜索结果(标题、链接、摘要等)的 JSON 字符串
        return json.dumps(data['organic'], ensure_ascii=False)
    else:
        # 没有结果时返回错误信息
        return json.dumps({"error": "No organic results found"}, ensure_ascii=False)

包装后可以查看工具自动生成的元信息:

print(f'''
name: {fetch_real_time_info.name}          # 工具名:fetch_real_time_info
description: {fetch_real_time_info.description}  # 描述:来自 docstring
arguments: {fetch_real_time_info.args}     # 参数:{'query': {'title': 'Query'}}
''')

步骤二:用工具列表实例化 ToolNode

from langgraph.prebuilt import ToolNode

tools = [fetch_real_time_info]   # 可以放多个工具,形成一个"工具库"
tool_node = ToolNode(tools)      # 返回一个 Runnable,可直接当作图中的节点使用

步骤三:构造带 tool_calls 的 AIMessage,手动调用 ToolNode

ToolNode 操作的是消息列表,要求最后一条消息是带 tool_calls 的 AIMessage。我们可以手动模拟一次:

from langchain_core.messages import AIMessage

# 手动构造一条"大模型决定调用工具"的消息
message_with_single_tool_call = AIMessage(
    content="",
    tool_calls=[
        {
            "name": "fetch_real_time_info",   # 要调用的工具名,必须与 @tool 定义的函数名一致
            "args": {"query": "小米汽车"},      # 工具参数,键名必须与函数参数名一致
            "id": "tool_call_id",             # 调用 ID,用于匹配后续的 ToolMessage
            "type": "tool_call",
        }
    ],
)

# ToolNode 会解析 tool_calls,执行工具,并返回 ToolMessage 结果
tool_node.invoke({"messages": [message_with_single_tool_call]})

返回结果如下(工具结果被包装成 ToolMessage):

{'messages': [ToolMessage(
    content='[{"title": "小米汽车", "link": "https://www.xiaomiev.com/", "snippet": "...", "position": 1}]',
    name='fetch_real_time_info',
    tool_call_id='tool_call_id')]}

步骤四(可选):并行工具调用

如果把多个工具调用同时放进 AIMessage 的 tool_calls 列表,ToolNode 会自动逐个执行并全部返回:

# 再定义一个查询天气的工具
@tool
def get_weather(location):
    """Call to get the current weather."""
    if location.lower() in ["beijing"]:
        return "北京的温度是16度,天气晴朗。"
    elif location.lower() in ["shanghai"]:
        return "上海的温度是20度,部分多云。"
    else:
        return "不好意思,并未查询到具体的天气信息。"

tools = [fetch_real_time_info, get_weather]
tool_node = ToolNode(tools)

# 一次 AIMessage 中携带两个 tool_calls,ToolNode 会并行执行两个工具
message_with_multiple_tool_calls = AIMessage(
    content="",
    tool_calls=[
        {"name": "fetch_real_time_info", "args": {"query": "小米汽车"},
         "id": "tool_call_id", "type": "tool_call"},
        {"name": "get_weather", "args": {"location": "beijing"},
         "id": "tool_call_id_2", "type": "tool_call"},
    ],
)

tool_node.invoke({"messages": [message_with_multiple_tool_calls]})

2.4 让大模型来决定调用哪个工具:bind_tools

上面 tool_calls 里的内容是手动构造的,而 Tool Calling Agent 的本质是:由大模型根据用户的自然语言输入,自动决定调用哪个工具、并生成符合工具参数 schema 的参数。

这个"告诉大模型有哪些工具可用"的过程,通过 bind_tools 函数实现:

from langchain_openai import ChatOpenAI

# deepseek-chat 兼容 OpenAI 接口,因此使用 ChatOpenAI 接入
key = "sk-xxx"                              # 替换成自己的 DeepSeek API Key
base_url = "https://api.deepseek.com/v1"    # DeepSeek 的 OpenAI 兼容接口地址

llm = ChatOpenAI(model="deepseek-chat", api_key=key, base_url=base_url, temperature=0)

# 把工具列表绑定给大模型:工具的名称、描述、参数 schema 会被传给模型
model_with_tools = llm.bind_tools(tools)

查看 model_with_tools.kwargs 可以确认,工具已被转换成 OpenAI 的 tools 格式:

{'tools': [
    {'type': 'function', 'function': {
        'name': 'fetch_real_time_info',
        'description': 'Get real-time Internet information',
        'parameters': {'properties': {'query': {}}, 'required': ['query'], 'type': 'object'}}},
    {'type': 'function', 'function': {
        'name': 'get_weather',
        'description': 'Call to get the current weather.',
        'parameters': {'properties': {'location': {}}, 'required': ['location'], 'type': 'object'}}}]
}

此时大模型就能根据输入自动填充 tool_calls:

# 输入与搜索相关,大模型自动选择 fetch_real_time_info 并填好参数
model_with_tools.invoke("小米汽车").tool_calls
# [{'name': 'fetch_real_time_info', 'args': {'query': '小米汽车'},
#   'id': 'call_xxx', 'type': 'tool_call'}]

# 输入与天气相关,大模型自动选择 get_weather
model_with_tools.invoke("北京现在多少度呀?").tool_calls
# [{'name': 'get_weather', 'args': {'location': '北京'},
#   'id': 'call_xxx', 'type': 'tool_call'}]

完整链路:model_with_tools.invoke(...) 的输出本身就是带 tool_calls 的 AIMessage,可以直接传给 ToolNode,从而打通"大模型决策 → 工具执行"的完整链路:

# 大模型决定调用搜索工具 → ToolNode 执行 → 返回 ToolMessage
tool_node.invoke({"messages": [model_with_tools.invoke("小米汽车")]})

# 大模型决定调用天气工具 → ToolNode 执行 → 返回 ToolMessage
tool_node.invoke({"messages": [model_with_tools.invoke("shanghai今天天气多少度呀")]})

三、Tool Calling Agent 的完整实现案例

3.1 需求说明

在 Router Agent 版本的基础上做进一步升级,构建一个多功能的智能助手:

  • 用户进行普通对话(如"你好,请你介绍一下你自己")→ 不需要外部信息,直接生成自然语言回复;
  • 用户需要实时信息(如"小米汽车")→ 进入工具库,调用联网搜索工具;
  • 用户询问天气(如"北京的天气怎么样?")→ 调用天气查询工具;
  • 用户自我介绍时携带个人信息(如"我叫XX,邮箱是XX")→ 调用数据库插入工具,把信息存入 MySQL。

也就是说:是否用工具、用哪个工具,全部交给大模型自己决定,我们不再为每个工具手写分支。

3.2 实现思路分析

整体流程分为四步:

  1. 定义工具库:用 @tool + Pydantic 参数 schema 定义若干工具(搜索、天气、入库);
  2. 路由判断:第一个节点用结构化输出让大模型判断——是需要工具(返回工具相关参数对象)还是普通对话(返回 ConversationalResponse),再由 Router Function 据此分支;
  3. 执行工具:需要工具时,把结构化输出的对象交给 model_with_tools 生成 tool_calls,再交给 ToolNode 执行;
  4. 生成回复:不需要工具时走 final_answer 直接输出;需要工具时执行完工具即返回结果。

这个案例演示的是"结构化输出 + ToolNode"的组合用法,方便从 Router Agent 平滑过渡。更标准的写法见下一节的"手动构建"。

3.3 第一步:定义工具库

每个工具都用 Pydantic 模型声明参数 schema,通过 @tool(args_schema=...) 绑定,让大模型清楚每个参数的类型和含义:

from pydantic import BaseModel, Field
from typing import Optional
from langchain_core.tools import tool
import requests, json

# ---------- 工具 1:联网搜索 ----------
class SearchQuery(BaseModel):
    query: str = Field(description="Questions for networking queries")  # 参数说明:用于联网查询的问题

@tool(args_schema=SearchQuery)
def fetch_real_time_info(query):
    """Get real-time Internet information"""
    url = "https://google.serper.dev/search"
    payload = json.dumps({"q": query, "num": 1})
    headers = {
        'X-API-KEY': 'YOUR_SERPER_API_KEY',
        'Content-Type': 'application/json'
    }
    response = requests.post(url, headers=headers, data=payload)
    data = json.loads(response.text)
    if 'organic' in data:
        return json.dumps(data['organic'], ensure_ascii=False)
    else:
        return json.dumps({"error": "No organic results found"}, ensure_ascii=False)

# ---------- 工具 2:天气查询 ----------
class WeatherLoc(BaseModel):
    location: str = Field(description="The location name of the city")  # 参数说明:城市名

@tool(args_schema=WeatherLoc)
def get_weather(location):
    """Call to get the current weather."""
    if location.lower() in ["beijing"]:
        return "北京的温度是16度,天气晴朗。"
    elif location.lower() in ["shanghai"]:
        return "上海的温度是20度,部分多云。"
    else:
        return "不好意思,并未查询到具体的天气信息。"

# ---------- 工具 3:用户信息入库(依赖上一节 Router 案例中创建的 SQLAlchemy 会话与 User 表) ----------
class UserInfo(BaseModel):
    """Extracted user information, such as name, age, email, and phone number, if relevant."""
    name: str = Field(description="The name of the user")
    age: Optional[int] = Field(description="The age of the user")
    email: str = Field(description="The email address of the user")
    phone: Optional[str] = Field(description="The phone number of the user")

@tool(args_schema=UserInfo)
def insert_db(name, age, email, phone):
    """Insert user information into the database, The required parameters are name, age, email, phone"""
    session = Session()  # 每次操作创建新的数据库会话
    try:
        user = User(name=name, age=age, email=email, phone=phone)  # 创建用户记录
        session.add(user)      # 加入会话
        session.commit()       # 提交事务
        return {"messages": ["数据已成功存储至Mysql数据库。"]}
    except Exception as e:
        session.rollback()     # 出错回滚
        return {"messages": [f"数据存储失败,错误原因:{e}"]}
    finally:
        session.close()        # 关闭会话

3.4 第二步:实例化 ToolNode 与大模型

from langgraph.prebuilt import ToolNode
from langchain_openai import ChatOpenAI

# 三个工具一起交给 ToolNode,形成统一的"工具执行节点"
tools = [insert_db, fetch_real_time_info, get_weather]
tool_node = ToolNode(tools)

llm = ChatOpenAI(model="deepseek-chat", api_key=key, base_url=base_url, temperature=0)
# 绑定工具后,大模型能根据输入决定调用哪个工具并填充参数
model_with_tools = llm.bind_tools(tools)

3.5 第三步:定义结构化输出的路由模型

用 Pydantic 的 Union 类型,把"普通对话"和"三种工具意图"统一封装进一个父模型,交给 with_structured_output 做路由判断:

from typing import Union

# 普通对话回复
class ConversationalResponse(BaseModel):
    """Respond to the user's query in a conversational manner. Be kind and helpful."""
    response: str = Field(description="A conversational response to the user's query")

# 最终响应:final_output 可能是四种类型之一
# - ConversationalResponse:普通对话
# - SearchQuery / WeatherLoc / UserInfo:分别对应三种工具调用意图
class FinalResponse(BaseModel):
    final_output: Union[ConversationalResponse, SearchQuery, WeatherLoc, UserInfo]

3.6 第四步:定义节点函数

def chat_with_model(state):
    """路由节点:把用户输入转换成结构化输出,用于判断走哪个分支"""
    messages = state['messages']
    # 用结构化输出让大模型在四种意图中选择一种
    structured_llm = llm.with_structured_output(FinalResponse)
    response = structured_llm.invoke(messages)
    return {"messages": [response]}

def final_answer(state):
    """普通对话分支:直接提取结构化输出中的自然语言回复"""
    messages = state['messages'][-1]
    response = messages.final_output.response
    return {"messages": [response]}

def execute_function(state):
    """工具执行分支:把结构化输出交给大模型生成 tool_calls,再由 ToolNode 执行"""
    # 取出路由节点产生的结构化对象(如 SearchQuery(query='小米汽车的最新消息'))
    messages = state['messages'][-1].final_output
    # 大模型根据该对象生成带 tool_calls 的 AIMessage → ToolNode 执行工具
    response = tool_node.invoke({"messages": [model_with_tools.invoke(str(messages))]})
    # 提取工具执行结果(ToolMessage 的 content)
    response = response["messages"][0].content
    return {"messages": [response]}

3.7 第五步:定义状态与 Router Function

from typing import TypedDict, Annotated
import operator
from langchain_core.messages import AnyMessage, HumanMessage

# 图状态:messages 使用 operator.add 作为 Reducer,节点返回的消息会追加而不是覆盖
class AgentState(TypedDict):
    messages: Annotated[list[AnyMessage], operator.add]

# Router Function:判断结构化输出的类型,决定走"工具分支"还是"对话分支"
def generate_branch(state: AgentState):
    result = state['messages'][-1]
    output = result.final_output
    if isinstance(output, ConversationalResponse):
        return False   # 普通对话 → final_answer
    else:
        return True    # 工具意图(SearchQuery / WeatherLoc / UserInfo)→ execute_function

3.8 第六步:构建并编译图

from langgraph.graph import StateGraph, END

graph = StateGraph(AgentState)

# 添加三个节点:路由 / 工具执行 / 对话回复
graph.add_node("chat_with_model", chat_with_model)
graph.add_node("final_answer", final_answer)
graph.add_node("execute_function", execute_function)

graph.set_entry_point("chat_with_model")   # 入口:路由节点

# 条件边:根据 generate_branch 的返回值选择分支
graph.add_conditional_edges(
    "chat_with_model",
    generate_branch,
    {True: "execute_function", False: "final_answer"}
)

# 设置终止节点
graph.set_finish_point("final_answer")
graph.set_finish_point("execute_function")

graph = graph.compile()   # 编译图

图的结构为:

START → chat_with_model ─(True)─→ execute_function → END
                     └─(False)─→ final_answer      → END

3.9 第七步:测试

# 场景 1:普通对话 → 走 final_answer
query = "你好,请你介绍一下你自己"
result = graph.invoke({"messages": [HumanMessage(content=query)]})
result["messages"][-1]
# '你好!我是一个智能助手,旨在帮助回答问题和提供信息……'

# 场景 2:实时信息 → 联网搜索工具
query = "小米汽车"
result = graph.invoke({"messages": [HumanMessage(content=query)]})
result["messages"][-1]
# '[{"title": "小米汽车最新消息:...", "link": "...", "snippet": "..."}]'

# 场景 3:天气查询 → get_weather 工具
query = "北京的天气怎么样?"
result = graph.invoke({"messages": [HumanMessage(content=query)]})
result["messages"][-1]
# '不好意思,并未查询到具体的天气信息。'

# 场景 4:个人信息 → insert_db 工具(数据成功写入 MySQL)
query = "我叫奥特曼a,今年38岁,邮箱地址是aoteman#qq.com,电话是1211111111"
result = graph.invoke({"messages": [HumanMessage(content=query)]})
result["messages"][-1]
# '{"messages": ["数据已成功存储至Mysql数据库。"]}'

四类输入都被正确路由到了对应分支,且工具参数完全由大模型自动生成,无需我们手写任何分支判断逻辑。


四、手动构建 Tool Calling Agent 的方法

4.1 与上一案例的区别

上一案例依赖"结构化输出 + isinstance 类型判断"来路由,本节展示更通用的手动实现方式:不使用结构化输出,而是直接通过 bind_tools 让大模型输出 tool_calls,用 tool_calls 是否为空作为路由条件,并用系统提示词让大模型汇总工具结果、生成最终回复。

4.2 实现步骤

步骤一:定义工具库(与上一案例相同的三个工具,此处不再重复)。

步骤二:定义节点函数

# 节点 1:模型决策节点 —— 直接调用绑定工具后的大模型,输出带 tool_calls 的 AIMessage
def chat_with_model(state):
    messages = state['messages']
    # 这里不使用结构化输出,直接由 bind_tools 后的大模型决定是否调用工具
    response = llm.invoke(messages)
    return {"messages": [response]}

# 节点 2:手动执行工具 —— 等价于 ToolNode 的内部逻辑,自己实现一遍
def execute_function(state: AgentState):
    # 取出大模型决定的所有工具调用
    tool_calls = state['messages'][-1].tool_calls
    results = []
    tools = [insert_db, fetch_real_time_info, get_weather]
    tools = {t.name: t for t in tools}   # 构建工具名 -> 工具对象的映射
    for t in tool_calls:
        if not t['name'] in tools:
            # 大模型可能尝试调用不存在的工具,此时返回提示而非报错
            result = "bad tool name, retry"
        else:
            # 用大模型生成的参数执行工具
            result = tools[t['name']].invoke(t['args'])
        # 每个工具结果都要包装成 ToolMessage,并携带对应的 tool_call_id
        results.append(ToolMessage(tool_call_id=t['id'], name=t['name'], content=str(result)))
    return {'messages': results}

# 节点 3:透传节点 —— 无需工具时,直接把模型的回复往下传
def final_answer(state):
    messages = state['messages'][-1]
    return {"messages": [messages]}

# 系统提示词:指示大模型基于已有信息总结并生成专业回复
SYSTEM_PROMPT = """
Please summarize the information obtained so far and generate a professional response. Note, please reply in Chinese.
"""

# 节点 4:最终回复节点 —— 把工具执行结果交给大模型,生成自然语言总结
def natural_response(state):
    messages = state['messages'][-1]
    # 用系统提示词 + 工具结果内容组成新的 Prompt
    messages = [SystemMessage(content=SYSTEM_PROMPT)] + [HumanMessage(content=messages.content)]
    response = llm.invoke(messages)
    return {"messages": [response]}

步骤三:定义路由函数与状态

# Router Function:判断最后一条消息中是否存在 tool_calls
def exists_function_calling(state: AgentState):
    result = state['messages'][-1]
    return len(result.tool_calls) > 0   # 有工具调用 → 执行工具;没有 → 直接回复

# 图状态:与之前一致
class AgentState(TypedDict):
    messages: Annotated[list[AnyMessage], operator.add]

步骤四:构建并编译图

graph = StateGraph(AgentState)

# 四个节点:模型决策 / 工具执行 / 直接回复 / 最终总结
graph.add_node("chat_with_model", chat_with_model)
graph.add_node("execute_function", execute_function)
graph.add_node("final_answer", final_answer)
graph.add_node("natural_response", natural_response)

graph.set_entry_point("chat_with_model")

# 条件边:根据是否存在 tool_calls 分支
graph.add_conditional_edges(
    "chat_with_model",
    exists_function_calling,
    {True: "execute_function", False: "final_answer"}
)

# 两个分支最终都汇入 natural_response,由大模型总结生成专业回复
graph.add_edge("execute_function", "natural_response")
graph.add_edge("final_answer", "natural_response")

graph.set_finish_point("natural_response")

graph = graph.compile()

图的结构为:

START → chat_with_model ─(有 tool_calls)─→ execute_function ─┐
                     └─(无 tool_calls)─→ final_answer ────────┴→ natural_response → END

步骤五:绑定工具并测试

# 重新绑定工具列表(bind_tools 要在构建图之后、调用之前完成)
llm = llm.bind_tools([insert_db, fetch_real_time_info, get_weather])

# 测试 1:普通对话 → 无工具调用 → final_answer → natural_response 总结
messages = [HumanMessage(content="你好,请你介绍一下你自己")]
result = graph.invoke({"messages": messages})
result["messages"][-1].content
# '你好!感谢你详细介绍你的功能。如果你有任何具体问题……请随时告诉我!'

# 测试 2:实时信息 → 调用搜索工具 → natural_response 把搜索结果总结成中文回复
messages = [HumanMessage(content="小米汽车")]
result = graph.invoke({"messages": messages})
result["messages"][-1].content
# '小米汽车网站提供了有关其产品和服务的信息,包括超级电机、高压平台、超级大压铸……'

# 测试 3:个人信息 → 调用 insert_db 工具 → 总结生成回复
messages = [HumanMessage(content="我叫奥特曼b,今年38岁,邮箱地址是aoteman#qq.com,电话是1211111111")]
result = graph.invoke({"messages": messages})
result["messages"][-1].content
# '到目前为止,我们已经成功地将用户信息存储到Mysql数据库中。请问您还有其他需要帮助的地方吗?'

可以看到,手动版本与 ToolNode 版本功能完全等价:execute_function 节点本质上就是 ToolNode 内部逻辑的手写复现。实际开发中优先使用预构建的 ToolNode,手动实现的价值在于理解原理以及需要自定义执行逻辑(如自定义错误处理)时的灵活性。


五、总结

  1. 定位:Tool Calling Agent 是在 Router Agent 基础上的升级——Router 只能在大模型写死的少数分支中二选一,而 Tool Calling Agent 让大模型自主选择并调用工具库中的任意工具,控制权粒度更细、可扩展性更强。

  2. ToolNode 用法:

    • 用 @tool 装饰器把普通函数包装成工具(函数名 → 工具名,docstring → 描述,参数 → schema);
    • 用 ToolNode(tools) 实例化工具执行节点,它接收"最后一条消息带 tool_calls 的 AIMessage",执行工具并返回 ToolMessage;
    • 支持一次 tool_calls 列表中多个工具的并行调用。
  3. 大模型决策:通过 llm.bind_tools(tools) 把工具的名称、描述、参数 schema 绑定给大模型,由它根据自然语言输入自动决定调用哪个工具、生成什么参数。

  4. 两种构建方式:

    • 结构化输出 + ToolNode:with_structured_output(Union[...]) 判断意图,Router Function 用 isinstance 分支,工具分支内再由 bind_tools 的大模型 + ToolNode 执行;
    • 手动构建:直接 bind_tools,用 tool_calls 是否为空做条件边,execute_function 节点手写工具执行逻辑(即 ToolNode 的内部原理),最后由 natural_response 节点把工具结果总结成自然语言回复。
  5. 注意事项:工具调用参数由大模型根据用户输入生成,一定存在调用不存在的工具、参数与 schema 不匹配等边缘情况,会直接导致图运行中断,需要做进阶的错误处理优化(如 ToolNode 的 handle_tool_errors、重试机制等)。