[DeepAgents:LangChain平台的Harness-01]LangChain、LangGraph和DeepAgents三者之间的关系

关注

原创 2026-10-07 08:58:55 796 阅读 AI 写同款· GEO 优化 ›

LangChain Agent实战：从零构建具备联网搜索能力的AI智能体大语言模型（LLM）作为当前AI应用的核心，通过API调用可实现基础的文本生成与问答。其工作原理基于Transformer架构，通过自注意力机制处理序列数据，生成符合上下文逻辑的文本输出。这一技术价值在于将自然语言理解与生成能力标准化，为开发者提供了强大的语义处理基础。在实际工程实践中，当任务涉及外部数据查询、多步骤推理或工具调用时，单纯API调用便显不足，需要更高级的框架来编排复杂流程。这正是LangChain框架的应用场景，它通过标准化组件将LLM转化为可“思考”和“行动”的智能体（Agent）。本文聚阅读详情

DeepAgents是LangChain团队在2025年正式发布的一个开源Agent框架，专门用于构建能够处理生产级、长时程、多步骤任务的深度Agent。与传统的浅层Agent（仅依赖LLM + 简单工具调用循环）不同，DeepAgents旨在模拟像Claude Code或DeepResearch那样的复杂执行能力。作为一个Agent开发框架，DeepAgents内置了任务规划、文件系统、Sub-Agent和长期记忆等功能。我们可以将DeepAgents用于复杂的多步骤任务。在介绍DeepAgents之前，我们先来简单概括一下LangChain、LangGraph和DeepAgents三者之间的关系。表面上看它们它们对应不同的创建方式，但是最终对应最终创建出来的Agent来说，本质上并没有什么不同，都是一个由StateGraph编译生成的CompiledStateGraph对象。

1. LangGraph：将StateGraph编程成Agent

LangGraph提供了这样的编程模式：利用一个StateGraph对象作为Builder，通过添加节点和边的形式，根据推理任务构建具有对应结构的状态图。最终的Agent是StateGraph编译后的结果，它本质上是一个Pregel对象，一个由节点和通道组成的Actor模型。StateGraph的节点转换成Pregel的节点，状态成员转换成Pregel的通道，由边决定的执行流程转换节点针对通道的订阅规则。原则上任意复杂度的状态图都可以通过为StateGraph添加相应的节点和边构建出来。比如我们利用如下的程序构建了一个包含四个节点（foo、bar、baz和qux）的状态图，并按照流转规则添加了相应的边，最终将其编译成一个Agent。

from typing import TypedDict
from langgraph.graph import StateGraph
from PIL import Image
import io

class State(TypedDict):
    pass

async def foo(state:State):
    pass
async def bar(state:State):
    pass
async def baz(state:State):
    pass
async def qux(state:State):
    pass

agent = (StateGraph(State)
    .add_node("foo",foo)
    .add_node("bar",bar)
    .add_node("baz",baz)
    .add_node("qux",qux)
    .set_entry_point("foo")
    .set_finish_point("qux")
    .add_edge("foo","bar")
    .add_edge("foo","baz")
    .add_edge(["bar","baz"],"qux")
    .compile())

Image.open(io.BytesIO(agent.get_graph().draw_mermaid_png())).show()

我们调用Agent对象的get_graph方法可以得到一个Graph对象，调用它的draw_mermaid_png方法可以得到一个PNG格式的状态图（字节数组），最终利用PIL库将其展示出来。

Alternative Text

2. LangChain：利用create_agent函数创建Agent

如果我们将LangChain和LangGraph和DeepAgents放在一起比较，关注点自然落在用来创建Agent的create_agent工厂函数上。create_agent函数根据指定的语言模型组件和工具集创建的Agent，其底层依然是采用LangGraph这套Agent创建机制。具体来说，它默认会针对状态类型AgentState创建一个StateGraph。AgentState具有核心的状态成员messages，它承载了模型、用户和工具三者之间的对话历史。

create_agent函数为StateGraph添加两个节点，一个用于封装模型的model节点，另一个承载所有的工具的tools节点。模型节点与工具节点之间具有一条动态条件边,当LLM返回的最后一条AIMessage包含工具调用时，被激活的这条边路由到tools节点完成工具调用，反之表明AIMessage携带的是最终的结果，整个推理过程就此结束。工具节点与模型节点有一条静态边，所以工具执行后会再次回到模型节点，后者在新的状态下完成下一步推理。

LangChain利用create_agent工厂函数创建Agent，一个最简单的Agent只需要指定模型即可，但一般情况我们都需要注册相应的工具。下面的代码利用create_agent函数创建了一个由ChatOpenAI模型和两个注册工具组成的Agent。

from langchain.agents import create_agent
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from PIL import Image
from dotenv import load_dotenv
import io

load_dotenv()

@tool
async def foo():
    """test tool foo"""

@tool
async def bar():
    """test tool bar"""

agent = create_agent(
    model= ChatOpenAI(name= "gpt-5.2-chat"),
    tools=[foo,bar]
)

Image.open(io.BytesIO(agent.get_graph().draw_mermaid_png())).show()

当这个Agent被转换成图后具有如下的结构。这是一个包含两个节点的状态图，一个是用于决策和推理的model节点，作为决策执行者的工具全部被封装到tools节点中。

Alternative Text

这种AgentState + 双节点（model和tools）的结构虽然简单，但却能满足常规的推理任务。对于更复杂的推理任务，一方面我们可以扩展AgentState，提供更多的状态成员来承载更多的上下文信息。另一方面我们也可以通过注册中间件（通过AgentMiddleware类型表示）来添加更多的节点来完善状态图。具体来说，注册的中间件提供了如下的功能：

添加状态字段：如果中间件涉及到针对状态更新，对应的状态字段会定义在state_schema字段返回的状态类型中。此状态类型通常是AgentState的子类，定义其中的字段最终会转换成通道；
用于注册工具：当中间件被注册到创建的Agent上时，存储在其tools字段中的工具会自动注册到Agent上。这相当于提供了一种模块化的工具开发和注册的方式；
添加节点：当中间件重写了before_agent/abefore_agent、before_model/abefore_model、after_model/aafter_model、after_agent/aafter_agent方法，都会在状态图中相应的位置添加一个节点。中间件相当于利用此方式完善了Agent的状态图；
包装模型和工具调用：中间件利用重写的wrap_model_call/awrap_model_call、wrap_tool_call/awrap_tool_call方法对模型和工具的调用进行包装，将AOP引入到模型和工具的调用中，使得在调用前后添加一些额外的操作变得非常简单。

class AgentMiddleware(Generic[StateT, ContextT]):
    def before_agent(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None
    async def abefore_agent(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None
    def before_model(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None
    async def abefore_model(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None
    def after_model(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None
    async def aafter_model(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None
    def after_agent(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None
    async def aafter_agent(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None

    def wrap_model_call(
        self,
        request: ModelRequest,
        handler: Callable[[ModelRequest], ModelResponse],
    ) -> ModelCallResult
    async def awrap_model_call(
        self,
        request: ModelRequest,
        handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
    ) -> ModelCallResult

    def wrap_tool_call(
        self,
        request: ToolCallRequest,
        handler: Callable[[ToolCallRequest], ToolMessage | Command[Any]],
    ) -> ToolMessage | Command[Any]
    async def awrap_tool_call(
        self,
        request: ToolCallRequest,
        handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]],
    ) -> ToolMessage | Command[Any]

在下面的程序中，我们定义了一个FoobarMiddleware，并将其注册到Agent上。虽然它没有添加任何新的功能，但它会在Agent如下所示的状态图中添加四个新的节点，分别是before_agent、before_model、after_model和after_agent节点。

from langchain.agents import create_agent
from dotenv import load_dotenv
from langchain.agents.middleware.types import AgentState
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from PIL import Image
from langchain.agents.middleware import AgentMiddleware
from typing import Any
from langgraph.runtime import Runtime
import io

load_dotenv()

class FoobarMiddleware(AgentMiddleware):
    def before_agent(self, state: AgentState[Any], runtime: Runtime[None]) -> dict[str, Any] | None:
        return super().before_agent(state, runtime) 
    def before_model(self, state: AgentState[Any], runtime: Runtime[None]) -> dict[str, Any] | None:
        return super().before_model(state, runtime)
    def after_agent(self, state: AgentState[Any], runtime: Runtime[None]) -> dict[str, Any] | None:
        return super().after_agent(state, runtime)
    def after_model(self, state: AgentState[Any], runtime: Runtime[None]) -> dict[str, Any] | None:
        return super().after_model(state, runtime) 

@tool
async def foo():
    """test tool foo"""

@tool
async def bar():
    """test tool bar"""

agent = create_agent(
    model= ChatOpenAI(name= "gpt-5.2-chat"),
    tools=[foo,bar],
    middleware=[FoobarMiddleware()]
)

Image.open(io.BytesIO(agent.get_graph().draw_mermaid_png())).show()

状态图结构如下所示：

3. DeepAgents：利用`create_deep_agent`函数创建Agent

DeepAgents拥有属于自己的Agent工厂函数create_deep_agent，它其实最终也会调用LangChain的create_agent函数来创建Agent，但是会在调用此方法时会注册用来实现各种Harness手段的中间件，如任务规划、用于上下文管理的文件系统、Sub-Agent和长期记忆等功能。

从LangGraph和LangChain创建Agent的方式可以看出，它们相当于是自助餐和套餐的差别。LangGraph具有完全的自由度，我们可以根据具体的推理任务对状态图进行DIY。虽然灵活自由，实则对用户提出了更高的要求。相比之下，LangChain利用create_agent函数创建的Agent具有固定结构，却能满足大部分的推理任务。它相当于提供了一款符合大众口味的基础套餐。在点餐的时候，我们可以选择这个基础套餐，也可以在此基础上添加、替换和剔除一些配菜来满足个性化的需求，这就是中间件赋予的定制能力。

LangChain和DeepAgents的关系就像是基础套餐和升级套餐的关系。LangChain利用create_agent函数构建的Agent只具有基础的功能，任务定制的功能都需要通过注册中间件来提供。企业级Agent由于推理任务的复杂性，以及对可靠性以及安全合规的要求，需要利用中间件的形式赋予Agent这些能力和特性。如果任何一个功能都要求用户通过注册中间件来实现的话，无疑也会增加用户的使用门槛。于是DeepAgents对套餐进行了升级，在通过create_deep_agent函数创建Agent的时候，根据提供的配置自动注册了对应的中间件。

为了探究create_deep_agent函数为创建的Agent注册了怎样的中间件，我们编写了如下的演示程序：

from deepagents import create_deep_agent
from deepagents.middleware import SubAgent,AsyncSubAgent
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from PIL import Image
import io
from dotenv import load_dotenv

load_dotenv()

@tool
async def foo():
    """test tool foo"""

@tool
async def bar():
    """test tool bar"""

inline_subagent:SubAgent = {
    "name": "inline-sub-agent",
    "description": "A test inline sub-agent",
    "system_prompt": "System prompt for inline sub-agent",
    "model": ChatOpenAI(name= "gpt-5.2-chat"),  
}

async_subagent:AsyncSubAgent = {
    "name": "async-sub-agent",
    "description": "A test async sub-agent",
    "graph_id": "graph-001",
}

agent = create_deep_agent(
    model= ChatOpenAI(name= "gpt-5.2-chat"),
    memory=["/memories/AGENTS.md"],
    skills=["/skills/"],
    tools=[foo,bar],
    interrupt_on={"foo":True},
    subagents=[inline_subagent,async_subagent],
)

Image.open(io.BytesIO(agent.get_graph().draw_mermaid_png())).show()

在上面的程序中，我们通过create_deep_agent函数创建了一个Agent，并为它指定了模型、记忆、Skill、工具、中断规则和Sub-Agent（同步和异步）等配置。最终我们得到的状态图如下所示：

Alternative Text

在上面这张图中，我们看到了五个中间件。但是DeepAgents涉及的中间件远不止这些，因为只有重写了before_agent/abefore_agent、before_model/abefore_model、after_model/aafter_model方法的中间件才会转换成状态图的节点，而且SubAgentMiddleware和AsyncSubAgentMiddleware生成的Sub-Agent也会有自己的中间件。总的来说，整个DeepAgents就建立在如下这几个中间件之上，了解了它们你就了解了DeepAgents的全部，当然随着不断更新迭代，这个列列表会不断更新：

FileSystemMiddleware: 提供一个抽象的文件系统。让Agent拥有利用工具读写本地文件的能力（如read_file和write_file），使它可以将中间推理结果或处理超长内容存入文件，防止上下文溢出；
TodoListMiddleware: 利用提供的系统提示词指导LLM将复杂的任务拆分为子任务列表（Todo-List），并以此为蓝本逐步实施。它同时提供了write_todos工具实时记录每个子任务的完成状态；
SkillsMiddleware: 允许Agent动态加载预定义的Skills，通过注入系统提示词让Agent快速获得特定领域的专业知识;
HumanInTheLoopMiddleware: 实现了人机交互，在Agent调用关键/敏感工具前（如支付、删除文件）暂停并请求人类批准、修改或拒绝;
PatchToolCallsMiddleware：用于在模型输出不符合规范或需要动态调整时，对工具调用的参数进行实时补丁或格式修正，提高调用成功率；
_DeepAgentsSummarizationMiddleware：记忆瘦身器。自动对冗长的对话历史进行摘要压缩。它在信息进入模型前执行，仅保留关键摘要和最新消息，从而节省Token并维持长期对话的连贯性；
MemoryMiddleware：记忆持久化与注入器。它负责将用户偏好、业务规则或跨Session的关键事实提取出来，并以系统提示词的形式注入到Agent的大脑中；
SubAgentMiddleware: 分身指挥官。支持Agent生成具有独立上下文的Sub-Agent来分担任务，实现复杂工作的委派与隔离；
AsyncSubAgentMiddleware: 异步分身。在SubAgent基础上增加了异步执行能力，允许Main-Agent在Sub-Agent处理耗时任务时继续执行其他操作或同时管理多个子任务；