引言：为什么传统Agent总是"浅尝辄止"？

你有没有遇到过这样的尴尬场景：

让AI助手帮你完成一个复杂任务，比如"调研一下LangGraph技术，写一份技术报告，并创建相应的代码示例"。刚开始，AI热情满满，调用几个工具，搜索一些资料。但没过多久，就开始迷失方向——要么陷入死循环，要么忘记最初的目标，要么因为上下文太长而"失忆"。

这就是传统Agent的致命缺陷：它们太"浅"了。

一个简单的"LLM调用工具循环"架构，只能处理单步骤任务。一旦面对需要多轮规划、跨文件操作、长期记忆保持的复杂场景，就会力不从心。

但现实世界的问题，恰恰都是复杂的、多步骤的、需要长期规划的。

这就是为什么像Claude Code、Deep Research、Manus这样的应用能够脱颖而出——它们不是简单的工具调用器，而是具备深度思考能力的智能体。

现在，LangChain团队开源了DeepAgents，将这些"深度智能体"的核心能力封装成一个可复用的Python SDK。

---

一、DeepAgents到底是什么？

1.1 核心定位

DeepAgents是LangChain团队继LangGraph、LangChain之后推出的第三个独立开源Agent框架，专门用于构建能够处理复杂、多步骤任务的深度智能体。

它的目标很明确：让智能体具备长期规划与分工能力，而不仅仅是工具调用。

1.2 与Claude Code的关系

DeepAgents的设计灵感直接来源于Claude Code等成功的编程智能体。它观察到一个关键模式：所有成功的"深度Agent"都具备四个核心能力：

1. 规划工具：将复杂任务分解为可执行的子任务
2. 子代理（Sub-Agents）：为不同任务创建隔离的上下文窗口
3. 文件系统：提供持久化状态存储
4. 精细化提示词：教会模型如何有效使用这些工具

DeepAgents将这四大能力打包成一个可组合的框架，让你无需从零搭建基础设施。

1.3 五大核心能力

DeepAgents内置了五大核心能力，开箱即用：

能力	作用	内置工具
规划（Planning）	任务分解与进度追踪	write_todos
文件系统	读写、编辑、搜索文件	read_file 、write_file、edit_file、ls、glob、grep
Shell访问	在隔离沙箱中执行命令	execute
子代理	将复杂工作委托给具有新鲜上下文的子代理	task
上下文管理	对话过长时自动摘要压缩	compact_conversation

注意：这些不是普通的工具，而是通过中间件系统深度集成的能力。

---

二、架构全景图：从Monorepo到编译图

2.1 Monorepo设计哲学

DeepAgents采用Monorepo架构，所有代码集中在一个仓库中，但分为多个独立版本化的包：

deepagents/├── libs/│   ├── deepagents/          # 核心SDK│   ├── cli/                 # 终端编码代理（类似Claude Code）│   ├── acp/                 # 编辑器集成（Zed、VS Code）│   ├── evals/               # 评估框架（LangSmith追踪）│   └── partners/            # 沙箱后端集成│       ├── daytona/         # Daytona远程沙箱│       ├── modal/           # Modal无服务器计算│       ├── quickjs/         # QuickJS进程内沙箱│       └── runloop/         # Runloop沙箱├── examples/                # 示例应用│   ├── deep_research/       # 多步骤网络研究│   ├── content-builder-agent/ # 内容生成代理│   ├── text-to-sql-agent/   # 自然语言转SQL│   └── ralph_mode/          # 自主循环模式└── AGENTS.md                # 开发指南

这种设计的优势在于：

• • 独立版本化：每个包可以独立发布和升级
• • 代码复用：核心逻辑共享，减少重复
• • 生态扩展：轻松集成第三方后端和工具

2.2 create_deep_agent工厂函数

整个框架的入口点是一个看似简单的函数：create_deep_agent()。

from deepagents import create_deep_agentagent = create_deep_agent()result = agent.invoke({    "messages": [{"role": "user", "content": "研究LangGraph并写一份总结"}]})

就这么两行代码，你就得到了一个功能完整的深度智能体！

但这个工厂函数背后，隐藏着一个复杂的组装过程：

create_deep_agent
配置参数
模型选择claude-sonnet-4-6
中间件栈默认5层中间件
后端选择StateBackend
工具注册文件系统+子代理
LangGraph编译器
CompiledStateGraph编译状态图
流式推理
状态检查点
中断控制

这个函数返回的是一个编译后的LangGraph状态图（CompiledStateGraph），这意味着你可以使用LangGraph的所有高级功能：流式响应、状态持久化、检查点恢复等。

2.3 核心参数详解

create_deep_agent()支持以下关键参数：

参数	作用	默认值
model	指定LLM模型（任何支持工具调用的模型）	claude-sonnet-4-6
tools	额外的自定义工具	None
system_prompt	覆盖基础系统提示词	内置提示词
middleware	添加或替换中间件层	默认栈
subagents	配置委托子代理	通用代理
skills	SKILL.md文件路径，用于工作流发现	None
memory	AGENTS.md文件路径，用于持久化上下文	None
backend	可插拔的文件/命令存储后端	StateBackend
checkpointer	LangGraph状态持久化	None
interrupt_on	人机协同的工具审批配置	None

关键要求：传入的LLM必须支持工具调用（Tool Calling）。默认使用Anthropic的Claude Sonnet 4.6，但你可以切换到任何提供商（OpenAI、Gemini、Ollama等）。

---

三、中间件系统：DeepAgents的灵魂

这是DeepAgents最核心、最优雅的设计。

3.1 中间件 vs 普通工具

在理解中间件之前，先要明确一个关键区别：

• • 普通工具：被LLM调用，执行特定功能，返回结果
• • 中间件：继承自AgentMiddleware，拦截每一次LLM请求，在请求发送前进行修改

Tools
LLM
中间件2
中间件1
Agent
User
Tools
LLM
中间件2
中间件1
Agent
User
中间件可以：
1. 修改系统提示词
2. 动态过滤工具
3. 跨轮次追踪状态
4. 注入上下文信息
用户请求
拦截请求
处理并传递
修改后的请求
调用工具
返回结果
生成响应
处理响应
最终响应
返回给用户

中间件的能力远超普通工具：

• • 动态工具过滤
• • 系统提示词注入
• • 消息转换
• • 跨轮次状态追踪

3.2 默认中间件栈

create_deep_agent()自动组装的默认中间件栈包含5层：

用户请求
FilesystemMiddleware文件系统操作
SubAgentMiddleware子代理委托
SummarizationMiddleware自动摘要
MemoryMiddlewareAGENTS.md注入
SkillsMiddlewareSKILL.md工作流
LLM

让我们逐层拆解：

3.2.1 FilesystemMiddleware（文件系统中间件）

提供的工具：ls、read_file、write_file、edit_file、glob、grep、execute

核心行为：

• • 根据后端能力过滤execute工具（某些沙箱不允许shell执行）
• • 将大型工具结果驱逐到文件系统，避免上下文爆炸
• • 提供完整的文件操作能力，支持本地和远程存储

技术亮点：

# 示例：大型结果自动驱逐到文件系统# 当工具返回超过阈值时，自动写入临时文件if len(tool_result) > MAX_CONTEXT_SIZE:    file_path = backend.write_temp_file(tool_result)    return f"结果已保存到: {file_path}"

3.2.2 SubAgentMiddleware（子代理中间件）

提供的工具：task

核心行为：

• • 将子代理指令注入系统提示词
• • 生成临时子代理，拥有独立的上下文窗口
• • 支持任务委托和结果汇总

工作原理：

后端存储
子代理
SubAgentMiddleware
父代理
后端存储
子代理
SubAgentMiddleware
父代理
子代理拥有：
- 独立的上下文窗口
- 临时文件系统
- 专属工具集
调用task工具
创建临时工作区
启动子代理
注入独立上下文
执行子任务
返回结果
清理临时工作区
汇总结果

使用场景：

# 父代理遇到复杂任务时，可以委托给子代理agent.invoke({    "messages": [{        "role": "user",        "content": "使用task工具，让子代理负责代码测试部分"    }]})

3.2.3 SummarizationMiddleware（摘要中间件）

提供的工具：自动触发（无需显式工具）

核心行为：

• • 监控token使用量，超过阈值时触发压缩
• • 将历史对话卸载到后端存储
• • 生成结构化摘要，保持对话连续性

技术实现：

class SummarizationMiddleware(AgentMiddleware):    def__init__(self, threshold_tokens=100000):        self.threshold = threshold_tokens        self.token_count = 0        defbefore_llm_call(self, state):        self.token_count = count_tokens(state["messages"])                ifself.token_count > self.threshold:            # 触发摘要生成            summary = self.generate_summary(state["messages"])            # 将历史卸载到后端            backend.store_conversation_history(state["messages"])            # 替换为摘要            state["messages"] = [summary]                return state

8段式上下文压缩：DeepAgents采用结构化压缩策略，将对话分为8个逻辑段（系统指令、工具定义、历史摘要、当前任务等），确保关键信息不丢失。

3.2.4 MemoryMiddleware（记忆中间件）

提供的工具：无（上下文注入）

核心行为：

• • 加载AGENTS.md文件
• • 在每一轮对话中将内容注入系统提示词
• • 提供持久化上下文，跨会话保持记忆

使用示例：

# AGENTS.md## 项目规范- 使用TypeScript编写- 遵循ESLint规则- 所有函数必须有类型注解## 偏好设置- 优先使用函数式编程- 避免使用any类型

中间件会自动读取这个文件，并在每次LLM调用时注入：

system_prompt += "\n\n## 项目记忆（来自AGENTS.md）\n"system_prompt += backend.read("AGENTS.md")

3.2.5 SkillsMiddleware（技能中间件）

提供的工具：无（渐进式披露）

核心行为：

• • 从后端源发现SKILL.md文件
• • 将元数据注入系统提示词
• • 支持工作流复用和最佳实践沉淀

SKILL.md示例：

# SKILL.md: React组件开发## 触发条件当用户请求创建React组件时## 工作流程1. 分析组件需求2. 创建TypeScript接口3. 实现组件逻辑4. 添加单元测试5. 编写文档## 代码模板export interface Props {  // 属性定义}export const Component: React.FC<Props> = (props) => {  // 实现};

中间件会自动发现这个文件，并在适当时机提示LLM使用这个工作流。

3.3 中间件执行流程

完整的中间件执行流程如下：

是
否

是
否

用户请求
FilesystemMiddleware1. 注入文件系统工具2. 配置execute权限
SubAgentMiddleware1. 注入task工具2. 配置子代理提示词
SummarizationMiddleware1. 检查token使用量2. 必要时触发摘要
MemoryMiddleware1. 读取AGENTS.md2. 注入到系统提示词
SkillsMiddleware1. 扫描SKILL.md2. 渐进式披露技能
LLM调用
工具调用？
执行工具
生成响应
结果过大？
写入文件系统
返回给用户

关键设计原则：

• • 中间件顺序很重要：从底层（文件系统）到高层（技能）逐层封装
• • 双向流动：请求时从上到下，响应时从下到上
• • 职责分离：每个中间件只负责一个领域

3.4 何时使用中间件 vs 普通工具？

这是一个关键的设计决策：

使用中间件，当你的工具需要：

• • 修改系统提示词
• • 跨轮次追踪状态
• • 对所有SDK消费者可用
• • 动态过滤或注入上下文

使用普通工具（tools=[]列表），当：

• • 函数是无状态的
• • 功能是自包含的
• • 不需要修改提示词
• • 不需要跨轮次跟踪

---

四、可插拔后端系统：抽象的力量

4.1 BackendProtocol抽象

DeepAgents的所有文件和命令操作都通过BackendProtocol抽象层进行。

class BackendProtocol(Protocol):    """后端协议定义"""        defread(self, path: str) -> str:        """读取文件"""        ...        defwrite(self, path: str, content: str) -> None:        """写入文件"""        ...        defedit(self, path: str, edits: List[Edit]) -> None:        """编辑文件"""        ...        defls(self, path: str) -> List[str]:        """列出目录"""        ...        defglob(self, pattern: str) -> List[str]:        """ glob匹配文件"""        ...        defgrep(self, pattern: str, path: str) -> List[Match]:        """搜索文件内容"""        ...        defupload_files(self, files: List[File]) -> None:        """上传文件"""        ...        defdownload_files(self, paths: List[str]) -> List[File]:        """下载文件"""        ...classSandboxBackendProtocol(BackendProtocol):    """沙箱后端扩展协议"""        defexecute(self, command: str) -> ExecutionResult:        """执行shell命令"""        ...

这个抽象的价值：

• • 同一份代理代码可以在不同后端上运行
• • 无需修改业务逻辑，只需切换后端实现
• • 支持懒加载：通过BackendFactory实现运行时配置

4.2 后端实现全景图

DeepAgents提供了多种后端实现：

BackendProtocol抽象接口
StateBackend内存/临时存储
FilesystemBackend本地磁盘
LangSmithBackend云存储
Partner Backends第三方沙箱
Daytona远程开发沙箱
Modal无服务器计算
Runloop托管沙箱
QuickJS进程内JS沙箱

后端	包	使用场景
StateBackend	内置	临时、内存存储（默认）
FilesystemBackend	内置	本地磁盘访问，开发环境
LangSmithBackend	内置	通过LangSmith云托管
Daytona	libs/partners/daytona	远程开发沙箱
Modal	libs/partners/modal	无服务器计算环境
Runloop	libs/partners/runloop	托管沙箱执行
QuickJS	libs/partners/quickjs	进程内JavaScript沙箱

4.3 后端选择策略

如何选择适合的后端？

开发阶段：

# 使用本地文件系统，便于调试from deepagents.backends import FilesystemBackendagent = create_deep_agent(    backend=FilesystemBackend(root_path="./workspace"))

生产环境：

# 使用远程沙箱，确保安全隔离from deepagents.partners.daytona import DaytonaBackendagent = create_deep_agent(    backend=DaytonaBackend(        api_key=os.environ["DAYTONA_API_KEY"],        sandbox_id="my-sandbox"    ))

云原生场景：

# 使用LangSmith后端，便于追踪和监控from deepagents.backends import LangSmithBackendagent = create_deep_agent(    backend=LangSmithBackend(        project_id="my-project",        api_key=os.environ["LANGSMITH_API_KEY"]    ))

4.4 后端工厂模式

支持懒加载和运行时配置：

from deepagents import BackendFactory, ToolRuntimedef backend_factory(runtime: ToolRuntime):    """后端工厂函数"""    if runtime.environment == "production":        return DaytonaBackend(api_key=get_api_key())    else:        return FilesystemBackend(root_path="./dev-workspace")agent = create_deep_agent(backend=backend_factory)

优势：

• • 延迟初始化，减少启动开销
• • 根据运行时环境动态选择后端
• • 支持热切换后端

---

五、核心技术亮点深度剖析

5.1 任务规划机制

DeepAgents的规划能力基于write_todos工具实现。

工作流程：

待办存储
LLM
Agent
User
待办存储
LLM
Agent
User
创建子代理
alt
[需要委托]
loop
[执行子任务]
loop
[任务执行循环]
复杂任务请求
分析任务
分解为子任务
创建待办列表
返回todo_id
执行当前任务
更新进度
确认更新
调用task工具
标记完成
返回最终结果

代码示例：

# 自动任务规划result = agent.invoke({    "messages": [{        "role": "user",        "content": """        完成以下任务：        1. 调研LangGraph最新文档        2. 分析其核心架构        3. 编写技术报告        4. 创建示例代码        """    }]})# LLM会自动调用write_todos创建计划# 待办列表：# [ ] 搜索LangGraph文档# [ ] 阅读核心概念# [ ] 分析架构图# [ ] 撰写报告大纲# [ ] 编写示例代码# [ ] 完成报告

5.2 子代理委托机制

子代理是DeepAgents处理复杂任务的关键。

核心技术：

1. 上下文隔离：每个子代理拥有独立的上下文窗口
2. 临时文件系统：子代理在临时工作区操作
3. 结果汇总：父代理收集子代理结果并整合

示例：

# 父代理委托子代理parent_agent.invoke({    "messages": [{        "role": "user",        "content": "使用task工具，让子代理负责单元测试部分"    }]})# 子代理执行# 1. 创建临时工作区# 2. 编写测试代码# 3. 运行测试# 4. 返回结果# 父代理汇总# "子代理已完成测试，通过率95%"

优势：

• • 避免上下文污染
• • 并行执行多个子任务
• • 每个子代理专注单一职责

5.3 上下文管理机制

DeepAgents采用多层上下文管理策略：

上下文管理
短期记忆当前对话
中期记忆AGENTS.md
长期记忆后端存储
摘要记忆压缩历史
消息队列token限制内
项目规范偏好设置工作流
完整对话历史工具执行记录文件变更
结构化摘要关键决策任务进度

自动摘要触发：

# 当对话超过阈值时if token_count > 100000:    # 1. 生成结构化摘要    summary = {        "任务目标": "调研LangGraph",        "已完成": ["文档搜索", "架构分析"],        "待完成": ["编写报告"],        "关键发现": ["基于图的工作流", "中间件系统"]    }        # 2. 将完整历史卸载到后端    backend.store("conversation_history.json", full_messages)        # 3. 替换为摘要    messages = [format_summary(summary)]

5.4 文件系统操作

文件系统是DeepAgents的基石。

核心操作：

# 1. 读取文件content = backend.read("src/main.py")# 2. 写入文件backend.write("src/new_file.py", "print('hello')")# 3. 编辑文件（支持差异编辑）backend.edit("src/main.py", [    {"old_str": "print('hello')", "new_str": "print('world')"}])# 4. 列出目录files = backend.ls("./src")# 5. 全局搜索matches = backend.glob("**/*.py")# 6. 内容搜索results = backend.grep("def main", "./src")# 7. 执行命令（沙箱后端）result = backend.execute("python src/main.py")

大型结果驱逐：

# 当工具返回过大时def handle_large_result(result: str) -> str:    if len(result) > MAX_CONTEXT_SIZE:        # 自动写入临时文件        temp_path = f"/tmp/result_{uuid.uuid4()}.txt"        backend.write(temp_path, result)        return f"结果过大，已保存到: {temp_path}"    return result

5.5 完整代码示例

让我们看一个完整的实战示例：

from deepagents import create_deep_agentfrom deepagents.backends import FilesystemBackendfrom langchain_anthropic import ChatAnthropic# 1. 配置后端backend = FilesystemBackend(root_path="./my-project")# 2. 创建代理agent = create_deep_agent(    model=ChatAnthropic(model="claude-sonnet-4-6"),    backend=backend,    memory=["./AGENTS.md"],  # 加载项目记忆    skills=["./skills/"],     # 加载技能库    system_prompt="""你是一个专业的软件工程师。    遵循AGENTS.md中的规范，使用SKILL.md中的工作流。    遇到复杂任务时，使用task工具委托子代理。""")# 3. 执行复杂任务result = agent.invoke({    "messages": [{        "role": "user",        "content": """        为项目创建一个完整的用户认证模块：        - 实现JWT认证        - 添加密码加密        - 编写单元测试        - 生成API文档        """    }]})# 4. 流式响应for chunk in agent.stream({    "messages": [{"role": "user", "content": "开始开发"}]}):    if"messages"in chunk:        msg = chunk["messages"][-1]        print(f"{msg['role']}: {msg['content']}")

---

六、实战应用场景

6.1 场景一：深度研究代理

# 多步骤网络研究from deepagents import create_deep_agentresearch_agent = create_deep_agent(    tools=[tavily_search],  # 网络搜索工具    system_prompt="你是一个专业研究员。使用search工具收集信息，使用write_todos规划研究步骤。")result = research_agent.invoke({    "messages": [{        "role": "user",        "content": "研究LangGraph的技术架构，写一份5000字的技术报告"    }]})# 代理会自动：# 1. 制定研究计划# 2. 搜索相关文档# 3. 阅读关键资料# 4. 整理笔记# 5. 撰写报告

6.2 场景二：内容生成代理

# 带记忆和技能的内容生成content_agent = create_deep_agent(    memory=["./content_style.md"],  # 写作风格    skills=["./skills/blog_post.md"],  # 博客写作流程    backend=FilesystemBackend(root_path="./content"))result = content_agent.invoke({    "messages": [{        "role": "user",        "content": "写一篇关于DeepAgents的技术博客"    }]})# 代理会：# 1. 遵循写作风格指南# 2. 使用博客写作工作流# 3. 保存草稿到文件系统# 4. 迭代优化内容

6.3 场景三：Text-to-SQL代理

# 自然语言转SQLsql_agent = create_deep_agent(    tools=[execute_sql],    memory=["./database_schema.md"],  # 数据库 schema    system_prompt="""你是一个SQL专家。    根据database_schema.md中的表结构，    将自然语言转换为SQL查询。""")result = sql_agent.invoke({    "messages": [{        "role": "user",        "content": "找出上个月销售额最高的10个产品"    }]})# 代理会：# 1. 理解查询需求# 2. 参考schema生成SQL# 3. 执行查询# 4. 返回结果

---

七、性能优化与最佳实践

7.1 性能优化技巧

1. 合理设置摘要阈值

from deepagents.middleware import SummarizationMiddlewareagent = create_deep_agent(    middleware=[        SummarizationMiddleware(threshold_tokens=50000)  # 降低阈值，更早触发摘要    ])

2. 使用检查点恢复

from langgraph.checkpoint import MemorySaveragent = create_deep_agent(    checkpointer=MemorySaver())# 长时间任务可以中断后恢复config = {"configurable": {"thread_id": "task_123"}}result = agent.invoke(state, config=config)

3. 并行执行子代理

# 同时启动多个子代理tasks = [    agent.invoke({"messages": [{"role": "user", "content": "任务1"}]}),    agent.invoke({"messages": [{"role": "user", "content": "任务2"}]}),    agent.invoke({"messages": [{"role": "user", "content": "任务3"}]}),]results = await asyncio.gather(*tasks)

7.2 最佳实践

1. 精心设计AGENTS.md

# AGENTS.md## 项目结构- src/ - 源代码- tests/ - 单元测试- docs/ - 文档## 编码规范- 使用TypeScript- 所有函数必须有类型注解- 遵循ESLint规则## 测试要求- 覆盖率>80%- 每个模块必须有单元测试- 使用Jest框架

2. 创建可复用的SKILL.md

# SKILL.md: API开发## 触发条件当用户请求创建REST API时## 工作流程1. 定义路由结构2. 实现业务逻辑3. 添加错误处理4. 编写API文档5. 创建集成测试## 模板代码import { Router } from 'express';export const router = Router();router.get('/endpoint', async (req, res) => {  try {    // 业务逻辑    res.json(result);  } catch (error) {    res.status(500).json({ error: error.message });  }});

3. 选择合适的后端

• • 开发：FilesystemBackend
• • 测试：StateBackend（快速、隔离）
• • 生产：Daytona/Modal（安全、可扩展）

---

八、CLI与生态工具

DeepAgents不仅仅是SDK，还提供了完整的生态工具链。

8.1 Deep Agents CLI

类似于Claude Code的终端编码代理：

# 安装pip install deepagents-cli# 使用deepagent# 交互式终端(deepagent) > 帮我修复这个bug

功能特性：

• • 交互式TUI界面
• • 流式响应
• • 网络搜索集成
• • 对话恢复
• • 远程沙箱支持
• • 持久化记忆
• • 自定义技能
• • 无头模式（脚本化）
• • 人机协同审批

8.2 ACP连接器（编辑器集成）

支持在支持ACP的编辑器（如Zed）中运行Deep Agent：

// .zed/settings.json{  "agent": {    "type": "deepagents",    "model": "claude-sonnet-4-6",    "backend": "filesystem"  }}

优势：

• • 无缝集成编辑器
• • 动态模型切换（不丢失对话历史）
• • 直接操作项目文件

8.3 评估框架

DeepAgents提供行为测试框架：

from deepagents.evals import run_evaluationresults = run_evaluation(    agent=my_agent,    test_cases=[        {            "input": "创建用户登录功能",            "expected": ["auth.py", "test_auth.py"],            "assertions": [                "success: 文件必须存在",                "efficiency: 工具调用<10次"            ]        }    ])# 结果追踪到LangSmith# 生成雷达图，跨模型对比

两层断言：

• • 成功断言：硬失败，验证正确性
• • 效率断言：仅记录，不失败

---

九、设计哲学与安全模型

9.1 "信任LLM"安全模型

DeepAgents遵循**“信任LLM”**的安全模型：

• • 代理可以做工具允许的任何事情
• • 边界应该在工具和沙箱层强制执行
• • 不依赖模型自我约束

实践建议：

# 错误做法：期望模型自律# "请不要删除重要文件"# 正确做法：在工具层限制class SafeFilesystemBackend(BackendProtocol):    def write(self, path: str, content: str):        if path in PROTECTED_FILES:            raise PermissionError("无法写入受保护文件")        # 正常写入

9.2 开源与Provider无关

• • 100%开源：MIT许可证
• • Provider无关：支持任何支持工具调用的LLM
• • 基于LangGraph：生产级运行时特性

# 可以切换到任何模型agent = create_deep_agent(model="openai:gpt-4o")agent = create_deep_agent(model="gemini:gemini-pro")agent = create_deep_agent(model="ollama:llama3")

---

十、总结与展望

10.1 DeepAgents的核心价值

通过这篇文章，我们深入剖析了DeepAgents的技术架构：

1. 中间件系统：这是DeepAgents的灵魂，通过5层中间件实现了文件系统、子代理、摘要、记忆、技能等核心能力
2. 可插拔后端：BackendProtocol抽象让同一份代码可以在内存、本地磁盘、远程沙箱上运行
3. 基于LangGraph：利用编译状态图，获得流式响应、状态持久化、检查点恢复等生产级特性
4. 开箱即用：create_deep_agent()一行代码获得完整功能，同时保持高度可定制

10.2 与LangChain生态的关系

DeepAgents与LangChain、LangGraph形成清晰分工：

• • LangChain：基础的LLM工具链
• • LangGraph：工作流编排
• • DeepAgents：深度智能体框架

三者可以组合使用，构建复杂AI应用。

学AI大模型的正确顺序，千万不要搞错了

🤔2026年AI风口已来！各行各业的AI渗透肉眼可见，超多公司要么转型做AI相关产品，要么高薪挖AI技术人才，机遇直接摆在眼前！

有往AI方向发展，或者本身有后端编程基础的朋友，直接冲AI大模型应用开发转岗超合适！

就算暂时不打算转岗，了解大模型、RAG、Prompt、Agent这些热门概念，能上手做简单项目，也绝对是求职加分王🔋

📝给大家整理了超全最新的AI大模型应用开发学习清单和资料，手把手帮你快速入门！👇👇

学习路线:

✅大模型基础认知—大模型核心原理、发展历程、主流模型（GPT、文心一言等）特点解析
✅核心技术模块—RAG检索增强生成、Prompt工程实战、Agent智能体开发逻辑
✅开发基础能力—Python进阶、API接口调用、大模型开发框架（LangChain等）实操
✅应用场景开发—智能问答系统、企业知识库、AIGC内容生成工具、行业定制化大模型应用
✅项目落地流程—需求拆解、技术选型、模型调优、测试上线、运维迭代
✅面试求职冲刺—岗位JD解析、简历AI项目包装、高频面试题汇总、模拟面经

以上6大模块，看似清晰好上手，实则每个部分都有扎实的核心内容需要吃透！

我把大模型的学习全流程已经整理📚好了！抓住AI时代风口，轻松解锁职业新可能，希望大家都能把握机遇，实现薪资/职业跃迁～

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】