LangChain Deep Agents 从入门到企业实战

Java后端的Ai之路2026-09-08 13:00

一文搞懂LangChain Deep Agents：从入门到企业级实战，让你的Agent不再"浅尝辄止"

你是不是也遇到过这样的场景：花了半天时间用LangChain搭了一个Agent，结果让它"帮我调研一下2025年AI Agent框架的发展趋势并写一份报告"，它搜了两个网页就草草收场，输出的内容还不如你自己百度一下来得详细。Agent不是很智能吗？为什么一遇到复杂任务就"浅尝辄止"？

这篇文章，我们就来聊聊LangChain在2025年推出的重磅武器------Deep Agents，看看它是如何让Agent从"只能聊聊天"进化到"能独立完成复杂任务"的。全文从痛点出发，讲透原理、给出可运行代码、对比竞品、附上面试题，小白也能直接上手。

文章目录

  • [一文搞懂LangChain Deep Agents：从入门到企业级实战，让你的Agent不再"浅尝辄止"](#一文搞懂LangChain Deep Agents：从入门到企业级实战，让你的Agent不再"浅尝辄止")
    • 一、痛点场景：你的Agent是不是也"浅尝辄止"？
      • [1.1 一个真实的翻车现场](#1.1 一个真实的翻车现场)
      • [1.2 为什么传统Agent"深"不下去？](#1.2 为什么传统Agent"深"不下去？)
      • [1.3 生活中的类比](#1.3 生活中的类比)
    • [二、解决方案：Deep Agents的四大核心支柱](#二、解决方案：Deep Agents的四大核心支柱)
      • [2.1 Deep Agents是什么来头？](#2.1 Deep Agents是什么来头？)
      • [2.2 四大支柱详解](#2.2 四大支柱详解)
        • [支柱一：规划工具（Planning Tool）](#支柱一：规划工具（Planning Tool）)
        • [支柱二：文件系统（File System）](#支柱二：文件系统（File System）)
        • 支柱三：子智能体（Subagents）
        • [支柱四：详细提示词（Detailed Prompt）](#支柱四：详细提示词（Detailed Prompt）)
      • [2.3 四大支柱如何协同工作](#2.3 四大支柱如何协同工作)
    • [三、Deep Agents到底是什么](#三、Deep Agents到底是什么)
      • [3.1 官方定义](#3.1 官方定义)
      • [3.2 LangChain、LangGraph、Deep Agents三者关系](#3.2 LangChain、LangGraph、Deep Agents三者关系)
      • [3.3 核心特性一览](#3.3 核心特性一览)
    • [四、为什么要用Deep Agents](#四、为什么要用Deep Agents)
      • [4.1 它解决了什么实际问题](#4.1 它解决了什么实际问题)
      • [4.2 谁在用Deep Agents？](#4.2 谁在用Deep Agents？)
      • [4.3 什么时候不该用Deep Agents](#4.3 什么时候不该用Deep Agents)
    • [五、演进之路：从LangChain到Deep Agents](#五、演进之路：从LangChain到Deep Agents)
      • [5.1 第一阶段：LangChain时代（2022-2023）------积木式拼装](#5.1 第一阶段：LangChain时代（2022-2023）——积木式拼装)
      • [5.2 第二阶段：LangGraph时代（2023-2024）------图状态机](#5.2 第二阶段：LangGraph时代（2023-2024）——图状态机)
      • [5.3 第三阶段：多Agent框架涌现（2024）------百花齐放](#5.3 第三阶段：多Agent框架涌现（2024）——百花齐放)
      • [5.4 第四阶段：Deep Agents（2025至今）------开箱即用的深度Harness](#5.4 第四阶段：Deep Agents（2025至今）——开箱即用的深度Harness)
      • [5.5 演进的核心逻辑](#5.5 演进的核心逻辑)
    • 六、怎么用：从安装到实战
      • [6.1 环境准备](#6.1 环境准备)
      • [6.2 最简示例：5行代码创建深度Agent](#6.2 最简示例：5行代码创建深度Agent)
      • [6.3 实战一：带搜索能力的研究Agent](#6.3 实战一：带搜索能力的研究Agent)
      • [6.4 实战二：完整的深度研究Agent（带子智能体+规划）](#6.4 实战二：完整的深度研究Agent（带子智能体+规划）)
      • [6.5 实战三：自定义工具集成](#6.5 实战三：自定义工具集成)
      • [6.6 常见问题排查](#6.6 常见问题排查)
    • 七、常用场景教学
      • [7.1 场景一：深度研究报告生成](#7.1 场景一：深度研究报告生成)
      • [7.2 场景二：代码开发助手](#7.2 场景二：代码开发助手)
      • [7.3 场景三：数据分析与洞察](#7.3 场景三：数据分析与洞察)
      • [7.4 场景四：内容创作流水线](#7.4 场景四：内容创作流水线)
      • [7.5 场景五：客户服务与工单处理](#7.5 场景五：客户服务与工单处理)
      • [7.6 场景六：合规审查与风控](#7.6 场景六：合规审查与风控)
    • 八、企业项目中如何使用
    • [九、竞品对比：Deep Agents vs LangGraph vs CrewAI vs AutoGen](#九、竞品对比：Deep Agents vs LangGraph vs CrewAI vs AutoGen)
      • [9.1 核心对比表](#9.1 核心对比表)
      • [9.2 各框架优劣势详解](#9.2 各框架优劣势详解)
      • [9.3 选型决策树](#9.3 选型决策树)
    • 十、面试官高频面试题
      • [面试题1：什么是Deep Agents？它和普通Agent有什么区别？](#面试题1：什么是Deep Agents？它和普通Agent有什么区别？)
      • [面试题2：LangChain、LangGraph、Deep Agents三者是什么关系？](#面试题2：LangChain、LangGraph、Deep Agents三者是什么关系？)
      • [面试题3：Deep Agents的文件系统是如何工作的？它解决了什么问题？](#面试题3：Deep Agents的文件系统是如何工作的？它解决了什么问题？)
      • [面试题4：Deep Agents的子智能体是如何实现上下文隔离的？](#面试题4：Deep Agents的子智能体是如何实现上下文隔离的？)
      • [面试题5：Deep Agents的规划工具（write_todos）是如何工作的？它真的有必要吗？](#面试题5：Deep Agents的规划工具（write_todos）是如何工作的？它真的有必要吗？)
      • [面试题6：在生产环境中使用Deep Agents需要注意哪些问题？](#面试题6：在生产环境中使用Deep Agents需要注意哪些问题？)
      • [面试题7：Deep Agents和CrewAI怎么选？](#面试题7：Deep Agents和CrewAI怎么选？)
      • [面试题8：如何用Deep Agents实现一个深度研究Agent？请描述架构和关键代码。](#面试题8：如何用Deep Agents实现一个深度研究Agent？请描述架构和关键代码。)
      • [面试题9：Deep Agents支持哪些模型？如何切换模型？](#面试题9：Deep Agents支持哪些模型？如何切换模型？)
      • [面试题10：Deep Agents的局限性是什么？什么时候不应该用它？](#面试题10：Deep Agents的局限性是什么？什么时候不应该用它？)
    • 总结

一、痛点场景：你的Agent是不是也"浅尝辄止"？

1.1 一个真实的翻车现场

先来看一个很多人都踩过的坑。假设你写了下面这段最经典的LangChain Agent代码：

python 复制代码 
from langchain.agents import create_agent
from langchain_anthropic import ChatAnthropic
from langchain_community.tools import TavilySearchResults

llm = ChatAnthropic(model="claude-sonnet-4-5")
tools = [TavilySearchResults(max_results=5)]

agent = create_agent(model=llm, tools=tools)

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "帮我深度调研LangChain Deep Agents、CrewAI、AutoGen三个框架的优缺点，对比它们的架构差异，并给出企业选型建议，最后写成一份结构化报告。"
    }]
})
print(result["messages"][-1].content)

运行之后你会发现什么？大概率是这样的：

  • 它搜了一次"LangChain Deep Agents"，看了一眼摘要
  • 又搜了一次"CrewAI vs AutoGen"，看了一眼摘要
  • 然后直接开始写报告，内容全是搜索结果摘要的拼凑
  • 没有深入读取任何一篇文章的全文
  • 没有分模块对比，没有架构分析，没有选型建议
  • 整个过程不到30秒，输出的报告空洞无物

这就是典型的**"浅Agent"（Shallow Agent）**问题。

1.2 为什么传统Agent"深"不下去？

用大白话来说，传统的Agent就像一个刚入职的实习生：

  • 你让他写一份行业调研报告，他打开百度搜了两个关键词，复制粘贴几段话就交差了
  • 他不会先列个提纲，不会分章节去查，不会找多个信息源交叉验证
  • 他查着查着就忘了前面要干什么（上下文窗口有限）
  • 他不会把中间查到的资料先存下来，而是全部堆在脑子里，很快就"内存溢出"
  • 他也不会把任务拆给同事帮忙，所有事都自己扛

从技术角度看，传统Agent面临四大核心痛点：

痛点 具体表现 后果
缺乏长期规划能力 走一步看一步，没有任务拆解和待办清单 任务执行混乱，容易遗漏关键步骤
上下文管理困难 所有信息都塞进对话历史，很快超出token限制 重要信息被截断，Agent"失忆"
无法有效拆分任务 所有子任务都在同一个上下文里执行 互相干扰，无法并行，效率低下
缺少持久化工作区 中间结果无法保存，只能靠对话记忆 长任务无法持续，崩溃后全部丢失

1.3 生活中的类比

想象你要装修一套房子：

  • 传统Agent的做法：一个工人既当设计师又当泥瓦匠还当电工，脑子里同时记着所有图纸和材料清单，干着干着就忘了下一步该干啥，材料堆得满地都是找不到，最后装出来的房子四不像。
  • Deep Agents的做法：有一个项目经理（主管Agent）先列好装修计划（规划工具），有一个文件柜存放所有图纸和合同（文件系统），需要的时候派不同的专业工人（子智能体）分别去干水电、木工、油漆，每个工人只专注自己的活，干完把结果放回文件柜，最后项目经理汇总验收。

这就是Deep Agents要解决的核心问题------让Agent能够处理复杂、多步骤、长周期的任务。

二、解决方案：Deep Agents的四大核心支柱

2.1 Deep Agents是什么来头？

Deep Agents是LangChain创始人Harrison Chase在2025年7月正式提出的概念，并随后开源了deepagentsPython库。它的诞生受到了Claude Code、OpenAI Deep Research、Manus等产品的启发------这些产品之所以能完成复杂任务，本质上都用了相同的四件套。

Harrison Chase在官方博客中明确指出："Deep Agent的核心算法其实和普通Agent一样，都是LLM在循环中调用工具。区别在于它额外配备了四样东西：详细的系统提示词、规划工具、子智能体和文件系统。"

2.2 四大支柱详解

支柱一：规划工具（Planning Tool）

专业解释 ：Deep Agents内置了一个write_todos工具（通过TodoListMiddleware启用），Agent可以在执行任务前先创建待办清单，把大目标拆解成可执行的小步骤，并在执行过程中不断更新进度。

大白话：就像你每天上班先列一个to-do list，把"完成项目报告"拆成"收集资料、整理数据、撰写初稿、修改润色"四步，做完一项勾一项，不会干着干着就跑偏。

生活案例：你要做一顿红烧肉，先在手机备忘录里列好：1.买五花肉 2.焯水 3.炒糖色 4.炖煮 5.收汁。每做完一步就划掉，这样就不会出现"肉都下锅了才发现没买酱油"的尴尬。

关键代码：

python 复制代码 
from langchain.agents.middleware import TodoListMiddleware

# 通过中间件启用规划能力
agent = create_deep_agent(
    model=model,
    tools=[search_tool],
    middleware=[TodoListMiddleware()],  # 启用后Agent会自动使用write_todos
)
支柱二：文件系统（File System）

专业解释 ：Deep Agents提供了一套虚拟文件系统工具（write_file、read_file、list_dir等），Agent可以把中间结果、搜索到的资料、子任务的产出写入文件，需要时再读取。这本质上是一种上下文工程策略------把不常用的大文本从对话历史中卸载到文件里，从而管理有限的上下文窗口。

大白话：就像你有一个书桌，桌面上只能放几本书（上下文窗口），但你有一个文件柜（文件系统）可以存放所有资料。需要哪份资料就从文件柜里拿到桌面上，用完放回去，这样桌面永远不会乱。

生活案例：学生考试复习，不可能把整学期的笔记都摊在课桌上。他会把各科笔记放在书包里，复习数学时拿出数学笔记，复习完放回去再拿英语的。文件系统就是Agent的"书包"。

关键代码：

python 复制代码 
# Agent会自动使用以下内置文件工具，无需手动创建
# write_file(path, content)  - 写入文件
# read_file(path)            - 读取文件
# list_dir(path)             - 列出目录
# edit_file(path, ...)       - 编辑文件

# 示例：Agent在执行中可能自动做这样的操作
# write_file("/research_notes.md", "## 调研笔记\n...")
# read_file("/research_notes.md")
支柱三：子智能体（Subagents）

专业解释 ：Deep Agents内置了一个task工具，主管Agent可以动态创建临时的子智能体来执行独立的子任务。每个子智能体拥有全新的上下文环境 、独立的工具集和系统提示词，执行完毕后只返回最终结果给主管Agent。这实现了上下文隔离 和任务并行。

大白话：就像一个团队领导，不会自己干所有活，而是把任务分配给不同的下属。每个下属只知道自己的任务，不会被其他任务的信息干扰。领导可以同时派好几个人干活，最后汇总他们的成果。

生活案例：公司要办一场年会，行政主管不会自己一个人又找场地又买奖品又排节目。他会派A同事负责场地，B同事负责奖品，C同事负责节目编排，三个人同时干活，最后向主管汇报，主管汇总成完整方案。

关键代码：

python 复制代码 
# 定义子智能体配置
research_sub_agent = {
    "name": "research-agent",
    "description": "Delegate research to the sub-agent. Give one topic at a time.",
    "system_prompt": "You are a research assistant...",  # 子智能体的专属提示词
    "tools": [tavily_search],  # 子智能体的专属工具
}

# 创建主管Agent时注册子智能体
agent = create_deep_agent(
    model=model,
    tools=[tavily_search],
    subagents=[research_sub_agent],  # 注册子智能体
)
# 主管Agent会自动使用task工具派生子智能体
支柱四：详细提示词（Detailed Prompt）

专业解释 ：Deep Agents自带一套经过精心设计的系统提示词，其中包含了工具使用规范、行为准则、少样本示例（few-shot examples）等。用户可以通过system_prompt参数注入自定义指令，这些指令会被插入到完整的系统提示词中。

大白话：就像新员工入职时，公司会给他一本厚厚的员工手册，告诉他遇到什么情况该怎么处理、什么能做什么不能做、标准流程是什么。有了这本手册，新员工就不会乱来。

生活案例：你去海底捞吃饭，服务员之所以服务那么到位，是因为他们有一套详细的服务标准话术和流程手册。Deep Agents的系统提示词就是Agent的"服务手册"。

关键代码：

python 复制代码 
custom_instructions = """
You are an expert researcher. Your job is to conduct thorough research.

## Workflow
1. Use write_todos to plan your research
2. Save intermediate findings to files
3. Delegate sub-tasks to sub-agents
4. Synthesize a final report with citations
"""

agent = create_deep_agent(
    model=model,
    tools=[search_tool],
    system_prompt=custom_instructions,  # 自定义指令会被注入系统提示词
)

2.3 四大支柱如何协同工作

用一个完整的"深度调研"任务来看看四大支柱是怎么配合的：

text 复制代码 
用户："帮我调研三大Agent框架并写报告"
    │
    ▼
主管Agent启动
    │
    ├── ① 规划工具：write_todos创建待办清单
    │   ├── [ ] 调研Deep Agents
    │   ├── [ ] 调研CrewAI
    │   ├── [ ] 调研AutoGen
    │   └── [ ] 汇总对比写报告
    │
    ├── ② 文件系统：write_file保存用户需求到 /request.md
    │
    ├── ③ 子智能体：并行派出3个research子智能体
    │   ├── 子智能体A（全新上下文）→ 搜索Deep Agents → 结果写入 /deepagents.md
    │   ├── 子智能体B（全新上下文）→ 搜索CrewAI → 结果写入 /crewai.md
    │   └── 子智能体C（全新上下文）→ 搜索AutoGen → 结果写入 /autogen.md
    │
    ├── ② 文件系统：read_file读取三个子任务的结果文件
    │
    ├── ④ 详细提示词：按照报告规范整合内容、标注引用
    │
    └── ② 文件系统：write_file写入最终报告 /final_report.md
            │
            ▼
        返回报告给用户

看到了吗？这就是一个"深度Agent"的完整工作流------有计划、有存档、有分工、有规范。

三、Deep Agents到底是什么

3.1 官方定义

根据LangChain官方文档的定义：

Deep Agents是一个开源的Agent Harness（智能体 harness/工装），专为长时间运行的复杂任务而构建。它基于LangGraph构建，内置了任务规划、用于上下文管理的文件系统、子智能体派生能力以及详细的提示词，让你能够用更少的代码构建出能处理复杂多步骤任务的智能体。

关键词拆解：

  • Harness（工装/ harness）：它不是一个从零开始的框架，而是套在LangChain之上的"增强套件"，提供开箱即用的深度能力
  • 基于LangGraph：底层运行时是LangGraph，天然支持持久化、流式输出、人机交互
  • 开源：MIT协议，可自由商用
  • 更少的代码：原本需要自己写几百行的规划、文件管理、子智能体调度，现在几行配置就搞定

3.2 LangChain、LangGraph、Deep Agents三者关系

这是面试高频考点，必须搞清楚：

层级 名称 定位 大白话
最底层 LangGraph Agent运行时（Runtime） 发动机，提供持久化、流式、状态管理
中间层 LangChain Agent开发框架（Framework） 汽车底盘，提供模型、工具、链、记忆等组件
最上层 Deep Agents Agent Harness（工装） 整车出厂，自带规划、文件系统、子智能体、提示词

用造车来类比：

  • LangGraph是发动机和变速箱------决定了车能不能跑、能不能持久跑
  • LangChain是底盘和车身框架------提供了各种可以组装的零件
  • Deep Agents是直接卖给你的整车------发动机、底盘、空调、导航都装好了，你加个油（API Key）就能开

3.3 核心特性一览

python 复制代码 
# deepagents库的核心能力清单
from deepagents import create_deep_agent

# 1. 一行代码创建深度Agent（默认内置文件系统+子智能体+详细提示词）
agent = create_deep_agent(model="anthropic:claude-sonnet-4-6")

# 2. 支持多种模型提供商
# google_genai:gemini-3.6-flash
# openai:gpt-5.5
# anthropic:claude-sonnet-4-6
# openrouter:xxx
# fireworks:xxx
# ollama:xxx（本地模型）

# 3. 内置工具（自动可用，无需手动创建）
# - 文件操作：write_file, read_file, list_dir, edit_file
# - 子智能体派生：task
# - 规划：write_todos（需启用TodoListMiddleware）

# 4. 可定制项
# - model: 字符串或模型实例
# - tools: 自定义工具列表
# - subagents: 子智能体配置列表
# - system_prompt: 自定义系统指令
# - middleware: 中间件列表（如TodoListMiddleware）

四、为什么要用Deep Agents

4.1 它解决了什么实际问题

问题一：长任务执行到一半就"失忆"

传统Agent把所有信息都放在对话历史里，一个需要搜索20个网页的调研任务，光搜索结果就能撑爆上下文窗口。Deep Agents用文件系统把中间结果落盘，对话历史里只保留当前需要的信息，完美解决上下文溢出。

问题二：复杂任务不会拆解

传统Agent拿到一个大任务直接开干，没有规划。Deep Agents的write_todos工具强制Agent先拆解任务，就像项目经理先做WBS（工作分解结构）再执行。

问题三：多任务互相干扰

传统Agent在同一个上下文里处理所有子任务，调研A框架的信息会干扰对B框架的判断。Deep Agents的子智能体拥有独立上下文，互不干扰，还能并行执行。

问题四：生产环境不可观测

Deep Agents天然集成LangSmith，可以追踪每一步工具调用、子智能体派生、文件读写，方便调试和评估。

4.2 谁在用Deep Agents？

Deep Agents已经在多个知名企业的生产环境中落地：

  • 丰田北美：构建了GearPal应用，让产线技师用自然语言诊断机器人故障，减少非计划停机时间（每分钟停机损失高达数十万美元）"https://www.langchain.com/blog/how-toyota-north-america-put-enterprise-ai-on-the-balance-sheet-with-deep-agents-and-langsmith"
  • Rippling：在6个月内用Deep Agents实现了全产品线AI化，架构是一个主管Agent协调5到7个专用子智能体"https://www.langchain.com/blog/how-rippling-went-ai-native-across-every-product-in-6-months-with-deep-agents-and-langsmith"
  • Harmonic：用Deep Agents重构了Scout产品，用户留存率提升了4倍"https://www.langchain.com/blog/how-harmonic-rebuilt-scout-on-deep-agents-and-4xd-retention-with-langsmith"
  • NVIDIA：将Nemotron模型与Deep Agents结合，Abridge、Amdocs、Box等企业正在把专用智能体嵌入平台"https://blogs.nvidia.cn/blog/nemotron-langchain-agents-open-stack/"

4.3 什么时候不该用Deep Agents

不是所有场景都需要Deep Agents，以下情况用普通LangChain Agent就够了：

  • 单轮问答、简单聊天机器人
  • 只需要调用一两个工具的简单任务（如查天气、翻译）
  • 对延迟要求极高、不能接受多轮推理的场景
  • 任务流程完全固定、不需要动态规划的场景（用LangGraph硬编码流程图更好）

五、演进之路：从LangChain到Deep Agents

5.1 第一阶段：LangChain时代（2022-2023）------积木式拼装

2022年底，LangChain诞生。它的核心理念是"组合"------把模型、工具、提示词、记忆等组件像乐高积木一样拼在一起，形成Chain（链）。

python 复制代码 
# 早期LangChain的链式调用
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

chain = LLMChain(llm=llm, prompt=prompt)
result = chain.run({"input": "你好"})

特点：组件丰富、上手快，但Chain是线性的，不擅长处理循环和条件分支，Agent的执行过程像个黑盒。

5.2 第二阶段：LangGraph时代（2023-2024）------图状态机

随着Agent任务越来越复杂，线性的Chain不够用了。2023年LangGraph发布，它把Agent的执行过程建模为有向图------节点是操作，边是状态转移，状态在图中流动。

python 复制代码 
# LangGraph的图式编排
from langgraph.graph import StateGraph, END

graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
graph.add_node("tools", tool_node)
graph.add_edge("agent", "tools")
graph.add_edge("tools", "agent")
# 支持循环、条件分支、检查点持久化

特点：强大的状态管理、持久化、人机交互，但需要开发者自己设计图结构，学习曲线较陡。

5.3 第三阶段：多Agent框架涌现（2024）------百花齐放

2024年，CrewAI、AutoGen、MetaGPT等多Agent框架纷纷出现，主打"角色分工"和"团队协作"。

python 复制代码 
# CrewAI的角色式多Agent
from crewai import Agent, Task, Crew

researcher = Agent(role="研究员", goal="收集信息", ...)
writer = Agent(role="作家", goal="撰写报告", ...)
crew = Crew(agents=[researcher, writer], tasks=[...])

特点：上手快、角色概念直观，但大多缺乏生产级的持久化和可观测能力，执行过程不够可控。

5.4 第四阶段：Deep Agents（2025至今）------开箱即用的深度Harness

2025年7月，Harrison Chase正式提出Deep Agents概念并开源deepagents库。它站在LangChain和LangGraph的肩膀上，把"深度Agent"所需的四大能力做成了开箱即用的标准配置。

python 复制代码 
# Deep Agents：一行代码搞定深度Agent
from deepagents import create_deep_agent

agent = create_deep_agent(model="anthropic:claude-sonnet-4-6")
result = agent.invoke({"messages": [{"role": "user", "content": "复杂任务..."}]})

特点：在LangGraph的可靠运行时之上，提供了规划、文件系统、子智能体、详细提示词的"全家桶"，既保留了生产级能力，又大幅降低了使用门槛。

5.5 演进的核心逻辑

整个演进过程其实是在回答一个问题：如何让Agent处理越来越复杂的任务？

text 复制代码 
LangChain  →  解决"能不能用工具"的问题
LangGraph  →  解决"能不能持久可靠地循环执行"的问题
多Agent框架 →  解决"能不能分工协作"的问题
Deep Agents →  解决"能不能开箱即用地完成复杂长周期任务"的问题

六、怎么用：从安装到实战

6.1 环境准备

首先安装依赖：

bash 复制代码 
pip install deepagents

如果你需要用Tavily做搜索（非Google/OpenAI/Anthropic内置搜索时），再安装：

bash 复制代码 
pip install tavily-python

配置API密钥：

bash 复制代码 
# 选择一个模型提供商的密钥
export ANTHROPIC_API_KEY="your-api-key"
# 或
export OPENAI_API_KEY="your-api-key"
# 或
export GOOGLE_API_KEY="your-api-key"

# 可选：LangSmith追踪（强烈建议开启，方便调试）
export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-langsmith-api-key"

# 可选：Tavily搜索密钥
export TAVILY_API_KEY="your-tavily-api-key"

6.2 最简示例：5行代码创建深度Agent

这是最小可运行示例，使用Anthropic Claude模型和内置搜索：

python 复制代码 
# agent_minimal.py
from deepagents import create_deep_agent

# 一行代码创建深度Agent，自动内置文件系统+子智能体+详细提示词
agent = create_deep_agent(model="anthropic:claude-sonnet-4-6")

# 运行Agent
result = agent.invoke({
    "messages": [{"role": "user", "content": "帮我列出当前目录下的文件，并统计每个文件的行数"}]
})

# 输出结果
print(result["messages"][-1].content)

就这么简单。这个Agent已经具备了：

  • 读写文件的能力（write_file、read_file等）
  • 派生子智能体的能力（task）
  • 详细的系统提示词指导

6.3 实战一：带搜索能力的研究Agent

下面构建一个能联网搜索并撰写报告的研究Agent，使用Google内置搜索（无需额外安装搜索包）：

python 复制代码 
# research_agent.py
from deepagents import create_deep_agent

# Google内置搜索，无需额外安装或API密钥
internet_search = {"google_search": {}}

# 自定义系统提示词，指导Agent如何做研究
research_instructions = """You are an expert researcher. Your job is to conduct thorough research and then write a polished report.

You have access to an internet search tool as your primary means of gathering information.

## internet_search
Use this to run an internet search for a given query. You can specify the max number of results to return, the topic, and whether raw content should be included.

## Workflow
1. Break down the research question into sub-topics
2. Search for each sub-topic thoroughly
3. Save intermediate findings to files using write_file
4. Synthesize all findings into a comprehensive report
5. Write the final report to /final_report.md
"""

# 创建深度研究Agent
agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    tools=[internet_search],
    system_prompt=research_instructions,
)

# 运行
if __name__ == "__main__":
    result = agent.invoke({
        "messages": [{
            "role": "user",
            "content": "调研2025年AI Agent框架的发展趋势，重点关注LangChain Deep Agents、CrewAI和AutoGen，写成一份结构化报告。"
        }]
    })
    print(result["messages"][-1].content)

运行：

bash 复制代码 
python research_agent.py

6.4 实战二：完整的深度研究Agent（带子智能体+规划）

这是最接近生产环境的完整实现，包含自定义搜索工具、子智能体、规划中间件、详细工作流提示词。

第一步：创建自定义搜索工具

python 复制代码 
# tools.py
import os
from typing import Annotated, Literal

import httpx
from langchain.tools import InjectedToolArg, tool
from markdownify import markdownify
from tavily import TavilyClient

tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])


def fetch_webpage_content(url: str, timeout: float = 10.0) -> str:
    """抓取网页并将HTML转换为Markdown。"""
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
    }
    try:
        response = httpx.get(url, headers=headers, timeout=timeout)
        response.raise_for_status()
        return markdownify(response.text)
    except Exception as e:
        return f"Error fetching {url}: {e!s}"


@tool(parse_docstring=True)
def tavily_search(
    query: str,
    max_results: Annotated[int, InjectedToolArg] = 1,
    topic: Annotated[Literal["general", "news", "finance"], InjectedToolArg] = "general",
) -> str:
    """搜索网络信息。

    使用Tavily发现相关URL，然后抓取并返回完整网页内容（Markdown格式）。

    Args:
        query: 搜索关键词
        max_results: 最大返回结果数（默认1）
        topic: 主题过滤 - 'general'、'news'或'finance'（默认'general'）

    Returns:
        格式化的搜索结果，包含完整网页内容
    """
    search_results = tavily_client.search(
        query,
        max_results=max_results,
        topic=topic,
    )

    result_texts = []
    for result in search_results.get("results", []):
        url = result["url"]
        title = result["title"]
        content = fetch_webpage_content(url)
        result_texts.append(f"## {title}\n**URL:** {url}\n\n{content}\n---")

    return f"Found {len(result_texts)} result(s) for '{query}':\n\n" + "\n".join(result_texts)

第二步：定义提示词模板

python 复制代码 
# prompts.py
RESEARCH_WORKFLOW_INSTRUCTIONS = """# Research Workflow

Follow this workflow for all research requests:

1. **Plan**: Create a todo list with write_todos to break down the research into focused tasks
2. **Save the request**: Use write_file() to save the user's research question to /research_request.md
3. **Research**: Delegate research tasks to sub-agents using the task() tool - ALWAYS use sub-agents for research, never conduct research yourself
4. **Synthesize**: Review all sub-agent findings and consolidate citations
5. **Write Report**: Write a comprehensive final report to /final_report.md
6. **Verify**: Read /research_request.md and confirm you've addressed all aspects

## Research Planning Guidelines
- Batch similar research tasks into a single TODO to minimize overhead
- For simple fact-finding questions, use 1 sub-agent
- For comparisons or multi-faceted topics, delegate to multiple parallel sub-agents

## Report Writing Guidelines
- Use clear section headings (## for sections, ### for subsections)
- Write in paragraph form - be text-heavy, not just bullet points
- Cite sources inline using [1], [2], [3] format
- End report with ### Sources section listing each numbered source
"""

RESEARCHER_INSTRUCTIONS = """You are a research assistant conducting research on the user's input topic. For context, today's date is {date}.

Your job is to use tools to gather information about the user's input topic.

Think like a human researcher with limited time:
1. Read the question carefully
2. Start with broader searches
3. After each search, pause and assess - do I have enough?
4. Execute narrower searches to fill gaps
5. Stop when you can answer confidently

**Tool Call Budgets**:
- Simple queries: 2-3 search calls maximum
- Complex queries: up to 5 search calls maximum

**Stop Immediately When**:
- You can answer comprehensively
- You have 3+ relevant sources
- Your last 2 searches returned similar information

When returning findings:
1. Structure with clear headings
2. Cite sources inline using [1], [2] format
3. End with ### Sources section
"""

SUBAGENT_DELEGATION_INSTRUCTIONS = """# Sub-Agent Research Coordination

## Delegation Strategy
**DEFAULT: Start with 1 sub-agent** for most queries.

**ONLY parallelize when the query EXPLICITLY requires comparison:**
- "Compare A vs B vs C" -> 3 parallel sub-agents
- "Compare A vs B" -> 2 parallel sub-agents

## Key Principles
- Bias towards single sub-agent: one comprehensive task is more token-efficient
- Avoid premature decomposition
- Parallelize only for clear comparisons

## Parallel Execution Limits
- Use at most {max_concurrent_research_units} parallel sub-agents per iteration
"""

第三步：组装完整Agent

python 复制代码 
# deep_research_agent.py
from datetime import datetime

from deepagents import create_deep_agent
from langchain.agents.middleware import TodoListMiddleware
from langchain.chat_models import init_chat_model

from tools import tavily_search
from prompts import (
    RESEARCH_WORKFLOW_INSTRUCTIONS,
    RESEARCHER_INSTRUCTIONS,
    SUBAGENT_DELEGATION_INSTRUCTIONS,
)

# 配置参数
max_concurrent_research_units = 3
max_researcher_iterations = 3
current_date = datetime.now().strftime("%Y-%m-%d")

# 组装系统提示词
INSTRUCTIONS = (
    RESEARCH_WORKFLOW_INSTRUCTIONS
    + "\n\n"
    + "=" * 80
    + "\n\n"
    + SUBAGENT_DELEGATION_INSTRUCTIONS.format(
        max_concurrent_research_units=max_concurrent_research_units,
        max_researcher_iterations=max_researcher_iterations,
    )
)

# 定义研究子智能体
research_sub_agent = {
    "name": "research-agent",
    "description": "Delegate research to the sub-agent. Give one topic at a time.",
    "system_prompt": RESEARCHER_INSTRUCTIONS.format(date=current_date),
    "tools": [tavily_search],
}

# 初始化模型
model = init_chat_model(model="anthropic:claude-sonnet-4-5-20250929", temperature=0.0)

# 创建深度Agent
agent = create_deep_agent(
    model=model,
    tools=[tavily_search],
    system_prompt=INSTRUCTIONS,
    subagents=[research_sub_agent],
    middleware=[TodoListMiddleware()],  # 启用规划工具
)

第四步：运行（同步+流式两种方式）

python 复制代码 
# run.py
from langchain.messages import HumanMessage
from deep_research_agent import agent

# 方式一：同步运行
if __name__ == "__main__":
    result = agent.invoke({
        "messages": [
            HumanMessage(
                content="对比RAG和Fine-tuning在LLM应用中的优缺点，给出选型建议。"
            )
        ]
    })

    for msg in result.get("messages", []):
        if hasattr(msg, "content") and msg.content:
            print(msg.content)
python 复制代码 
# run_stream.py
from langchain.messages import HumanMessage
from deep_research_agent import agent

# 方式二：流式输出（实时看到Agent的思考过程）
if __name__ == "__main__":
    stream = agent.stream_events(
        {
            "messages": [
                HumanMessage(content="对比Python vs JavaScript用于Web开发的优劣")
            ]
        },
        version="v3",
    )

    for message in stream.messages:
        for token in message.text:
            print(token, end="", flush=True)

运行：

bash 复制代码 
python run.py
# 或
python run_stream.py

6.5 实战三：自定义工具集成

Deep Agents可以轻松接入你自己的业务工具。下面演示如何添加一个数据库查询工具：

python 复制代码 
# custom_tools.py
from langchain.tools import tool
import sqlite3


@tool
def query_database(sql: str) -> str:
    """执行SQL查询并返回结果。

    Args:
        sql: 要执行的SQL查询语句

    Returns:
        查询结果的字符串表示
    """
    conn = sqlite3.connect("company.db")
    cursor = conn.cursor()
    try:
        cursor.execute(sql)
        results = cursor.fetchall()
        columns = [desc[0] for desc in cursor.description]
        output = " | ".join(columns) + "\n"
        output += "-" * 50 + "\n"
        for row in results:
            output += " | ".join(str(v) for v in row) + "\n"
        return output
    except Exception as e:
        return f"Query error: {e}"
    finally:
        conn.close()


@tool
def send_email(to: str, subject: str, body: str) -> str:
    """发送邮件。

    Args:
        to: 收件人邮箱
        subject: 邮件主题
        body: 邮件正文

    Returns:
        发送状态
    """
    # 实际项目中这里调用邮件服务API
    return f"Email sent to {to} with subject '{subject}'"
python 复制代码 
# 使用自定义工具
from deepagents import create_deep_agent
from custom_tools import query_database, send_email

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    tools=[query_database, send_email],  # 传入自定义工具
    system_prompt="""You are a data analyst assistant.
    Use query_database to fetch data and send_email to send reports.
    Always verify SQL before executing.""",
)

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "查询上个月销售额最高的5个产品，把结果发到manager@company.com"
    }]
})
print(result["messages"][-1].content)

6.6 常见问题排查

问题 原因 解决方案
Agent不使用子智能体 提示词中没有明确要求 在system_prompt中明确指示"ALWAYS use sub-agents for research"
Agent不创建待办清单 没有启用TodoListMiddleware 添加middleware=[TodoListMiddleware()]
上下文溢出 搜索结果太大没有写入文件 在提示词中要求"Save intermediate findings to files"
子智能体返回空结果 子智能体工具配置错误 检查subagents配置中的tools列表
模型不支持工具调用 使用了不支持function calling的模型 更换为支持工具调用的模型

七、常用场景教学

7.1 场景一：深度研究报告生成

适用场景：市场调研、竞品分析、技术选型、学术综述

为什么适合Deep Agents：研究任务需要多源检索、信息交叉验证、分章节撰写、引用标注，正好匹配规划+子智能体+文件系统的组合。

核心配置要点：

  • 启用TodoListMiddleware做任务规划
  • 配置研究子智能体，每个子智能体负责一个主题
  • 用文件系统保存各章节草稿
  • 提示词中明确引用格式规范
python 复制代码 
# 深度研究Agent的关键配置
agent = create_deep_agent(
    model=model,
    tools=[tavily_search],
    subagents=[research_sub_agent],
    middleware=[TodoListMiddleware()],
    system_prompt=RESEARCH_WORKFLOW_INSTRUCTIONS,
)

7.2 场景二：代码开发助手

适用场景：多文件项目开发、代码重构、Bug修复、代码审查

为什么适合Deep Agents：编程任务需要读取多个文件、修改代码、运行测试、迭代修复，文件系统是刚需，子智能体可以分别处理不同模块。

核心配置要点：

  • 利用内置文件工具读写代码文件
  • 可以配置"测试子智能体"专门运行测试
  • 提示词中加入代码规范和测试要求
python 复制代码 
coding_instructions = """You are a senior software engineer.

## Workflow
1. Read existing files to understand the codebase
2. Plan changes using write_todos
3. Implement changes using edit_file or write_file
4. Delegate testing to the test-subagent
5. Fix any issues found during testing
6. Write a summary of changes to /CHANGES.md
"""

7.3 场景三：数据分析与洞察

适用场景：销售数据分析、用户行为分析、财务报表生成、异常检测

为什么适合Deep Agents：数据分析需要连接数据库、清洗数据、生成图表、撰写洞察报告，是典型的多步骤任务。

核心配置要点：

  • 自定义数据库查询工具
  • 子智能体分别负责数据提取、分析、可视化
  • 文件系统保存中间数据和图表
python 复制代码 
# 数据分析Agent示例
agent = create_deep_agent(
    model=model,
    tools=[query_database, run_python_code],
    subagents=[
        {"name": "data-extractor", "tools": [query_database], ...},
        {"name": "data-analyst", "tools": [run_python_code], ...},
    ],
    middleware=[TodoListMiddleware()],
)

7.4 场景四：内容创作流水线

适用场景：公众号文章撰写、产品文档生成、营销文案、多语言内容本地化

为什么适合Deep Agents：内容创作需要选题、调研、大纲、撰写、校对、排版多个环节，子智能体可以分别扮演研究员、撰稿人、校对员。

python 复制代码 
# 内容创作子智能体配置
content_subagents = [
    {"name": "researcher", "system_prompt": "负责收集素材和数据...", "tools": [search]},
    {"name": "writer", "system_prompt": "负责撰写正文...", "tools": []},
    {"name": "editor", "system_prompt": "负责校对和优化...", "tools": []},
]

7.5 场景五：客户服务与工单处理

适用场景：复杂售后问题处理、多系统工单流转、客户投诉处理

为什么适合Deep Agents：客服问题往往需要查询订单、联系物流、核实库存、生成解决方案，涉及多个内部系统的协调。

python 复制代码 
# 客服Agent工具配置
customer_service_tools = [
    query_order_status,    # 查订单
    query_logistics,       # 查物流
    create_refund_ticket,  # 创建退款工单
    escalate_to_human,     # 转人工
]

7.6 场景六：合规审查与风控

适用场景：合同审查、合规检查、反欺诈分析、监管报告生成

为什么适合Deep Agents：合规审查需要逐条比对法规、检查文档、生成风险报告，对准确性和可追溯性要求高，文件系统保证审查过程可回溯。

八、企业项目中如何使用

8.1 企业级架构设计

在企业项目中使用Deep Agents，不能只跑一个简单的agent.invoke()，需要考虑架构设计。推荐的分层架构如下：

text 复制代码 
┌─────────────────────────────────────────────────┐
│                   接入层                          │
│   Web UI / API网关 / 企业IM / 邮件触发             │
└────────────────────┬────────────────────────────┘
                     │
┌────────────────────▼────────────────────────────┐
│              Deep Agent 主管智能体                 │
│   （任务规划 + 子智能体调度 + 结果汇总）            │
│                                                  │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐       │
│  │ 研究子智能体│  │ 执行子智能体│  │ 审核子智能体│       │
│  │(信息检索)  │  │(工具执行)  │  │(质量把关)  │       │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘       │
└───────┼──────────────┼──────────────┼────────────┘
        │              │              │
┌───────▼──────────────▼──────────────▼────────────┐
│                    工具层                          │
│  企业知识库 │ 数据库 │ 内部API │ 文件存储 │ 搜索    │
└─────────────────────────────────────────────────┘
         │                    │
┌────────▼────────┐  ┌────────▼────────┐
│  LangSmith       │  │  安全与权限      │
│  (追踪/评估/监控) │  │  (沙箱/鉴权/审计)│
└─────────────────┘  └─────────────────┘

8.2 企业级关键配置代码

python 复制代码 
# enterprise_agent.py
import os
from deepagents import create_deep_agent
from langchain.agents.middleware import TodoListMiddleware
from langchain.chat_models import init_chat_model
from langchain.checkpoint import Checkpointer

# 1. 模型配置：使用企业部署的模型
model = init_chat_model(
    model="anthropic:claude-sonnet-4-5-20250929",
    temperature=0.0,  # 企业场景降低随机性
    max_tokens=8192,
)

# 2. 企业内部工具
from enterprise_tools import (
    query_knowledge_base,   # 企业知识库检索
    query_internal_api,     # 内部系统API
    access_file_storage,    # 文件存储
    human_approval,         # 人工审批节点
)

enterprise_tools = [
    query_knowledge_base,
    query_internal_api,
    access_file_storage,
    human_approval,
]

# 3. 子智能体配置：按职责划分
research_subagent = {
    "name": "research-specialist",
    "description": "负责信息检索和资料整理",
    "system_prompt": "你是企业研究员，负责从知识库和网络收集信息...",
    "tools": [query_knowledge_base],
}

execution_subagent = {
    "name": "execution-specialist",
    "description": "负责调用内部API执行具体操作",
    "system_prompt": "你是执行专员，负责调用内部系统完成操作...",
    "tools": [query_internal_api, access_file_storage],
}

review_subagent = {
    "name": "review-specialist",
    "description": "负责结果审核和质量把关",
    "system_prompt": "你是审核员，负责检查结果的准确性和合规性...",
    "tools": [],
}

# 4. 企业级系统提示词
enterprise_instructions = """你是企业级智能助手，必须遵守以下规则：

## 安全规则
1. 涉及资金、数据删除、权限变更等高危操作，必须调用human_approval获取人工审批
2. 不得泄露其他用户的隐私数据
3. 所有操作必须可追溯，关键步骤写入/audit_log.md

## 执行规范
1. 先用write_todos制定执行计划
2. 复杂任务必须派生子智能体并行处理
3. 中间结果必须写入文件系统
4. 最终结果必须经过review-specialist审核

## 输出规范
1. 结果必须包含数据来源
2. 不确定的信息必须标注"待核实"
3. 报告格式遵循企业模板
"""

# 5. 创建企业级Deep Agent
agent = create_deep_agent(
    model=model,
    tools=enterprise_tools,
    subagents=[research_subagent, execution_subagent, review_subagent],
    system_prompt=enterprise_instructions,
    middleware=[TodoListMiddleware()],
    # 持久化配置（生产环境必须）
    # checkpointer=checkpointer,  # 传入LangGraph检查点
)

8.3 生产部署最佳实践

实践一：启用LangSmith可观测性
bash 复制代码 
# 环境变量配置
export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-api-key"
export LANGSMITH_PROJECT="enterprise-agent-prod"
python 复制代码 
# 代码中评估Agent表现
from langsmith import evaluate

# 定义评估数据集
eval_data = [
    {"input": "查询Q3销售额", "expected": "包含具体数字和同比"},
    {"input": "生成合规报告", "expected": "包含风险评级和建议"},
]

# 运行评估
evaluate(
    lambda x: agent.invoke({"messages": [{"role": "user", "content": x["input"]}]}),
    data=eval_data,
    evaluators=[accuracy_evaluator, compliance_evaluator],
)
实践二：持久化与断点续跑
python 复制代码 
# 配置检查点，支持任务中断后恢复
from langgraph.checkpoint.memory import MemorySaver

checkpointer = MemorySaver()

agent = create_deep_agent(
    model=model,
    tools=tools,
    subagents=subagents,
    middleware=[TodoListMiddleware()],
    # checkpointer=checkpointer,  # 生产环境用数据库检查点
)

# 带thread_id运行，支持中断恢复
config = {"configurable": {"thread_id": "task-001"}}
result = agent.invoke({"messages": [...]}, config=config)
实践三：人工审核节点
python 复制代码 
from langchain.tools import tool

@tool
def human_approval(action: str, details: str) -> str:
    """请求人工审批。

    Args:
        action: 待审批的操作描述
        details: 操作详情

    Returns:
        审批结果：approved / rejected
    """
    # 实际项目中：发送审批请求到企业IM/邮件
    # 等待人工响应后返回结果
    return f"Action '{action}' is pending approval. Details: {details}"
实践四：沙箱环境隔离
yaml 复制代码 
# docker-compose.yml 生产部署示例
version: "3.8"
services:
  deep-agent:
    build: .
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - LANGSMITH_TRACING=true
      - LANGSMITH_API_KEY=${LANGSMITH_API_KEY}
    volumes:
      - agent-workspace:/workspace  # 文件系统持久化
    security_opt:
      - no-new-privileges:true      # 安全加固
    read_only: true                  # 只读根文件系统
    deploy:
      replicas: 3                   # 多实例部署
      resources:
        limits:
          cpus: "2"
          memory: 4G

volumes:
  agent-workspace:

8.4 企业落地的踩坑经验

  1. 不要一开始就追求全自动：先从"Agent辅助+人工审核"的模式开始，逐步建立信任后再放开自动化程度
  2. 工具权限最小化：每个子智能体只给它完成任务所需的最少工具，避免误操作
  3. 成本控制：深度Agent的token消耗是普通Agent的5-10倍，需要设置最大迭代次数和预算告警
  4. 提示词版本管理：系统提示词是Agent的"灵魂"，每次修改都要记录版本并做回归测试
  5. 失败兜底：Agent执行失败时要有明确的降级策略（如转人工、返回模板答案）

九、竞品对比：Deep Agents vs LangGraph vs CrewAI vs AutoGen

9.1 核心对比表

对比维度 Deep Agents LangGraph CrewAI AutoGen
定位 Agent Harness（上层工装） Agent运行时（底层引擎） 角色式多Agent框架 对话式多Agent框架
出品方 LangChain LangChain CrewAI Inc. Microsoft
开源协议 MIT MIT MIT MIT（已进入维护模式）
架构层次 基于LangChain+LangGraph 图状态机 Agent+Task+Crew 多Agent对话
学习曲线 中等 较高 低 中等
规划能力 内置write_todos 需自行实现 内置任务分解 需自行实现
文件系统 内置虚拟文件系统 无（需自己实现） 无 无
子智能体 内置task工具，上下文隔离 支持子图 内置角色Agent 内置多Agent对话
持久化 天然支持（LangGraph） 原生支持检查点 有限支持 有限支持
流式输出 支持 支持 支持 支持
可观测性 深度集成LangSmith 集成LangSmith 需自行接入 需自行接入
人机交互 支持（LangGraph） 原生支持 需自定义 Human Proxy模式
模型支持 多模型（LangChain生态） 多模型 多模型 多模型
生产就绪度 高 很高 中等 中等（维护模式）
最佳场景 长周期复杂任务、研究、编码 状态流编排、确定性流程 快速原型、角色协作 研究辩论、多Agent讨论

9.2 各框架优劣势详解

Deep Agents

优势：

  • 开箱即用，一行代码创建深度Agent
  • 四大支柱（规划、文件系统、子智能体、提示词）全部内置
  • 基于LangGraph，生产级持久化和可观测性
  • LangChain生态完善，工具和模型支持最广泛
  • 企业案例丰富（丰田、Rippling、Harmonic等）

劣势：

  • 相对较新（2025年发布），API可能还有变动
  • 高度依赖LangChain生态，脱离LangChain使用较困难
  • 对简单任务来说有点"杀鸡用牛刀"
LangGraph

优势：

  • 最灵活，完全控制执行流程
  • 原生支持持久化、人机交互、流式输出
  • 生产验证最充分
  • 是Deep Agents的底层引擎

劣势：

  • 学习曲线陡峭，需要自己设计图结构
  • 规划、文件系统等能力需要自己实现
  • 代码量较大，简单任务用起来繁琐
CrewAI

优势：

  • 上手最快，Agent+Task+Crew三要素概念直观
  • 角色扮演模式适合业务人员理解
  • 内置顺序/层级/共识三种协作模式
  • 社区活跃，文档友好

劣势：

  • 生产级持久化和可观测性较弱
  • 执行过程不够可控，调试困难
  • 复杂任务的可靠性不如LangGraph系
  • 2025年v1.0后移除了LangChain硬依赖，但生态仍在建设中
AutoGen

优势：

  • 对话式多Agent模式自然，适合辩论和讨论场景
  • 微软背书，学术研究丰富
  • Human Proxy Agent模式支持人机协作

劣势：

  • 已进入维护模式，微软转向更广泛的Agent Framework
  • 生产部署能力较弱
  • 缺乏内置的规划和文件系统
  • 中文社区资源相对较少

9.3 选型决策树

text 复制代码 
你的任务是什么类型？
│
├── 简单单轮问答/工具调用
│   └── 用普通LangChain Agent即可，不需要Deep Agents
│
├── 流程固定、需要精确控制的状态流
│   └── 直接用LangGraph，自己画图最可靠
│
├── 快速原型验证、角色分工明确
│   └── CrewAI上手最快
│
├── 多Agent辩论/研究讨论
│   └── AutoGen适合（但注意维护状态）
│
└── 复杂、多步骤、长周期任务（研究/编码/分析）
    ├── 需要生产级可靠性和可观测性
    │   └── Deep Agents（首选）
    └── 只做Demo不考虑生产
        └── CrewAI也可以

一句话总结：如果你要在企业里做能真正跑起来的复杂Agent，Deep Agents是目前综合最优的选择------它在"开箱即用"和"生产可靠"之间找到了最好的平衡点。

十、面试官高频面试题

面试题1：什么是Deep Agents？它和普通Agent有什么区别？

参考答案：

Deep Agents是LangChain推出的开源Agent Harness，专为复杂、多步骤、长周期任务设计。它基于LangGraph构建，内置四大核心能力：规划工具（write_todos）、文件系统（虚拟文件读写）、子智能体（上下文隔离的task派生）、详细提示词（内置工作流规范）。

和普通Agent的核心区别在于：普通Agent只是"LLM+工具调用循环"，缺乏长期规划能力，上下文容易溢出，任务无法有效拆分；而Deep Agents通过四大支柱系统性地解决了这些问题，让Agent能够"深入"处理复杂任务而不是"浅尝辄止"。

面试题2：LangChain、LangGraph、Deep Agents三者是什么关系？

参考答案：

三者是分层关系，从下到上依次是：

  • LangGraph是最底层的Agent运行时（Runtime），提供图状态机、持久化检查点、流式输出、人机交互等核心能力
  • LangChain是中间层的开发框架（Framework），提供模型封装、工具接口、链、记忆等组件
  • Deep Agents是最上层的Harness（工装），在LangChain和LangGraph之上封装了规划、文件系统、子智能体、详细提示词等开箱即用的深度能力

用造车类比：LangGraph是发动机，LangChain是底盘，Deep Agents是整车。

面试题3：Deep Agents的文件系统是如何工作的？它解决了什么问题？

参考答案：

Deep Agents的文件系统是一套虚拟文件工具（write_file、read_file、list_dir、edit_file），它基于LangGraph的State实现，将文件内容存储在Agent的状态中而不是真实磁盘上。

它解决的核心问题是上下文管理。传统Agent把所有信息都放在对话历史里，长任务很快就会超出上下文窗口限制。文件系统允许Agent把中间结果、大段搜索结果、子任务产出写入"文件"，需要时再读取，从而将不活跃的信息从对话上下文中卸载出去，有效管理有限的token预算。

这本质上是一种上下文工程策略------用存储空间换取上下文空间。

面试题4：Deep Agents的子智能体是如何实现上下文隔离的？

参考答案：

Deep Agents通过内置的task工具派生子智能体。每次调用task时，会创建一个全新的Agent实例，这个实例拥有：

  • 独立的对话历史（从空白开始）
  • 独立的工具集（在subagents配置中指定）
  • 独立的系统提示词
  • 独立的文件系统命名空间

子智能体自主执行直到完成，然后只返回最终结果给主管Agent。主管Agent的上下文不会被子智能体的中间过程污染。这种隔离确保了：

  1. 不同子任务的信息不会互相干扰
  2. 可以并行执行多个子智能体
  3. 主管Agent的上下文不会因为子任务的细节而膨胀

面试题5：Deep Agents的规划工具（write_todos）是如何工作的？它真的有必要吗？

参考答案：

write_todos是一个"no-op"工具------它本身不执行任何实际操作，只是把待办清单存储在Agent的状态中。但它的价值在于上下文工程：

  1. 强制Agent在执行前先思考和拆解任务，将大目标分解为可执行的小步骤
  2. 待办清单会持续存在于上下文中，提醒Agent当前进度和下一步该做什么，防止"跑偏"
  3. Agent可以在执行中更新待办状态（标记完成、添加新项），实现动态规划

Harrison Chase在博客中明确提到，Claude Code的Todo list工具也是一个no-op，但它对Agent保持任务聚焦至关重要。规划工具的价值不在于"做了什么"，而在于"让Agent想清楚该做什么"。

面试题6：在生产环境中使用Deep Agents需要注意哪些问题？

参考答案：

生产环境部署需要关注以下几点：

  1. 可观测性：必须开启LangSmith追踪，监控每一步工具调用、token消耗、执行时长
  2. 持久化：配置数据库检查点，支持任务中断恢复和执行历史回溯
  3. 安全隔离：Agent运行在沙箱环境中，工具权限最小化，高危操作需要人工审批
  4. 成本控制：深度Agent的token消耗是普通Agent的5-10倍，需要设置最大迭代次数和预算告警
  5. 失败兜底：Agent执行失败时要有降级策略（转人工、返回模板答案）
  6. 评估体系：建立评估数据集，每次提示词或模型变更后做回归测试
  7. 多租户：企业环境中需要隔离不同用户/部门的Agent状态和文件系统

面试题7：Deep Agents和CrewAI怎么选？

参考答案：

选择取决于场景：

  • 如果是快速原型验证、角色分工明确的简单多Agent任务，CrewAI上手更快，Agent+Task+Crew的概念更直观
  • 如果是生产级复杂任务，需要持久化、可观测性、人机交互、可靠执行，Deep Agents更优
  • Deep Agents基于LangGraph，生产级能力更强；CrewAI的生产就绪度相对较弱
  • Deep Agents内置文件系统和规划工具，CrewAI需要自己实现这些能力
  • Deep Agents的子智能体是上下文隔离的，CrewAI的Agent之间通过对话共享上下文

企业项目优先选Deep Agents，个人项目或Demo可以用CrewAI快速验证。

面试题8：如何用Deep Agents实现一个深度研究Agent？请描述架构和关键代码。

参考答案：

深度研究Agent的架构包括：

  1. 主管Agent：负责任务规划（write_todos）、派生子智能体、汇总结果、撰写报告
  2. 研究子智能体：每个子智能体负责一个研究主题，拥有独立的搜索工具和上下文
  3. 搜索工具：使用Tavily或内置搜索，抓取网页全文而不是摘要
  4. 文件系统：保存用户需求、各子任务结果、最终报告
  5. 规划中间件：TodoListMiddleware启用write_todos

关键代码结构：

python 复制代码 
from deepagents import create_deep_agent
from langchain.agents.middleware import TodoListMiddleware

research_sub_agent = {
    "name": "research-agent",
    "description": "Delegate research to the sub-agent.",
    "system_prompt": RESEARCHER_INSTRUCTIONS,
    "tools": [tavily_search],
}

agent = create_deep_agent(
    model=model,
    tools=[tavily_search],
    system_prompt=WORKFLOW_INSTRUCTIONS,
    subagents=[research_sub_agent],
    middleware=[TodoListMiddleware()],
)

执行流程：规划任务 -> 保存需求 -> 并行派出研究子智能体 -> 子智能体搜索并写入文件 -> 主管读取文件汇总 -> 撰写最终报告 -> 验证完整性。

面试题9：Deep Agents支持哪些模型？如何切换模型？

参考答案：

Deep Agents基于LangChain，支持所有LangChain兼容的模型，包括：

  • Anthropic Claude系列（anthropic:claude-sonnet-4-6）
  • OpenAI GPT系列（openai:gpt-5.5）
  • Google Gemini系列（google_genai:gemini-3.6-flash）
  • OpenRouter（openrouter:xxx）
  • Fireworks、Baseten等第三方提供商
  • 本地模型Ollama（ollama:xxx）

切换模型只需修改model参数，支持provider:model格式的字符串或已初始化的模型实例：

python 复制代码 
# 字符串方式
agent = create_deep_agent(model="openai:gpt-5.5")

# 实例方式（更灵活）
from langchain.chat_models import init_chat_model
model = init_chat_model("anthropic:claude-sonnet-4-6", temperature=0.0)
agent = create_deep_agent(model=model)

注意：模型必须支持工具调用（function calling），否则无法正常工作。

面试题10：Deep Agents的局限性是什么？什么时候不应该用它？

参考答案：

Deep Agents的局限性包括：

  1. 过度设计：对于简单的单轮问答或单工具调用任务，Deep Agents的四大支柱会带来不必要的开销和延迟
  2. Token成本高：规划、子智能体、文件读写都会增加token消耗，简单任务用它成本不划算
  3. 相对较新：2025年才发布，API和最佳实践还在快速演进中
  4. 依赖LangChain生态：深度绑定LangChain，脱离生态使用较困难
  5. 调试复杂度：多智能体+文件系统+规划的组合，调试比普通Agent更复杂

不应该使用的场景：

  • 简单聊天机器人、FAQ问答
  • 只需要调用一两个工具的简单任务
  • 对延迟要求极高（毫秒级响应）的场景
  • 任务流程完全固定、不需要动态规划的场景（用LangGraph硬编码更好）
  • 资源受限、token预算极低的场景

总结

Deep Agents代表了Agent开发的一个重要方向------从"能调用工具的简单循环"走向"能独立完成复杂任务的深度智能体"。它的四大支柱（规划工具、文件系统、子智能体、详细提示词）看似简单，却精准命中了传统Agent"浅尝辄止"的核心痛点。

对于开发者来说，Deep Agents最大的价值在于降低了深度Agent的开发门槛 ：原本需要自己实现规划、上下文管理、多智能体调度的几百行代码，现在通过create_deep_agent一行配置就能搞定。同时它又基于LangGraph这个经过生产验证的运行时，不会像一些快速原型框架那样在生产环境中掉链子。

如果你正在做企业级Agent应用，特别是研究、编码、数据分析这类复杂多步骤任务，Deep Agents值得你投入时间学习和实践。

转载声明：本文为原创文章，如需转载，请联系作者获得授权，并注明出处。

相关推荐
databook1 小时前
正态分布撒谎时：用柯西分布捕捉生活中的“黑天鹅”
python·数据挖掘·数据分析
必须会一定会1 小时前
GPT-6 Astra 官方基准与 AI 编程能力：ARC-AGI-3、Terminal-Bench 4.0、长上下文评测
人工智能·gpt·agi
2601_962381581 小时前
Mac和Windows，哪种电脑适合新手学Python|数智码力分享
windows·python·mac·编程环境·学习入门
ShallWeL1 小时前
RAG Embedding 模型替换与索引回归
人工智能·embedding·知识库·工作流·rag
会飞的拖把1 小时前
Python文件操作详解：从文件读写到os、shutil模块实战
开发语言·python
爱吃火鸡面呀1 小时前
OpenCV 人脸检测与识别实战：从静态图像到视频流
人工智能·opencv·计算机视觉
RS迷途小书童1 小时前
Python 解析大疆无人机 SRT 字幕日志
开发语言·python·无人机
北京晶数信息科技1 小时前
加油站成品油智慧监管云平台成品油流通数智化监管平台加油机数据采集设备交易即开票全链路技术实现方案：技术拆解、架构设计与落地实践
大数据·人工智能
知了一笑1 小时前
职场丨岗位减少，职责增加
大数据·人工智能·职场·产品·业务
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02GitHub 镜像站点03历年考研数学一、数学二、数学三真题试卷及答案PDF04蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接052026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？06微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新07ZCode 周末送额度活动开启：3 亿 Token 免费领取08Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费09AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路10VSCode+CodeX扩展，无法启动