Router：让 LLM 决定走哪条路
ToolNode · tools_condition · 条件路由

1 上一讲遗留的问题：工具没有被执行

回顾上一讲（Chain）的图：START → tool_calling_llm → END。当你问"Multiply 2 and 3"，LLM 返回了一个带 tool_calls 的 AIMessage，但图直接走到 END 了——工具请求就躺在 State 里没人理。

Router 要解决的就是这个问题，需要新增两个东西：

• 一个执行工具的节点（ToolNode）
• 一个条件判断：LLM 有没有请求工具？有就去执行，没有就直接结束

2 Router 的核心思想：LLM 作为路由器

Router 这个名字来自网络路由器的比喻——根据条件决定数据包走哪条路。在这里，LLM 就是路由器：

3 ToolNode：执行工具调用的内置节点

ToolNode 是 LangGraph 内置的预构建节点，专门用来执行 LLM 请求的工具调用。你不需要自己写执行逻辑：

from langgraph.prebuilt import ToolNode

# 定义工具函数
def multiply(a: int, b: int) -> int:
    """Multiply a and b."""
    return a * b

# ToolNode 接收工具列表，自动处理执行逻辑
tool_node = ToolNode([multiply])

# 注册为图的节点
builder.add_node("tools", tool_node)

ToolNode 在内部做了什么？

ToolNode 从 State 里取出最新的 AIMessage，读取其中的 tool_calls，然后：

• 找到对应名称的函数（如 multiply）
• 用 LLM 提供的参数调用该函数（multiply(a=2, b=3)）
• 把结果包装成 ToolMessage 追加到 messages

# ToolNode 执行后，State 里的 messages 变成：
# [
#   HumanMessage("Multiply 2 and 3"),
#   AIMessage(tool_calls=[{name:"multiply", args:{a:2,b:3}}]),
#   ToolMessage(content="6", name="multiply", tool_call_id="call_xxx")  ← 新增
# ]

4 tools_condition：内置的条件路由函数

tools_condition 是 LangGraph 内置的路由函数，专门用于判断"LLM 有没有请求工具"：

from langgraph.prebuilt import tools_condition

# tools_condition 的等效手写版本（帮助你理解它做了什么）：
def tools_condition(state: MessagesState):
    last_message = state["messages"][-1]  # 取最新的消息
    if last_message.tool_calls:           # 有工具调用请求？
        return "tools"                    # → 去 tools 节点
    return END                            # → 结束

# 用法：作为条件边的路由函数
builder.add_conditional_edges(
    "tool_calling_llm",   # 从这个节点出发
    tools_condition,       # 用这个函数决定去哪
    # 可选：明确指定可能的路由目标（提高可读性）
    # {"tools": "tools", END: END}
)

tools_condition 就是我们在 1-1 里学到的"路由函数（decide_mood）"的生产级版本。它做的事情完全一样：读 State，返回下一个节点名。

5 完整 Router 图：代码全解析

from langgraph.graph import StateGraph, MessagesState, START, END
from langgraph.prebuilt import ToolNode, tools_condition

# ─── 工具定义 ───
def multiply(a: int, b: int) -> int:
    """Multiply a and b."""
    return a * b

# ─── LLM 绑定工具 ───
llm_with_tools = llm.bind_tools([multiply])

# ─── LLM Node ───
def tool_calling_llm(state: MessagesState):
    return {"messages": [llm_with_tools.invoke(state["messages"])]}

# ─── 构建图 ───
builder = StateGraph(MessagesState)

builder.add_node("tool_calling_llm", tool_calling_llm)  # LLM 节点
builder.add_node("tools", ToolNode([multiply]))         # 工具执行节点

builder.add_edge(START, "tool_calling_llm")            # 入口
builder.add_conditional_edges(                          # 条件分支
    "tool_calling_llm",
    tools_condition,   # 有工具调用→tools，没有→END
)
builder.add_edge("tools", END)                          # 工具执行完→结束

graph = builder.compile()

6 两种执行路径详解

路径 A：用户问普通问题（不需要工具）

messages = [HumanMessage(content="Hello, how are you?")]
result = graph.invoke({"messages": messages})

# 执行路径：
# START → tool_calling_llm（LLM 直接回复，无 tool_calls）
#       → tools_condition 返回 END
#       → 结束
#
# 最终 messages：
# [HumanMessage("Hello, how are you?"), AIMessage("Hi! I'm fine...")]

路径 B：用户让 LLM 做计算（需要工具）

messages = [HumanMessage(content="What is 2 multiplied by 3?")]
result = graph.invoke({"messages": messages})

# 执行路径：
# START → tool_calling_llm（LLM 请求工具）
#       → tools_condition 返回 "tools"
#       → ToolNode 执行 multiply(2, 3) = 6
#       → END
#
# 最终 messages：
# [
#   HumanMessage("What is 2 multiplied by 3?"),
#   AIMessage(tool_calls=[{name:"multiply",args:{a:2,b:3}}]),
#   ToolMessage(content="6", name="multiply")  ← 工具执行结果
# ]

7 Router vs Chain：前进了哪一步？

这一讲引入的两个预构建组件