Chain: LLM + Messages + Tools
The starting point of everything

1What problem is this lecture going to solve?

In the first lecture (1-1) of Module 1, Node only does string concatenation and has nothing to do with LLM. At the beginning of this lecture, we willReal LLM callIntroducing LangGraph.

To allow LLM to enter the graph, 4 sub-problems need to be solved:

2Messages: the basic unit of LLM dialogue

You have studied LangChain and know that the input of the chat model is a set of "messages". LangGraph completely reuses this system. LangChain defines multiple message types, each corresponding to a role in the conversation:

from langchain_core.messages import AIMessage, HumanMessage

# 构建一段对话历史
messages = [
    AIMessage(content="So you said you were researching ocean mammals?", name="Model"),
    HumanMessage(content="Yes, that's right.", name="Lance"),
    AIMessage(content="Great, what would you like to learn about.", name="Model"),
    HumanMessage(content="I want to learn about the best place to see Orcas.", name="Lance"),
]

# 把消息列表传给 LLM
result = llm.invoke(messages)
# result 是一个 AIMessage 对象

3Chat Models: Calling LLM in Node

LangGraph's Node is just an ordinary Python function. In the function body, you can directly call any Chat Model supported by LangChain:

from langchain_openai import ChatOpenAI
# 或者用 DeepSeek、Anthropic、Google 等任意 LangChain 支持的模型

llm = ChatOpenAI(model="gpt-4o-mini")

# 这就是一个调用 LLM 的 Node
def tool_calling_llm(state: MessagesState):
    # state["messages"] 是当前对话历史（列表）
    response = llm_with_tools.invoke(state["messages"])
    # 把 LLM 的回复作为新消息返回
    return {"messages": [response]}

It's that simple. Node gets the message list from State, calls LLM, and puts the result back into State.LangGraph's philosophy: The simpler the Node, the better, and the complexity is managed by the graph structure.

4Tools: Let LLM call functions

What is Tool Calling?

Modern LLMs (GPT-4, DeepSeek, etc.) support the "tool call" feature: you define some Python functions, tell LLM the names and parameters of these functions, and LLM canRequest to call a function(Instead of giving a direct text answer).

# 定义一个工具：普通 Python 函数，有类型注解和 docstring
def multiply(a: int, b: int) -> int:
    """Multiply a and b.

    Args:
        a: first int
        b: second int
    """
    return a * b

# bind_tools：把函数"绑定"给 LLM，让它知道有这个工具可用
llm_with_tools = llm.bind_tools([multiply])

When you ask LLM "What is 2 multiplied by 3?", it will not directly say "6", but will return a string withtool_callsAIMessage:

# LLM 的回复：请求调用工具
tool_call.tool_calls
# 输出：
# [{'name': 'multiply', 'args': {'a': 2, 'b': 3}, 'id': 'call_xxx', 'type': 'tool_call'}]

How does LLM know when to call a tool?

LLM will use your inputautomatic decisionDo you need to call tools:

5reducer: Solve the problem of status "overwritten"

Issue: Default behavior destroys conversation history

In the simple diagram of 1-1, State has only one string field, and each Node returns the new value overwriting the old value, which is no problem. But when State is stored inMessage listWhen, something goes wrong:

# State 初始：[HumanMsg]
# Node 返回：{"messages": [AIMsg]}
# State 变成：[AIMsg]
# ← HumanMsg 丢失了！

# State 初始：[HumanMsg]
# Node 返回：{"messages": [AIMsg]}
# State 变成：[HumanMsg, AIMsg]
# ← 追加，历史保留！

What is a reducer?

reducer is a function that defines "how the old value and the new value in State are merged when Node returns a new value." Via PythonAnnotatedType hints to declare:

from typing import Annotated
from langchain_core.messages import AnyMessage
from langgraph.graph.message import add_messages

class MessagesState(TypedDict):
    # Annotated[字段类型, Reducer函数]
    # add_messages：把新消息追加到列表，而不是覆盖
    messages: Annotated[list[AnyMessage], add_messages]

verifyadd_messagesBehavior:

from langgraph.graph.message import add_messages

initial = [AIMessage(content="Hello!"), HumanMessage(content="Hi!")]
new_msg = AIMessage(content="How can I help?")

result = add_messages(initial, new_msg)
# result = [AIMessage("Hello!"), HumanMessage("Hi!"), AIMessage("How can I help?")]
# ← 追加了，没有覆盖！

6MessagesState: Official built-in conversation state

Because the requirement of "there is a messages list using add_messages in State" is so common, LangGraph has it built-in directly.MessagesState：

from langgraph.graph import MessagesState

# 直接用！等价于手写 TypedDict + Annotated + add_messages
# 还可以继承它来添加自定义字段：
class MyState(MessagesState):
    user_id: str       # 额外添加的字段
    search_results: list

7Complete Chain Diagram: Assembled

Now combine all the parts into one picture:

from langgraph.graph import StateGraph, MessagesState, START, END

# Node：一个调用带工具绑定的 LLM 的节点
def tool_calling_llm(state: MessagesState):
    return {"messages": [llm_with_tools.invoke(state["messages"])]}

# 构建图：START → tool_calling_llm → END
builder = StateGraph(MessagesState)
builder.add_node("tool_calling_llm", tool_calling_llm)
builder.add_edge(START, "tool_calling_llm")
builder.add_edge("tool_calling_llm", END)
graph = builder.compile()

8Interpretation of running results

The same picture, different inputs get different results:

# 场景 1：普通问候，LLM 直接回复
messages = graph.invoke({"messages": HumanMessage(content="Hello!")})
# messages = {
#   "messages": [
#     HumanMessage("Hello!"),
#     AIMessage("Hi there! How can I assist you today?")  ← 纯文字回复
#   ]
# }

# 场景 2：数学计算，LLM 请求调用工具
messages = graph.invoke({"messages": HumanMessage(content="Multiply 2 and 3")})
# messages = {
#   "messages": [
#     HumanMessage("Multiply 2 and 3"),
#     AIMessage(tool_calls=[{'name':'multiply','args':{'a':2,'b':3}}])  ← 工具调用请求
#   ]
# }

Summary: Map of knowledge points in this lecture