AI创想

标题: [DeepAgents:LangChain平台的Harness-01]LangChain、LangGraph和DeepAgents三者之间的关系 [打印本页]

---

作者: juminsheng    时间: 昨天 09:14
标题: [DeepAgents:LangChain平台的Harness-01]LangChain、LangGraph和DeepAgents三者之间的关系
作者：CSDN博客
DeepAgents是LangChain团队在2025年正式发布的一个开源Agent框架，专门用于构建能够处理生产级、长时程、多步骤任务的深度Agent。与传统的浅层Agent（仅依赖LLM + 简单工具调用循环）不同，DeepAgents旨在模拟像Claude Code或DeepResearch那样的复杂执行能力。作为一个Agent开发框架，DeepAgents内置了任务规划、文件系统、Sub-Agent生成和长期记忆等功能。我们可以将DeepAgents用于复杂的多步骤任务。在介绍DeepAgents之前，我们先来简单概括一下LangChain、LangGraph和DeepAgents三者之间的关系。

LangChain：是一个Agent开发框架，提供了构建Agent的核心模块，如工具调用循环、提示管理、记忆管理等;LangGraph：是一个运行时系统，提供了持久执行、流式传输、人机交互等功能;DeepAgents：是一个基于LangChain构建的Agent开发框架，它使用LangGraph来实现持久执行、流式传输、人机交互等功能。

也许说了这些你还是觉得困惑，那我说得更简单一点：它们的最终使命都是利用构建的Agent来完成我们给它的任务，但是它们创建Agent的方式不同。
1. LangGraph：将StateGraph编程成Agent

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

1. from typing import TypedDict
2. from langgraph.graph import StateGraph
3. from PIL import Image
4. import io
6. classState(TypedDict):passasyncdeffoo(state:State):passasyncdefbar(state:State):passasyncdefbaz(state:State):passasyncdefqux(state:State):pass
8. 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())
10. Image.open(io.BytesIO(agent.get_graph().draw_mermaid_png())).show()

复制代码

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

2. LangChain：利用create_agent函数创建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。

1. from langchain.agents import create_agent
2. from langchain.tools import tool
3. from langchain_openai import ChatOpenAI
4. from PIL import Image
5. from dotenv import load_dotenv
6. import io
8. load_dotenv()@toolasyncdeffoo():"""test tool foo"""@toolasyncdefbar():"""test tool bar"""
10. agent = create_agent(
11.     model= ChatOpenAI(name="gpt-5.2-chat"),
12.     tools=[foo,bar])
14. Image.open(io.BytesIO(agent.get_graph().draw_mermaid_png())).show()

复制代码

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

这种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引入到模型和工具的调用中，使得在调用前后添加一些额外的操作变得非常简单。

1. classAgentMiddleware(Generic[StateT, ContextT]):defbefore_agent(self, state: StateT, runtime: Runtime[ContextT])->dict[str, Any]|Noneasyncdefabefore_agent(self, state: StateT, runtime: Runtime[ContextT])->dict[str, Any]|Nonedefbefore_model(self, state: StateT, runtime: Runtime[ContextT])->dict[str, Any]|Noneasyncdefabefore_model(self, state: StateT, runtime: Runtime[ContextT])->dict[str, Any]|Nonedefafter_model(self, state: StateT, runtime: Runtime[ContextT])->dict[str, Any]|Noneasyncdefaafter_model(self, state: StateT, runtime: Runtime[ContextT])->dict[str, Any]|Nonedefafter_agent(self, state: StateT, runtime: Runtime[ContextT])->dict[str, Any]|Noneasyncdefaafter_agent(self, state: StateT, runtime: Runtime[ContextT])->dict[str, Any]|Nonedefwrap_model_call(
2.         self,
3.         request: ModelRequest,
4.         handler: Callable[[ModelRequest], ModelResponse],)-> ModelCallResult
5.     asyncdefawrap_model_call(
6.         self,
7.         request: ModelRequest,
8.         handler: Callable[[ModelRequest], Awaitable[ModelResponse]],)-> ModelCallResult
10.     defwrap_tool_call(
11.         self,
12.         request: ToolCallRequest,
13.         handler: Callable[[ToolCallRequest], ToolMessage | Command[Any]],)-> ToolMessage | Command[Any]asyncdefawrap_tool_call(
14.         self,
15.         request: ToolCallRequest,
16.         handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]],)-> ToolMessage | Command[Any]

复制代码

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

1. from langchain.agents import create_agent
2. from dotenv import load_dotenv
3. from langchain.agents.middleware.types import AgentState
4. from langchain.tools import tool
5. from langchain_openai import ChatOpenAI
6. from PIL import Image
7. from langchain.agents.middleware import AgentMiddleware
8. from typing import Any
9. from langgraph.runtime import Runtime
10. import io
12. load_dotenv()classFoobarMiddleware(AgentMiddleware):defbefore_agent(self, state: AgentState[Any], runtime: Runtime[None])->dict[str, Any]|None:returnsuper().before_agent(state, runtime)defbefore_model(self, state: AgentState[Any], runtime: Runtime[None])->dict[str, Any]|None:returnsuper().before_model(state, runtime)defafter_agent(self, state: AgentState[Any], runtime: Runtime[None])->dict[str, Any]|None:returnsuper().after_agent(state, runtime)defafter_model(self, state: AgentState[Any], runtime: Runtime[None])->dict[str, Any]|None:returnsuper().after_model(state, runtime)@toolasyncdeffoo():"""test tool foo"""@toolasyncdefbar():"""test tool bar"""
14. agent = create_agent(
15.     model= ChatOpenAI(name="gpt-5.2-chat"),
16.     tools=[foo,bar],
17.     middleware=[FoobarMiddleware()])
19. 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，它仅仅在调用此方法时利用注册的中间件为Agent添加了更多的功能，如任务规划、用于上下文管理的文件系统、Sub-Agent生成和长期记忆等功能。
从LangGraph和LangChain创建Agent的方式可以看出，它们相当于是自助餐和套餐的差别。LangGraph具有完全的自由度，我们可以根据具体的推理任务对状态图进行DIY。虽然灵活自由，实则对用户提出了更高的要求。相比之下，LangChain利用create_agent函数创建的Agent具有固定结构，却能满足大部分的推理任务。它相当于提供了一款符合大众口味的基础套餐。在点餐的时候，我们可以选择这个基础套餐，也可以在此基础上添加、替换和剔除一些配菜来满足个性化的需求，这就是中间件赋予的定制能力。
LangChain和DeepAgents的关系就像是基础套餐和升级套餐的关系。LangChain利用create_agent函数构建的Agent只具有基础的功能，任务定制的功能都需要通过注册中间件来提供。企业级Agent来往往具有一些公共的功能需求，如任务规划、用于上下文管理的文件系统、Sub-Agent生成和长期记忆等功能。如果任何一个功能都要求用户通过注册中间件来实现的话，无疑也会增加用户的使用门槛。于是DeepAgents对套餐进行了升级，在通过create_deep_agent函数创建Agent的时候，根据提供的配置自动注册了对应的中间件。
为了探究create_deep_agent函数为创建的Agent注册了怎样的中间件，我们编写了如下的演示程序：

1. from deepagents import create_deep_agent
2. from deepagents.middleware import SubAgent,AsyncSubAgent
3. from langchain.tools import tool
4. from langchain_openai import ChatOpenAI
5. from PIL import Image
6. import io
7. from dotenv import load_dotenv
9. load_dotenv()@toolasyncdeffoo():"""test tool foo"""@toolasyncdefbar():"""test tool bar"""
11. 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"),}
13. async_subagent:AsyncSubAgent ={"name":"async-sub-agent","description":"A test async sub-agent","graph_id":"graph-001",}
15. agent = create_deep_agent(
16.     model= ChatOpenAI(name="gpt-5.2-chat"),
17.     memory=["/memories/AGENTS.md"],
18.     skills=["/skills/"],
19.     tools=[foo,bar],
20.     interrupt_on={"foo":True},
21.     subagents=[inline_subagent,async_subagent],)
23. Image.open(io.BytesIO(agent.get_graph().draw_mermaid_png())).show()

复制代码

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

在上面这张图中，我们看到了五个中间件。但是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：记忆持久化与注入器。它负责将用户偏好、业务规则或跨会话的关键事实提取出来，并以系统提示词的形式注入到Agent的大脑中；SubAgentMiddleware: 分身指挥官。支持Agent生成具有独立上下文的Sub-Agent来分担任务，实现复杂工作的委派与隔离；AsyncSubAgentMiddleware: 异步分身。在SubAgent基础上增加了异步执行能力，允许Main-Agent在Sub-Agent处理耗时任务时继续执行其他操作或同时管理多个子任务；

原文地址：https://blog.csdn.net/JaydenAI/article/details/160844830

---

欢迎光临 AI创想 (https://llms-ai.com/)

Powered by Discuz! X3.4