Router: Let the LLM Decide Which Path to Take
ToolNode · tools_condition · Conditional Routing

1 The Problem Left from the Previous Lesson: The Tool Was Not Executed

Recall the graph from the previous lesson, Chain: START → tool_calling_llm → END. When you ask "Multiply 2 and 3", the LLM returns an AIMessage with tool_calls, but the graph goes straight to END. The tool request simply sits in State and nobody handles it.

Router solves exactly this problem by adding two things:

• A node that executes tools (ToolNode)
• A conditional check: did the LLM request a tool? If yes, execute it; if no, end directly

2 The Core Idea of Router: The LLM as the Router

The name Router comes from the network-router metaphor: choose which path a packet should take based on conditions. Here, the LLM is the router:

3 ToolNode: A Built-in Node for Executing Tool Calls

ToolNode is a built-in, prebuilt LangGraph node dedicated to executing tool calls requested by the LLM. You do not need to write the execution logic yourself:

from langgraph.prebuilt import ToolNode

# Define the tool function
def multiply(a: int, b: int) -> int:
    """Multiply a and b."""
    return a * b

# ToolNode receives the list of tools and automatically handles execution logic
tool_node = ToolNode([multiply])

# Register it as a graph node
builder.add_node("tools", tool_node)

What Does ToolNode Do Internally?

ToolNode takes the latest AIMessage from State, reads its tool_calls, and then:

• Finds the function with the corresponding name, such as multiply
• Calls that function with the arguments provided by the LLM, such as multiply(a=2, b=3)
• Wraps the result in a ToolMessage and appends it to messages

# After ToolNode executes, messages in State become:
# [
#   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")  ← added
# ]

4 tools_condition: A Built-in Conditional Routing Function

tools_condition is LangGraph's built-in routing function specifically for checking whether the LLM requested a tool:

from langgraph.prebuilt import tools_condition

# A hand-written equivalent of tools_condition (to help you understand what it does):
def tools_condition(state: MessagesState):
    last_message = state["messages"][-1]  # Take the latest message
    if last_message.tool_calls:           # Is there a tool-call request?
        return "tools"                    # → Go to the tools node
    return END                            # → End

# Usage: as the routing function for conditional edges
builder.add_conditional_edges(
    "tool_calling_llm",   # Start from this node
    tools_condition,       # Use this function to decide where to go
    # Optional: explicitly specify possible routing targets (improves readability)
    # {"tools": "tools", END: END}
)

tools_condition is the production-grade version of the "routing function (decide_mood)" we learned in 1-1. It does exactly the same thing: read State and return the next node name.

5 Complete Router diagram: full code analysis

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 Detailed explanation of the two execution paths

Path A: User asks a normal question (no tools required)

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...")]

Path B: The user lets LLM do the calculations (tools required)

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")  ← 工具执行结果
# ]

7Router vs Chain: Which step forward?

Two pre-built components introduced in this lecture