相信经过前两节的练习，你已经可以构建一个简单的智能体，在前两节知道大体框架之后，后面我们就在细分一下，学习 LangChain 的核心组件，这一节是关于智能体（Agents）的介绍。智能体（Agents）将语言模型与工具相结合，构建能够推理任务、决定使用哪些工具，并迭代推进解决方案的系统。

在与之前版本的繁琐不同 LangChain v1.0 中专门更新了 create_agent 以此提供生产级别的智能体实现。下面用一副流程图来介绍智能体的核心逻辑，LLM 智能体会循环运行工具以实现目标，直到满足停止条件——即模型输出最终结果或达到迭代上限。

create_agent 基于 LangGraph 构建了一个基于图的智能体运行时。图由节点（步骤）和边（连接）组成，定义了智能体处理信息的方式。智能体通过该图执行流程，运行节点（如调用模型的“模型节点”、执行工具的“工具节点”）或中间件。

一、核心组件

1.1 模型（Model）

模型是智能体的推理引擎，支持多种指定方式，包括静态和动态模型选择。

静态模型（Static model）

静态模型在创建智能体时配置一次，整个执行过程中保持不变，是最常见且直接的方式。

通过模型标识符字符串初始化静态模型：

from langchain.agents import create_agent

agent = create_agent(
    "gpt-5",
    tools=tools
)

模型标识符字符串支持自动推断（例如 gpt-5 会被推断为 openai:gpt-5）。在参考文档中可查看完整的模型标识符映射列表。

如需更精细地控制模型配置，可通过提供商包直接初始化模型实例。以下示例使用 ChatOpenAI，其他可用聊天模型类详见「聊天模型」文档。

from langchain.agents import create_agent
from langchain_openai import ChatOpenAI

model = ChatOpenAI(
    model="gpt-5",
    temperature=0.1,
    max_tokens=1000,
    timeout=30
    # ...（其他参数）
)

agent = create_agent(model, tools=tools)

模型实例允许你完全控制配置，适用于需要设置 temperature、max_tokens、timeouts、base_url 等特定参数或提供商专属设置的场景。

动态模型（Dynamic model）

动态模型可以根据运行时的状态和上下文选择，支持复杂的路由逻辑和成本优化。

如果需要使用动态模型，可通过 @wrap_model_call 装饰器创建中间件，在请求中修改模型：

from langchain_openai import ChatOpenAI
from langchain.agents import create_agent
from langchain.agents.middleware import wrap_model_call, ModelRequest, ModelResponse

basic_model = ChatOpenAI(model="gpt-4o-mini")
advanced_model = ChatOpenAI(model="gpt-4o")

@wrap_model_call
def dynamic_model_selection(request: ModelRequest, handler) -> ModelResponse:
    """根据对话复杂度选择模型。"""
    message_count = len(request.state["messages"])
    if message_count > 10:
        # 长对话使用高级模型
        model = advanced_model
    else:
        model = basic_model
    return handler(request.override(model=model))

agent = create_agent(
    model=basic_model,  # 默认模型
    tools=tools,
    middleware=[dynamic_model_selection]
)

使用结构化输出时，不支持预绑定模型（已调用 bind_tools 的模型）。如果需要结合结构化输出使用动态模型选择，确保传递给中间件的模型未被预绑定。

1.2 工具（Tools）

工具赋予智能体执行动作的能力。智能体超越了简单的“模型+工具绑定”，支持：

• 序列调用多个工具（由单个提示词触发）
• 适当时并行调用工具
• 根据先前结果动态选择工具
• 工具重试逻辑和错误处理
• 工具调用间的状态持久化

定义工具（Defining tools）

向智能体传递工具列表即可。工具可指定为普通 Python 函数或协程。

可通过 @tool 装饰器自定义工具名称、描述、参数模式等属性：

from langchain.tools import tool
from langchain.agents import create_agent

@tool
def search(query: str) -> str:
    """搜索信息。"""
    return f"搜索结果：{query}"

@tool
def get_weather(location: str) -> str:
    """获取指定地点的天气信息。"""
    return f"{location}的天气：晴，72华氏度"

agent = create_agent(model, tools=[search, get_weather])

如果传递空工具列表，智能体将仅包含单个 LLM 节点，不具备工具调用能力。

工具错误处理（Tool error handling）

如需自定义工具错误处理方式，可通过 @wrap_tool_call 装饰器创建中间件：

from langchain.agents import create_agent
from langchain.agents.middleware import wrap_tool_call
from langchain.messages import ToolMessage

@wrap_tool_call
def handle_tool_errors(request, handler):
    """用自定义消息处理工具执行错误。"""
    try:
        return handler(request)
    except Exception as e:
        # 向模型返回自定义错误消息
        return ToolMessage(
            content=f"工具错误：请检查输入后重试。（{str(e)}）",
            tool_call_id=request.tool_call["id"]
        )

agent = create_agent(
    model="gpt-4o",
    tools=[search, get_weather],
    middleware=[handle_tool_errors]
)

工具失败时，智能体将返回带有自定义错误消息的 ToolMessage：

[
    ...
    ToolMessage(
        content="工具错误：请检查输入后重试。（除零错误）",
        tool_call_id="..."
    ),
    ...
]

ReAct循环中的工具使用（Tool use in the ReAct loop）

智能体遵循 ReAct（“推理+行动”）模式，在“针对性工具调用的简短推理步骤”和“将结果观察反馈到后续决策”之间交替，直到能够输出最终答案。

ReAct循环示例
提示词：找出当前最受欢迎的无线耳机并验证库存情况。

================== 人类消息（Human Message）=================
找出现在最受欢迎的无线耳机，并检查是否有货

推理：“受欢迎程度具有时效性，我需要使用提供的搜索工具。”
行动：调用 search_products("wireless headphones")

=================== AI消息（Ai Message）=====================
工具调用（Tool Calls）：
search_products（调用ID：call_abc123） 参数（Args）：
query: wireless headphones

================= 工具消息（Tool Message）===================
找到5款匹配“无线耳机”的产品，排名前五：WH-1000XM5、…

推理：“回答前需要确认排名第一产品的库存情况。”
行动：调用 check_inventory("WH-1000XM5")

=================== AI消息（Ai Message）=====================
工具调用（Tool Calls）：
check_inventory（调用ID：call_def456） 参数（Args）：
product_id: WH-1000XM5

================== 工具消息（Tool Message）===================
产品 WH-1000XM5：库存10台

推理：“已获取最受欢迎型号及其库存状态，可回答用户问题。”
行动：生成最终答案

=================== AI消息（Ai Message）=====================
我找到了无线耳机（型号
WH-1000XM5），库存10台…

1.3 系统提示词（System prompt）

通过提供提示词，你可以塑造智能体处理任务的方式。system_prompt 参数可传入字符串：

agent = create_agent(
    model,
    tools,
    system_prompt="你是一个乐于助人的助手。回答简洁准确。"
)

如果未提供 system_prompt，智能体将直接从消息中推断任务。

动态系统提示词（Dynamic system prompt）
对于需要根据运行时上下文或智能体状态修改系统提示词的高级场景，可使用中间件。

@dynamic_prompt 装饰器可创建中间件，根据模型请求动态生成系统提示词：

from typing import TypedDict

from langchain.agents import create_agent
from langchain.agents.middleware import dynamic_prompt, ModelRequest

class Context(TypedDict):
    user_role: str

@dynamic_prompt
def user_role_prompt(request: ModelRequest) -> str:
    """根据用户角色生成系统提示词。"""
    user_role = request.runtime.context.get("user_role", "user")
    base_prompt = "你是一个乐于助人的助手。"
    if user_role == "expert":
        return f"{base_prompt} 提供详细的技术类回答。"
    elif user_role == "beginner":
        return f"{base_prompt} 用简单的方式解释概念，避免专业术语。"
    return base_prompt

agent = create_agent(
    model="gpt-4o",
    tools=[web_search],
    middleware=[user_role_prompt],
    context_schema=Context
)

# 系统提示词将根据上下文动态设置
result = agent.invoke(
    {"messages": [{"role": "user", "content": "解释机器学习"}]},
    context={"user_role": "expert"}
)

1.4 调用（Invocation）

可通过向智能体的 State 传递更新来调用它。所有智能体的状态中都包含消息序列；调用时，传入新消息即可：

result = agent.invoke(
    {"messages": [{"role": "user", "content": "旧金山的天气怎么样？"}]}
)

如需流式获取智能体的步骤和/或令牌，详见「流式传输指南」。

此外，智能体遵循 LangGraph 图 API，支持所有相关方法（如 stream 和 invoke）。

---

二、高级概念

2.1 结构化输出（Structured output）

某些场景下，你可能希望智能体以特定格式返回输出。LangChain 通过 response_format 参数提供结构化输出策略。

工具策略（ToolStrategy）

ToolStrategy 使用虚拟工具调用生成结构化输出，适用于所有支持工具调用的模型：

from pydantic import BaseModel
from langchain.agents import create_agent
from langchain.agents.structured_output import ToolStrategy

class ContactInfo(BaseModel):
    name: str
    email: str
    phone: str

agent = create_agent(
    model="gpt-4o-mini",
    tools=[search_tool],
    response_format=ToolStrategy(ContactInfo)
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "从以下内容提取联系信息：John Doe, john@example.com, (555) 123-4567"}]
})

result["structured_response"]
# ContactInfo(name='John Doe', email='john@example.com', phone='(555) 123-4567')

提供商策略（ProviderStrategy）

ProviderStrategy 使用模型提供商的原生结构化输出生成功能，可靠性更高，但仅适用于支持原生结构化输出的提供商（如 OpenAI）：

from langchain.agents.structured_output import ProviderStrategy

agent = create_agent(
    model="gpt-4o",
    response_format=ProviderStrategy(ContactInfo)
)

从 langchain 1.0 开始，不再支持直接传入模式（如 response_format=ContactInfo），必须显式使用 ToolStrategy 或 ProviderStrategy。

2.2 记忆（Memory）

智能体通过消息状态自动维护对话历史。你也可以配置智能体使用自定义状态模式，在对话过程中记录额外信息。

状态中存储的信息可视为智能体的“短期记忆”：

• 自定义状态模式必须以 TypedDict 形式扩展 AgentState。
• 定义自定义状态有两种方式：
  1. 通过中间件（推荐）
  2. 通过 create_agent 的 state_schema 参数

通过中间件定义自定义状态，比通过 create_agent 的 state_schema 参数更推荐——这种方式能将状态扩展与相关中间件和工具在概念上绑定。

state_schema 仍为向后兼容保留在 create_agent 中。

通过中间件定义状态（Defining state via middleware）

当自定义状态需要被特定中间件钩子和关联工具访问时，使用中间件定义：

from langchain.agents import AgentState
from langchain.agents.middleware import AgentMiddleware
from typing import Any

class CustomState(AgentState):
    user_preferences: dict

class CustomMiddleware(AgentMiddleware):
    state_schema = CustomState
    tools = [tool1, tool2]
    
    def before_model(self, state: CustomState, runtime) -> dict[str, Any] | None:
        ...

agent = create_agent(
    model,
    tools=tools,
    middleware=[CustomMiddleware()]
)

# 智能体现在可以跟踪消息之外的额外状态
result = agent.invoke({
    "messages": [{"role": "user", "content": "我喜欢技术类解释"}],
    "user_preferences": {"style": "technical", "verbosity": "detailed"},
})

通过 state_schema 定义状态（Defining state via state_schema）

使用 state_schema 参数作为快捷方式，定义仅在工具中使用的自定义状态：

from langchain.agents import AgentState

class CustomState(AgentState):
    user_preferences: dict

agent = create_agent(
    model,
    tools=[tool1, tool2],
    state_schema=CustomState
)

# 智能体现在可以跟踪消息之外的额外状态
result = agent.invoke({
    "messages": [{"role": "user", "content": "我喜欢技术类解释"}],
    "user_preferences": {"style": "technical", "verbosity": "detailed"},
})

从 langchain 1.0 开始，自定义状态模式必须是 TypedDict 类型，不再支持 Pydantic 模型和数据类。详见 v1 迁移指南。

2.3 流式传输（Streaming）

我们已经了解如何通过 invoke 调用智能体获取最终响应。如果智能体执行多个步骤，可能需要一定时间。如需展示中间进度，可流式返回消息：

for chunk in agent.stream({
    "messages": [{"role": "user", "content": "搜索AI相关新闻并总结结果"}]
}, stream_mode="values"):
    # 每个块包含当前完整状态
    latest_message = chunk["messages"][-1]
    if latest_message.content:
        print(f"智能体：{latest_message.content}")
    elif latest_message.tool_calls:
        print(f"调用工具：{[tc['name'] for tc in latest_message.tool_calls]}")

2.4 中间件（Middleware）

中间件提供了强大的扩展性，可在执行的不同阶段自定义智能体行为。你可以使用中间件：

• 模型调用前处理状态（如消息裁剪、上下文注入）
• 修改或验证模型响应（如安全护栏、内容过滤）
• 用自定义逻辑处理工具执行错误
• 根据状态或上下文实现动态模型选择
• 添加自定义日志、监控或分析功能

中间件无缝集成到智能体的执行图中，允许你在关键节点拦截和修改数据流，无需更改智能体核心逻辑。

上面就是整个 Agent 完整核心流程，如果你有什么需要了解或者尝试的也可以前往挂网参阅更详细的 LangChain 文档。