DeepAgents 是一个基于 LangChain 和 LangGraph 的高级智能体框架，旨在简化长运行自主智能体的开发。它通过内置的最佳实践和中间件，解决复杂任务中的规划、记忆、工具使用和环境交互问题。DeepAgents 适用于深度调研、全栈代码生成、复杂数据分析、自动化运维和复杂工作流编排等场景。通过系统提示词、规划工具、文件系统和子代理四大核心功能，DeepAgents 实现了高可靠、可追溯、可恢复的完整闭环，将 AI Agent 从“脚本化”向“产品化”的关键演进。对于希望快速构建类似 “OpenAI Deep Research” 或 “Claude Code” 应用的开发者来说，DeepAgents 是一个值得收藏的学习资源。

一、 DeepAgents 框架定位与核心价值

1、 什么是 DeepAgents ？

DeepAgents是一个基于 LangChain 和 LangGraph 构建的企业级高级智能体框架。它建立在 LangGraph（底层运行时）和 LangChain（工具/模型层）之上，是一个高阶的Agent Harness（智能体装备/套件）。它构建可以规划、使用子代理和利用文件系统执行复杂任务的代理。

DeepAgents 是一个独立库，用于构建能够处理复杂多步骤任务的代理。深度代理基于 LangGraph，灵感来自 Claude Code、Deep Research 和 Manus 等应用程序，具备规划功能、用于上下文管理的文件系统以及生成子代理的能力。

• • 定位：它旨在简化长运行自主智能体 (Long-running Autonomous Agents) 的开发过程，通过内置的最佳实践和中间件，解决复杂任务中的规划、记忆、工具使用和环境交互问题。

• • 核心理念：如果说 LangChain 提供了积木，LangGraph 提供了地基，那么 DeepAgents 就是一套成品级的框架。它预设了最佳实践（规划、文件系统、子智能体），让你能快速构建类似 “OpenAI Deep Research” 或 “Claude Code” 的应用。

• 论文地址：https://arxiv.org/pdf/2510.21618

DeepAgents 开源地址：

https://github.com/langchain-ai/deepagents

官方文档：

https://docs.langchain.com/oss/python/deepagents/quickstart

deepagents 库包含：

• • Deep Agents SDK：用于构建代理的包
• • Deep Agents CLI：基于 deepagents 包构建的编码工具

2、 解决的核心问题

传统的 Agent 开发通常运行一个简单的循环：思考→调用工具→观察→重复。这种模式在处理多小时或多天的任务时，容易遇到以下"浅层陷阱"（Shallow Agent Problem）

1. 规划能力缺失：原生 Agent 倾向于“走一步看一步”，缺乏全局视角的任务拆解，容易在多步任务中迷失方向。

2. 遗忘与混乱：在执行超过 10-20 步的长任务时，由于 Context Window（上下文窗口）限制，传统 Agent 容易忘记初始目标或陷入死循环。

3. 环境交互困难：文件系统操作、代码执行环境（沙箱）的配置和安全管理复杂。

4. 上下文污染：所有工具返回结果都堆积在一个对话历史中，导致噪声过大。

5. 协作编排复杂：多智能体（Multi-Agent）之间的任务分发和上下文隔离难以实现。

DeepAgents 通过引入"类人"的工作流解决了这些问题：先做计划（Plan），再执行，利用文件系统管理记忆，遇到复杂子任务时"外包"给子 Agent。将规划工具、文件系统访问、子代理和详细提示词等关键机制整合在一起，以支持复杂的深度任务 。

import deepagents

print(dir(deepagents))

['CompiledSubAgent', 'FilesystemMiddleware', 'SubAgent', 'SubAgentMiddleware', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', 'backends', 'create_deep_agent', 'graph', 'middleware']

3、 应用场景

DeepAgents 不适合用来做简单的聊天机器人（Chatbot），它是为重任务设计的，它适用于任务需规划、上下文海量、需多专家协作、要求持久记忆的场景，将LangChain生态从单步响应提升至自主完成复杂项目的高度：

• • 深度调研 (Deep Research)：自动进行多轮网页搜索、阅读文档、整理笔记并生成长篇报告（如分析某个行业的市场格局）。
• • 全栈代码生成 (Coding Assistant)：类似 Claude Code，在沙箱环境中编写、运行、测试和修复代码，甚至重构整个代码库。
• • 复杂数据分析：自动连接数据库，生成 SQL，执行查询，将中间数据存为 CSV 文件（在虚拟文件系统中），最后生成图表。
• • 自动化运维 (DevOps Automation)：操作文件系统、执行 Shell 命令、管理服务器状态。
• • 复杂工作流编排：需要多角色协作（如产品经理-程序员-测试员）的复杂业务流程。

当然这个描述相对来说比较抽象，因此我们这里对适用于DeepAgents的场景进行一个总结：

DeepAgents 适用场景

场景类型	能力说明	工作逻辑 / 技术特点	代表性案例
深度调研与报告生成	支持长周期、多步骤、多来源信息整合的研究任务	• 自动生成研究计划（Todo） • 调用搜索工具获取资料 • 将关键信息写入文件系统（长期记忆） • 使用子代理（Sub-Agents）深入研究子课题 • 主代理统一规划、整合结果	• LangChain Deep Research 示例（Tavily 搜索 + 多子代理拆分研究） • OpenAI Deep Research（官方生产级深度调研助理）
自动编程与代码助理	理解代码、修改代码、生成新文件、执行工具链	• 代理可读写虚拟文件系统 • 自动分析源码并输出 diff • 人工审批（Human-in-the-Loop）保证安全写入 • 调用 Shell / 测试工具执行流程 • 可将项目规范写入 /memories 用作长期记忆	• LangChain DeepAgents CLI（终端自动编码） • Anthropic Claude Code（深度自动重构与编程） • Manus（多步骤代码智能体）
复杂流程自动化（业务流程 Orchestration）	将多个步骤串联为可控流程，适合企业级自动化任务	• 任务分解 → 多步骤规划 → 调用不同工具 • 搜索、筛选、处理、生成等多环节协作 • 使用文件系统存储中间数据（如列表、分析结果等） • 支持多工具、多子任务并行处理	• DeepAgents 求职助手（职位搜索 → 筛选排序 → 求职信生成 → 打包结果） • 企业场景如：自动生成分析报告 / 客服知识库构建 / 数据采集+处理流

二、 与 LangChain 及 LangGraph 的区别

从技术定位看，LangChain 适用于需要自定义提示与工具的基础智能体搭建；LangGraph 更适合构建复杂的多智能体系统与工作流；而 DeepAgents 面向希望省去底层开发、直接采用深度自主机制的用户，可快速实现 AutoGPT 类应用。因此，DeepAgents 本质上是基于 LangChain 的深度模式封装——它并非替代 LangChain 或 LangGraph，而是将其常用抽象与运行时封装为开箱即用的组件，可视为一层“开发加速器”。

特性	LangChain	LangGraph	DeepAgents
层级	基础组件库 (Foundation)	编排引擎 (Orchestration)	应用框架 (Application Framework)
核心抽象	Chain, Runnable, Tool	StateGraph, Node, Edge	DeepAgent, Middleware, Backend
灵活性	极高 (积木块)	高 (自定义图结构)	中 (Opinionated / 约定优于配置)
开箱即用	低 (需自行组装)	中 (需定义图逻辑)	高 (内置规划、文件系统、子代理)
适用对象	库开发者/底层构建	复杂流程序列化开发者	应用开发者/企业级解决方案

• • LangChain：提供 Prompt, Models, Tools 等积木。
• • LangGraph：提供 State, Nodes, Edges 等地基和连接逻辑。
• • DeepAgents：LangGraph 的一种“最佳实践实现”。它底层使用 LangGraph 来管理状态和循环，但向上提供了更高级的 API (create_deep_agent)，隐藏了底层的图构建细节。

三、 DeepAgents 核心功能介绍

• • 注意： 没有学习LangChain的用户，建议先学习LangChain1.0的基础内容，再学习DeepAgents。

1、安装环境与依赖

# 安装deepagents依赖
!pip install deepagents

# 查看版本
!pip list | grep -E 'langchain|deepagents'

deepagents                               0.3.0
langchain                                1.2.0
langchain-anthropic                      1.2.0
langchain-chroma                         1.0.0
langchain-classic                        1.0.0
langchain-community                      0.4.1
langchain-core                           1.2.1
langchain-deepseek                       1.0.0
langchain-experimental                   0.4.0
langchain-google-genai                   3.0.3
langchain-mcp-adapters                   0.1.13
langchain-ollama                         1.0.0
langchain-openai                         1.0.2
langchain-tavily                         0.2.13
langchain-text-splitters                 1.0.0

定义大模型

# from langchain_openai import ChatOpenAI
from langchain_deepseek import ChatDeepSeek
from dotenv import load_dotenv

# 1. 加载.env环境变量
load_dotenv(override=True)

# 2. 初始化模型
model = ChatDeepSeek(model="deepseek-chat", temperature=0)
model.invoke("你好")

2、 核心入口：create_deep_agent()

这是整个框架的核心函数，它创建了一个功能完整的深度智能体。

默认配置：

• • 使用 Claude Sonnet 4 或 GPT-4o 作为默认模型（推荐）。
• • 集成 7 个核心文件操作工具。
• • 提供待办事项管理功能。
• • 支持子代理调用。

关键参数：

• • model: 支持自定义语言模型。
• • tools: 自定义工具集。
• • system_prompt : 系统提示词
• • subagents: 子代理配置。
• • backend: 文件存储后端。
• • interrupt_on: 人机交互配置 (Human-in-the-Loop)。允许在特定节点暂停 Agent 执行，等待人工干预。这对于安全审核（删除文件）、成本控制（调用昂贵 API）和质量保证至关重要。

from deepagents import create_deep_agent

create_deep_agent?

...
Create a deep agent.

This agent will by default have access to a tool to write todos (write_todos),
seven file and execution tools: ls, read_file, write_file, edit_file, glob, grep, execute,
and a tool to call subagents.

The execute tool allows running shell commands if the backend implements SandboxBackendProtocol.
For non-sandbox backends, the execute tool will return an error message.

Args:
    model: The model to use. Defaults to Claude Sonnet 4.
    tools: The tools the agent should have access to.
    system_prompt: The additional instructions the agent should have. Will go in
        the system prompt.
    middleware: Additional middleware to apply after standard middleware.
    subagents: The subagents to use. Each subagent should be a dictionary with the
        following keys:
            - `name`
            - `description` (used by the main agent to decide whether to call the
              sub agent)
            - `prompt` (used as the system prompt in the subagent)
            - (optional) `tools`
            - (optional) `model` (either a LanguageModelLike instance or dict
              settings)
            - (optional) `middleware` (list of AgentMiddleware)
    response_format: A structured output response format to use for the agent.
    context_schema: The schema of the deep agent.
    checkpointer: Optional checkpointer for persisting agent state between runs.
    store: Optional store for persistent storage (required if backend uses StoreBackend).
    backend: Optional backend for file storage and execution. Pass either a Backend instance
        or a callable factory like `lambda rt: StateBackend(rt)`. For execution support,
        use a backend that implements SandboxBackendProtocol.
    interrupt_on: Optional Dict[str, bool | InterruptOnConfig] mapping tool names to
        interrupt configs.
    debug: Whether to enable debug mode. Passed through to create_agent.
    name: The name of the agent. Passed through to create_agent.
    cache: The cache to use for the agent. Passed through to create_agent.

Returns:
    A configured deep agent.
...

# 安装网络搜索工具
!pip install langchain-tavily

create_deep_agent代码

from deepagents import create_deep_agent
from langchain_tavily import TavilySearch
from langgraph.checkpoint.memory import InMemorySaver

# 1. 初始化 Tavily 搜索工具
tavily = TavilySearch(max_results=3)

# 2. 编写系统提示词
research_instructions = """
您是一位资深的研究人员。您的工作是进行深入的研究，然后撰写一份精美的报告。
您可以通过互联网搜索引擎作为主要的信息收集工具。
## 可用工具
### `互联网搜索`
使用此功能针对给定的查询进行互联网搜索。您可以指定要返回的最大结果数量、主题以及是否包含原始内容。
### `写入本地文件`
使用此功能将研究报告保存到本地文件。当您完成研究并生成报告后，请使用此工具将完整的报告内容保存到文
件中。
- 文件路径建议使用 .md 格式（Markdown），例如 "research_report.md" 或 "./reports/报告名
称.md"
- 请确保报告内容完整、结构清晰，包含所有章节和引用来源
## 工作流程
在进行研究时：
1. 首先将研究任务分解为清晰的步骤
2. 使用互联网搜索来收集全面的信息
3. 将信息整合成一份结构清晰的报告
4. **重要**：完成报告后，务必使用 `写入本地文件` 工具将完整报告保存到本地文件
5. 务必引用你的资料来源
**注意**：请确保在完成研究后，将完整的报告内容保存到文件中，这样用户可以方便地查看和保存报告。
"""

# 2. 创建 DeepAgents 智能体
agent = create_deep_agent(
    name="DeepAgents_Agent",       # 智能体名称
    tools=[tavily],                # 可调用工具Tool
    model=model,                   # 模型Model
    system_prompt=research_instructions,  # 系统提示词
    checkpointer=InMemorySaver(),  # 检查点Checkpointer，内存检查点
)

# 3. 配置线程 ID
config = {"configurable": {"thread_id": "1"}}

result = agent.invoke({"messages": [{"role": "user", "content": "帮我查询一下有关deepagents框架的最新动态"}]}, config=config)

print(result["messages"][-1].content)

注意：

• • 系统提示词system_promt可以不写，框架有

默认的提示词。

• • 若发现运行时间超过1分钟，请使用langsmith 监控看下是否出现死循环了，若出现死循环，使用默认的系统提示词。
• • model一定要指定，否则会使用默认的大模型Claude Sonnet 4。

3、 create_deep_agent 内部结构

• • 源码参数截图

# 安装美化代码库Rich
!pip install rich

# 导入Rich库，用于美化代码
from rich.console import Console
from rich.table import Table
from rich.panel import Panel
RICH_AVAILABLE = True
console = Console()

defprint_agent_tools(agent):
    """
    打印 Agent 中加载的所有工具
    包括用户自定义工具、文件系统工具、系统工具等
    """
    # 获取 agent 的 nodes (LangGraph 的节点)
    ifhasattr(agent, 'nodes') and'tools'in agent.nodes:
        tools_node = agent.nodes['tools']

        # tools_node 是 PregelNode，真正的 ToolNode 在 bound 属性中
        ifhasattr(tools_node, 'bound'):
            tool_node = tools_node.bound

            # 从 ToolNode 获取工具
            ifhasattr(tool_node, 'tools_by_name'):
                tools = tool_node.tools_by_name

                # 分类工具
                user_tools = []
                filesystem_tools = []
                system_tools = []

                for tool_name, tool in tools.items():
                    tool_info = {
                        'name': tool_name,
                        'description': getattr(tool, 'description', '无描述')
                    }

                    # 分类
                    if tool_name in ['ls', 'read_file', 'write_file', 'edit_file', 'glob', 'grep', 'execute']:
                        filesystem_tools.append(tool_info)
                    elif tool_name in ['write_todos', 'task']:
                        system_tools.append(tool_info)
                    else:
                        user_tools.append(tool_info)

                # 打印加载工具的输出
                _print_tools_rich(user_tools, filesystem_tools, system_tools)

            else:
                print("无法获取工具列表 (tools_by_name 不存在)")
        else:
            print("无法获取工具列表 (bound 属性不存在)")
    else:
        print("无法获取工具列表 (nodes 结构不符合预期)")

def_print_tools_rich(user_tools, filesystem_tools, system_tools):
    """使用 Rich 库美化打印工具列表"""
    console.print()

    # 创建表格
    table = Table(title="Agent 加载的工具列表", show_header=True, header_style="bold magenta")
    table.add_column("类别", style="cyan", width=20)
    table.add_column("工具名称", style="green", width=20)
    table.add_column("描述", style="white", width=60)

    # 添加用户工具
    for i, tool inenumerate(user_tools):
        category = "用户工具"if i == 0else""
        desc = tool['description'][:80] + "..."iflen(tool['description']) > 80else tool['description']
        table.add_row(category, tool['name'], desc)

    # 添加文件系统工具
    for i, tool inenumerate(filesystem_tools):
        category = "文件系统工具"if i == 0else""
        desc = tool['description'][:80] + "..."iflen(tool['description']) > 80else tool['description']
        table.add_row(category, tool['name'], desc)

    # 添加系统工具
    for i, tool inenumerate(system_tools):
        category = "系统工具"if i == 0else""
        desc = tool['description'][:80] + "..."iflen(tool['description']) > 80else tool['description']
        table.add_row(category, tool['name'], desc)

    console.print(table)

    # 打印统计
    total = len(user_tools) + len(filesystem_tools) + len(system_tools)
    console.print(Panel(
        f"[bold green]共计 {total} 个工具[/bold green]\n\n"
        f"• 用户工具: {len(user_tools)} 个\n"
        f"• 文件系统工具: {len(filesystem_tools)} 个\n"
        f"• 系统工具: {len(system_tools)} 个",
        title="统计信息",
        border_style="green"
    ))
    console.print()

print_agent_tools(agent)

Agent 加载的工具列表

这里可以看到，除了自己定义的工具（如 Tavily 搜索），DeepAgents 还默认添加了一些其他工具：

• • 文件系统中间件（FileSystemMiddleware）: 用于读写、查询、执行文件系统中的文件。
• • 待办事项中间件（TodoListMiddleware）: write_todos 用于写入待办事项，task 用于创建子agent来执行待办事项。

这些都是 DeepAgents 特有的功能，用于支持智能体在实际应用中的各种场景。那么，接下来我们来看看这些功能的具体应用。

• • Langgraph Studio 中可视化结构图：能看到

• • PatchToolCallsMiddleware用于 自动检测并修复“悬空”的工具调用 的关键中间件，确保工具调用的完整性和正确性。
• • SummarizationMiddleware上下文压缩中间件，防止上下文过长

四、 四大核心内置工具与组件详解

DeepAgents 通过中间件 (Middleware) 的形式，为智能体注入了四项核心能力，构成了框架的四大支柱（Four Pillars）：

DeepAgents四大内置工具通过角色分离、状态贯通、成本优化的设计哲学，将长周期Agent的开发复杂度降低70%以上，同时通过LangGraph运行时保障生产级可靠性。其核心价值在于将原本需要手动编排的规划-存储-委托-执行流程，固化为中心化、可复用、可观测的中间件体系，标志着AI Agent从"脚本化"向"产品化"的关键演进。

• • 协同价值：系统提示词确保质量，规划工具保证进度，文件系统实现数据共享，子代理隔离分析风险，四者形成高可靠、可追溯、可恢复的完整闭环。

维度	系统提示词 (System Prompt)	规划工具 (Planning Tool)	文件系统 (File System)	子代理 (Sub Agents)
角色定位	行为总导演 ：定义Agent的"世界观"与工具使用范式，确保三大中间件协同不偏离目标	任务架构师 ：将模糊需求转化为可执行、可追踪、可动态调整的结构化任务蓝图	上下文仓库 ：虚拟化存储引擎，解决长任务中的信息溢出与状态持久化难题	执行特派员 ：实现上下文隔离与专业分工，防止主Agent因深层递归导致状态混乱
核心功能	内置Claude Code风格指令，涵盖规划逻辑、文件操作规范、子代理调用协议；支持场景化自定义覆盖	write_todos : 生成带优先级/依赖关系的JSON任务列表 read_todos: 实时查询任务执行进度与状态	ls/glob : 文件浏览与模式匹配 read/write/edit: CRUD操作 grep: 内容检索 execute: 沙箱命令执行	task : 动态生成同构或异构子Agent 支持独立上下文窗口与工具集配置 结果通过文件系统回传
技术实现	字符串模板，在create_deep_agent时注入；默认提示词约2000 tokens，包含ReAct循环与三大中间件调用示例	TodoListMiddleware ：拦截LLM输出中的todo_list字段，解析为agent_state.todos字典，状态变更触发图节点重计算	FilesystemMiddleware ：基于LangGraph State的files字段实现内存级虚拟文件系统，大工具结果（>2KB）自动触发write_file落盘	SubAgentMiddleware ：将task调用编译为独立的StateGraph子图，通过命名空间隔离状态，父图通过files读取子图输出
状态管理	静态配置，单次会话内不可变；可通过configurable_agent实现热更新	动态状态机 ：每个todo含id/description/status/priority/dependencies字段，执行后状态从pending→completed，支持update_todos动态调整	持久化存储 ：默认存储在LangGraph State，支持切换StateBackend（内存/Redis/Postgres）实现跨会话文件共享	完全隔离 ：子Agent拥有独立的messages和files命名空间，异常不会污染父Agent状态；支持max_iterations限制防止无限递归
使用场景	① 垂直领域定制：金融研究/医疗诊断等需强化专业约束的场景 ② 多Agent协作：统一多个子Agent的行为规范 ③ 安全合规：注入数据脱敏、权限检查等硬性规则	① 长周期研究：自动拆解为文献检索→数据收集→分析→撰写的阶段性任务 ② 故障恢复：崩溃后通过read_todos快速定位断点续跑 ③ 动态重规划：执行中发现信息不足时新增补充任务	① 大结果处理：搜索返回100KB内容自动落盘，避免上下文溢出 ② 知识沉淀：中间分析结果写入文件供后续步骤复用 ③ 多Agent数据共享：父Agent与子Agent通过文件交换数据，无需序列化传递	① 高风险操作隔离：网页抓取/代码执行等易失败任务委托给子Agent ② 专业化分工：主Agent负责任务编排，子Agent专注领域执行（如专门的数据分析Agent） ③ 资源优化：子Agent可使用轻量化模型，降低整体token成本

1、 系统提示词 (System Prompts)

• • 功能：定义 Agent 的“人设”、行为准则和核心目标。
• • 机制：框架会自动将用户定义的 system_prompt 与内置的 BASE_AGENT_PROMPT 结合。
• • 作用：确保 Agent 始终遵循指令，理解其可用的工具集，并保持一致的输出风格。
• • 角色本质：系统提示词是DeepAgents三大中间件协同的"契约"，其默认版本包含：

• • 规划指令：要求LLM在任务开始前必须调用write_todos，输出格式为JSON Schema
• • 文件操作规范：明确write_file用于新内容，edit_file用于局部修改，避免覆盖冲突
• • 子代理调用协议：规定task工具的参数结构及结果通过/subagent_results/.md回传
• • 安全底线：禁止直接执行删除、格式化等危险命令，必须通过execute沙箱

FileSystem_System_prompt 文件系统提示词

Execute_Tool_Descriptition 执行工具提示词

• • 文件系统中间件提示词（FileSystemMiddleWare）
• • 文件路径：deepagents/middleware/filesystem.py

Write_Todos_System_prompt 写执行任务提示词

• • TodoList中间件提示词（TodoListMiddleware）
• • 文件路径：deepagents/middleware/todo.py

Task_System_prompt Task执行器提示词

• 子智能体中间件提示词（SubAgentMiddleware）
• 文件路径：deepagents/middleware/subagent.py

2、 规划工具 (Planning System / Todo List)

• 组件：TodoListMiddleware
• 工具名：write_todos
• 功能：Agent 在行动前先生成 Markdown 格式的待办事项列表 (Todo List)，并在执行过程中更新状态（完成/进行中）。
  工作流：

1. Agent 接收复杂任务（简单短期的任务不会触发todolist）。
2. 调用 write_todos 将任务拆解为子步骤 (Pending)。
3. 每完成一步，更新状态为 (Completed)。
4. 自我反思：在每一步行动前，Agent 都会看到当前的 Todo List，从而避免迷失方向。这强制模型进行"思维链"的显性化管理。

• 类似编程工具中的待执行项

import json
from rich.json import JSON

defdebug_agent(query: str, save_to_file: str = None):
    """
    运行智能体并打印中间过程（使用 Rich 美化输出）
    参数:
    query: 用户查询
    save_to_file: 保存最终输出到文件(可选)
    返回:
    str: 最终的研究报告
    """
    console.print(Panel.fit(
        f"[bold cyan]查询:[/bold cyan] {query}",
        border_style="cyan"
    ))
    step_num = 0
    final_response = None

    config = {"configurable": {"thread_id": "2"}}

    # 实时流式输出
    for event in agent.stream(
        {"messages": [{"role": "user", "content": query}]},
        stream_mode="values",
        config=config
    ):
        step_num += 1

        console.print(f"\n[bold yellow]{'─' * 80}[/bold yellow]")
        console.print(f"[bold yellow]步骤 {step_num}[/bold yellow]")
        console.print(f"[bold yellow]{'─' * 80}[/bold yellow]")

        if"messages"in event:
            messages = event["messages"]
            if messages:
                msg = messages[-1]
                # 保存最终响应
                ifhasattr(msg, 'content') and msg.content andnothasattr(msg,'tool_calls'):
                    final_response = msg.content
                # AI 思考
                ifhasattr(msg, 'content') and msg.content:
                    # 如果内容太长,只显示前300字符作为预览
                    content = msg.content
                    iflen(content) > 300andnot (hasattr(msg, 'tool_calls') and msg.tool_calls):
                        preview = content[:300] + "..."
                        console.print(Panel(
                            f"{preview}\n\n[dim](内容较长,完整内容将在最后显示)[/dim]",
                        title="[bold green]AI 思考[/bold green]",
                        border_style="green"
                        ))
                    else:
                        console.print(Panel(
                            content,
                            title="[bold green]AI 思考[/bold green]",
                            border_style="green"
                        ))
                # 工具调用
                ifhasattr(msg, 'tool_calls') and msg.tool_calls:
                    for tool_call in msg.tool_calls:
                        tool_info = {
                            "工具名称": tool_call.get('name', 'unknown'),
                            "参数": tool_call.get('args', {})
                        }
                        console.print(Panel(
                            JSON(json.dumps(tool_info, ensure_ascii=False)),
                            title="[bold blue]工具调用[/bold blue]",
                            border_style="blue"
                        ))
                # 工具响应
                ifhasattr(msg, 'name') and msg.name:
                    response = str(msg.content)[:500]
                    iflen(str(msg.content)) > 500:
                        response += f"\n... (共 {len(str(msg.content))} 字符)"

                    console.print(Panel(
                        response,
                        title=f"[bold magenta]工具响应: {msg.name}[/bold magenta]",
                        border_style="magenta"
                    ))
    console.print("\n[bold green]任务完成![/bold green]\n")
    return final_response

print("调试函数已创建")

调试函数已创建

# 示例：使用调试函数运行研究任务
query = "详细调研 LangChain DeepAgents 框架的核心特性，并写一份结构化的总结报告。"

# 使用调试函数）
result = debug_agent(query)

3、 子代理 (Sub-Agent Delegation)

• • 组件：`SubA
• gentMiddleware`
• • 工具名：task (delegate_task)
• • 核心概念：

• • 任务隔离：每个子代理有独立的上下文窗口。
• • 并行执行：支持同时启动多个子代理。
• • 结果聚合：智能整合多个子代理的输出。

• • 机制：

• • 当任务过于具体（如"爬取并分析这篇长论文"）时，主 Agent 会生成一个隔离环境的子 Agent 去执行。
• • 子 Agent 启动时，只继承必要的环境配置，但拥有全新的、空白的消息历史。
• • 子 Agent 执行完毕后只返回一个总结性的结果。这保证了主 Agent 的时间线（Context）保持干净，极大地节省了 Token。

自动触发默认的 SubAgentMiddleware

import asyncio
import os
from dotenv import load_dotenv
from rich.console import Console
from rich.panel import Panel
from rich.tree import Tree
from deepagents import create_deep_agent
from langchain_openai import ChatOpenAI
from langchain_community.tools import TavilySearchResults

from langchain_core.messages import ToolMessage, BaseMessage

# 加载环境变量
load_dotenv(override=True)

# 配置 Rich Console
console = Console()

asyncdefrun_auto_subagent_demo():
    """
    演示：不显式传入 subagents 参数，自动触发默认的 SubAgentMiddleware
    """
    console.print(Panel.fit("[bold magenta]DeepAgents 自动 SubAgent 中间件演示[/bold magenta]", border_style="magenta"))
    console.print("[dim]本演示验证：即使不传入 subagents 参数，Agent 默认也会启用 'general-purpose' 子 Agent。[/dim]")

    # 1. 初始化模型
    # 使用 GPT-4o 以确保对复杂指令的理解和工具调用的准确性
    llm = ChatOpenAI(model="gpt-4o", temperature=0)

    # 2. 定义工具
    # 给 Agent 一些工具，以便子 Agent 也有工具可用
    tools = [TavilySearchResults(max_results=2)]

    # 3. 创建 Agent (不传入 subagents)
    # create_deep_agent 默认会加载 SubAgentMiddleware(general_purpose_agent=True)
    # 这意味着 Agent 会自动获得一个名为 'task' 的工具，可以调用 'general-purpose' 子 Agent
    console.print("[bold cyan]正在创建 Agent (subagents=None)...[/bold cyan]")

    agent = create_deep_agent(
        model=llm,
        tools=tools,
        # subagents=[], # 故意不传或传空
        system_prompt="""你是一个能够高效处理并发任务的智能助手。
                        对于包含多个独立部分的复杂任务，你必须使用 'task' 工具来创建 'general-purpose' 子 Agent 进行处理。
                        不要自己在主线程中串行执行所有操作。利用子 Agent 来隔离上下文并提高效率。"""
    )

    # 4. 定义一个适合并行/隔离的任务
    task = """请同时调研以下两个完全不同的主题，并分别给出简短总结：
            1. Python 语言的历史起源。
            2. Rust 语言的内存安全机制。
            请务必使用子 Agent 分别处理这两个任务。"""

    console.print(f"\n[bold green]用户任务:[/bold green] {task}\n")

    # 5. 运行并可视化
    step = 0

    # 检查 API Key
    ifnot os.getenv("OPENAI_API_KEY"):
        console.print("[bold red]❌ 错误: 未找到 OPENAI_API_KEY，请检查 .env 文件[/bold red]")
        return

    console.print("[dim]开始流式输出...[/dim]")
    try:
        asyncfor event in agent.astream({"messages": [("user", task)]}):
            step += 1
            # 遍历所有节点输出 (e.g., 'agent', 'tools')
            for node_name, node_data in event.items():
                if node_data isNone:
                    continue

                if"messages"in node_data:
                    msgs = node_data["messages"]
                    # 确保是列表
                    ifnotisinstance(msgs, list):
                        msgs = [msgs]

                    for msg in msgs:
                        # 0. 过滤非消息对象
                        ifnotisinstance(msg, BaseMessage):
                            continue

                        # 1. 检测工具调用 (期望看到 'task' 工具)
                        ifhasattr(msg, "tool_calls") and msg.tool_calls:
                            tree = Tree(f"[bold yellow]Step {step}: 决策与调用 (Node: {node_name})[/bold yellow]")
                            for tc in msg.tool_calls:
                                tool_name = tc['name']
                                tool_args = tc['args']

                                if tool_name == "task":
                                    # 验证成功！
                                    branch = tree.add(f"[bold red]🚀 触发 'task' 工具 (Sub-Agent)[/bold red]")
                                    branch.add(f"[cyan]子 Agent 类型:[/cyan] {tool_args.get('subagent_type')}")
                                    branch.add(f"[cyan]任务指令:[/cyan] {tool_args.get('description')}")
                                else:
                                    tree.add(f"[blue]普通工具调用:[/blue] {tool_name}")

                            console.print(tree)

                        # 2. 检测工具输出 (Sub-Agent 的返回结果)
                        elifisinstance(msg, ToolMessage):
                            if msg.name == "task":
                                # Sub-Agent 完成任务返回
                                panel = Panel(
                                    msg.content,
                                    title=f"[bold magenta]Sub-Agent 完成任务 (Node: {node_name})[/bold magenta]",
                                    border_style="magenta"
                                )
                                console.print(panel)
                            else:
                                console.print(f"[dim]Tool Output ({msg.name}): {msg.content[:100]}...[/dim]")

                        # 3. 检测 AI 最终回复
                        elif msg.content andnot msg.tool_calls:
                            title = f"[bold green]Agent 回复 (Node: {node_name})[/bold green]"
                            console.print(Panel(msg.content, title=title, border_style="green"))

    except Exception as e:
        console.print(f"[bold red]❌ 运行时错误: {e}[/bold red]")

    console.print("\n[bold magenta]演示结束[/bold magenta]")

if __name__ == "__main__":
    await run_auto_subagent_demo()

显示传入subAgent参数

# 安装 MCP 适配器（关键依赖）\MCP 服务器开发库（如需自定义工具）
#!pip install langchain-mcp-adapters mcp

import asyncio
import os
from dotenv import load_dotenv
from rich.console import Console
from rich.panel import Panel
from rich.tree import Tree
from deepagents import create_deep_agent
from langchain_deepseek import ChatDeepSeek
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain_community.tools import TavilySearchResults

from langchain_core.messages import ToolMessage, BaseMessage

# 加载环境变量
load_dotenv(override=True)

# 1. 配置 Rich Console
console = Console()

# 2. 配置 Context7 MCP (连接官方文档)
asyncdefsetup_mcp_tools():
    console.print("[dim]正在连接 Context7 MCP 服务器...[/dim]")
    # 检查 node 环境
    try:
        client = MultiServerMCPClient({
            "context7": {
                "transport": "stdio",
                "command": "npx",
                "args": ["-y", "@upstash/context7-mcp@latest"],
            }
        })
        # 获取工具
        tools = await client.get_tools()
        console.print(f"[green]成功加载 {len(tools)} 个 MCP 工具[/green]")
        return client, tools
    except Exception as e:
        console.print(f"[red]连接 MCP 失败: {e}[/red]")
        console.print("[yellow]将使用模拟工具继续...[/yellow]")
        returnNone, []

# 3. 定义子 Agent 配置
defget_subagents_config(mcp_tools):
    # 子 Agent 1: 官方文档专家
    doc_tools = mcp_tools if mcp_tools else [TavilySearchResults(max_results=3)]

    docs_researcher = {
        "name": "DocsResearcher",
        "description": "负责查阅官方文档和技术规范的专家 Agent。",
        "system_prompt": "你是一名专门查阅官方文档的技术专家。请使用工具获取准确的技术细节。不要猜测。",
        "tools": doc_tools,
        "model": "deepseek-chat"
    }

    # 子 Agent 2: 社区生态专家
    community_researcher = {
        "name": "CommunityResearcher",
        "description": "负责搜索社区博客、教程和最佳实践的专家 Agent。",
        "system_prompt": "你是一名关注社区动态的开发者。请搜索博客、论坛和 GitHub 讨论。",
        "tools": [TavilySearchResults(max_results=3)],
        "model": "deepseek-chat"
    }

    return [docs_researcher, community_researcher]

# 4. 主运行逻辑
asyncdefrun_parallel_demo():
    console.print(Panel.fit("[bold blue]DeepAgents 并行子 Agent 演示[/bold blue]", border_style="blue"))

    # 初始化 MCP
    mcp_client, mcp_tools = await setup_mcp_tools()

    # 获取子 Agent 配置
    subagents = get_subagents_config(mcp_tools)

    # 创建主 Agent
    llm = ChatDeepSeek(model="deepseek-chat", temperature=0)

    agent = create_deep_agent(
        model=llm,
        tools=[],
        subagents=subagents,        # 传入子 Agent 配置
        system_prompt="""你是一名技术总监。你的任务是协调 DocsResearcher 和 CommunityResearcher 完成调研任务。
                        请根据用户需求，将任务拆解并分发给这两个子 Agent。
                        如果任务允许，请务必并行调用它们以提高效率。
                        最后汇总它们的报告。"""
    )

    task = "请详细调研 'LangChain DeepAgents' 框架。我需要官方的技术架构说明（来自文档）以及社区的最佳实践案例。请对比两者。"

    console.print(f"\n[bold green]任务指令:[/bold green] {task}\n")

    # 运行并可视化
    step = 0
    try:
        asyncfor event in agent.astream({"messages": [("user", task)]}):
            step += 1
            # 遍历所有节点输出 (e.g., 'agent', 'tools')
            for node_name, node_data in event.items():
                if node_data isNone:
                    continue

                if"messages"in node_data:
                    msgs = node_data["messages"]
                    # 确保是列表
                    ifnotisinstance(msgs, list):
                        msgs = [msgs]

                    for msg in msgs:
                        # 0. 过滤非消息对象
                        ifnotisinstance(msg, BaseMessage):
                            continue

                        # 1. 检测工具调用 (期望看到 'task' 工具)
                        ifhasattr(msg, "tool_calls") and msg.tool_calls:
                            tree = Tree(f"[bold yellow]Step {step}: 决策与调用 (Node: {node_name})[/bold yellow]")
                            for tc in msg.tool_calls:
                                tool_name = tc['name']
                                tool_args = tc['args']

                                if tool_name == "task":
                                    # 验证成功！
                                    branch = tree.add(f"[bold red]🚀 触发 'task' 工具 (Sub-Agent)[/bold red]")
                                    branch.add(f"[cyan]子 Agent 类型:[/cyan] {tool_args.get('subagent_type')}")
                                    branch.add(f"[cyan]任务指令:[/cyan] {tool_args.get('description')}")
                                else:
                                    tree.add(f"[blue]普通工具调用:[/blue] {tool_name}")

                            console.print(tree)

                        # 2. 检测工具输出 (Sub-Agent 的返回结果)
                        elifisinstance(msg, ToolMessage):
                            if msg.name == "task":
                                # Sub-Agent 完成任务返回
                                panel = Panel(
                                    msg.content,
                                    title=f"[bold magenta]Sub-Agent 完成任务 (Node: {node_name})[/bold magenta]",
                                    border_style="magenta"
                                )
                                console.print(panel)
                            else:
                                console.print(f"[dim]Tool Output ({msg.name}): {msg.content[:100]}...[/dim]")

                        # 3. 检测 AI 最终回复
                        elif msg.content andnot msg.tool_calls:
                            title = f"[bold green]Agent 回复 (Node: {node_name})[/bold green]"
                            console.print(Panel(msg.content, title=title, border_style="green"))

    except Exception as e:
        console.print(f"[bold red]❌ 运行时错误: {e}[/bold red]")


    console.print("\n[bold blue]演示结束[/bold blue]")

# 运行演示
if __name__ == "__main__":
    await run_parallel_demo()

如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

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

为什么要学习大模型？

我国在A大模型领域面临人才短缺,数量与质量均落后于发达国家。2023年，人才缺口已超百万，凸显培养不足。随着AI技术飞速发展，预计到2025年,这一缺口将急剧扩大至400万,严重制约我国AI产业的创新步伐。加强人才培养,优化教育体系,国际合作并进是破解困局、推动AI发展的关键。

大模型入门到实战全套学习大礼包

1、大模型系统化学习路线

作为学习AI大模型技术的新手，方向至关重要。 正确的学习路线可以为你节省时间，少走弯路；方向不对，努力白费。这里我给大家准备了一份最科学最系统的学习成长路线图和学习规划，带你从零基础入门到精通！

---

2、大模型学习书籍&文档

学习AI大模型离不开书籍文档，我精选了一系列大模型技术的书籍和学习文档（电子版），它们由领域内的顶尖专家撰写，内容全面、深入、详尽，为你学习大模型提供坚实的理论基础。

3、AI大模型最新行业报告

2025最新行业报告，针对不同行业的现状、趋势、问题、机会等进行系统地调研和评估，以了解哪些行业更适合引入大模型的技术和应用，以及在哪些方面可以发挥大模型的优势。

4、大模型项目实战&配套源码

学以致用，在项目实战中检验和巩固你所学到的知识，同时为你找工作就业和职业发展打下坚实的基础。

5、大模型大厂面试真题

面试不仅是技术的较量，更需要充分的准备。在你已经掌握了大模型技术之后，就需要开始准备面试，我精心整理了一份大模型面试题库，涵盖当前面试中可能遇到的各种技术问题，让你在面试中游刃有余。

适用人群

第一阶段（10天）：初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识，对大模型 AI 的理解超过 95% 的人，可以在相关讨论时发表高级、不跟风、又接地气的见解，别人只会和 AI 聊天，而你能调教 AI，并能用代码将大模型和业务衔接。

• 大模型 AI 能干什么？
• 大模型是怎样获得「智能」的？
• 用好 AI 的核心心法
• 大模型应用业务架构
• 大模型应用技术架构
• 代码示例：向 GPT-3.5 灌入新知识
• 提示工程的意义和核心思想
• Prompt 典型构成
• 指令调优方法论
• 思维链和思维树
• Prompt 攻击和防范
• …

第二阶段（30天）：高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习，学会构造私有知识库，扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架，抓住最新的技术进展，适合 Python 和 JavaScript 程序员。

• 为什么要做 RAG
• 搭建一个简单的 ChatPDF
• 检索的基础概念
• 什么是向量表示（Embeddings）
• 向量数据库与向量检索
• 基于向量检索的 RAG
• 搭建 RAG 系统的扩展知识
• 混合检索与 RAG-Fusion 简介
• 向量模型本地部署
• …

第三阶段（30天）：模型训练

恭喜你，如果学到这里，你基本可以找到一份大模型 AI相关的工作，自己也能训练 GPT 了！通过微调，训练自己的垂直大模型，能独立训练开源多模态大模型，掌握更多技术方案。

到此为止，大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗？

• 为什么要做 RAG
• 什么是模型
• 什么是模型训练
• 求解器 & 损失函数简介
• 小实验2：手写一个简单的神经网络并训练它
• 什么是训练/预训练/微调/轻量化微调
• Transformer结构简介
• 轻量化微调
• 实验数据集的构建
• …

第四阶段（20天）：商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知，可以在云端和本地等多种环境下部署大模型，找到适合自己的项目/创业方向，做一名被 AI 武装的产品经理。

• 硬件选型
• 带你了解全球大模型
• 使用国产大模型服务
• 搭建 OpenAI 代理
• 热身：基于阿里云 PAI 部署 Stable Diffusion
• 在本地计算机运行大模型
• 大模型的私有化部署
• 基于 vLLM 部署大模型
• 案例：如何优雅地在阿里云私有部署开源大模型
• 部署一套开源 LLM 项目
• 内容安全
• 互联网信息服务算法备案
• …

学习是一个过程，只要学习就会有挑战。天道酬勤，你越努力，就会成为越优秀的自己。

如果你能在15天内完成所有的任务，那你堪称天才。然而，如果你能完成 60-70% 的内容，你就已经开始具备成为一名大模型 AI 的正确特征了。

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