使用大语言模型循环调用工具是最简单的智能体形式。然而，这种架构生成的智能体往往较为“浅层”，难以在较长且复杂的任务中进行规划和执行。

像“Deep Research”、“Manus”和“Claude Code”这样的应用，通过结合以下四点来克服这一局限性： 规划工具、子智能体、对文件系统的访问权限，以及详尽的提示词。

deepagents 是一个 TypeScript 库，以通用的方式实现了这些功能，使您能够轻松为自己的应用创建深度智能体。

💡 提示: 想要该库的 Python 版本吗？请查看 langchain-ai/deepagents。

📖 概述

使用大语言模型循环调用工具是最简单的智能体形式。然而，这种架构生成的智能体往往较为“浅层”，难以在较长且复杂的任务中进行规划和执行。

像 Deep Research、Manus 和 Claude Code 这样的应用，通过实现四个关键组件克服了这一局限性：

1. 规划工具 - 战略性地分解任务
2. 子智能体 - 专门处理子任务的智能体
3. 文件系统访问 - 持久化状态与记忆
4. 详尽的提示词 - 上下文丰富的指令

Deep Agents 是一个 TypeScript 库，以通用方式实现了这些模式，让您能够轻松为自己的应用创建复杂的智能体。

✨ 特性

• 🎯 任务规划与分解 - 将复杂任务拆解为可管理的步骤
• 🤖 子智能体架构 - 将专业工作委派给专注的智能体
• 💾 文件系统集成 - 持久化内存与状态管理
• 🌊 流式支持 - 实时更新、令牌流传输和进度跟踪
• 🔄 基于 LangGraph - 构建于强大的 LangGraph 框架之上
• 📝 TypeScript 优先 - 完整的类型安全与 IntelliSense 支持
• 🔌 可扩展 - 易于根据您的用例进行自定义和扩展

安装

# npm
npm install deepagents

# yarn
yarn add deepagents

# pnpm
pnpm add deepagents

使用

（要运行下面的示例，您需要 npm install @langchain/tavily）。

请确保在您的环境变量中设置 TAVILY_API_KEY。您可以在 这里 生成一个。

import { tool } from "langchain";
import { TavilySearch } from "@langchain/tavily";
import { createDeepAgent } from "deepagents";
import { z } from "zod";

// 网络搜索工具
const internetSearch = tool(
  async ({
    query,
    maxResults = 5,
    topic = "general",
    includeRawContent = false,
  }: {
    query: string;
    maxResults?: number;
    topic?: "general" | "news" | "finance";
    includeRawContent?: boolean;
  }) => {
    const tavilySearch = new TavilySearch({
      maxResults,
      tavilyApiKey: process.env.TAVILY_API_KEY,
      includeRawContent,
      topic,
    });
    return await tavilySearch._call({ query });
  },
  {
    name: "internet_search",
    description: "执行网络搜索",
    schema: z.object({
      query: z.string().describe("搜索查询"),
      maxResults: z
        .number()
        .optional()
        .default(5)
        .describe("返回的最大结果数"),
      topic: z
        .enum(["general", "news", "finance"])
        .optional()
        .default("general")
        .describe("搜索的主题类别"),
      includeRawContent: z
        .boolean()
        .optional()
        .default(false)
        .describe("是否包含原始内容"),
    }),
  },
);

// 引导智能体成为专家研究员的系统提示
const researchInstructions = `你是一位专家级研究员。你的任务是进行深入研究，并撰写一份精炼的报告。

你可以使用网络搜索工具作为主要的信息收集手段。

> [!提示]
> 如需开发、调试和部署 AI 智能体及 LLM 应用程序，请参阅 [LangSmith](https://docs.langchain.com/langsmith/home)。

## \`internet_search\`

用于针对特定查询执行网络搜索。你可以指定返回的最大结果数量、主题，以及是否包含原始内容。
`;

// 创建深度智能体
const agent = createDeepAgent({
  tools: [internetSearch],
  systemPrompt: researchInstructions,
});

// 调用智能体
const result = await agent.invoke({
  messages: [{ role: "user", content: "什么是 langgraph?" }],
});

更多复杂示例请参见 examples/research/research-agent.ts。

使用 createDeepAgent 创建的智能体本质上就是一个 LangGraph 图——因此您可以像操作任何 LangGraph 智能体一样与之交互（流式传输、人机协作、记忆管理、Studio）。

核心能力

规划与任务分解

Deep Agents 内置了一个 write_todos 工具，使智能体能够将复杂任务分解为离散的步骤，跟踪进度，并在新信息出现时调整计划。

上下文管理

文件系统工具（ls、read_file、write_file、edit_file、glob、grep）允许智能体将大量上下文卸载到存储中，防止上下文窗口溢出，并支持处理可变长度的工具输出。

子智能体生成

内置的 task 工具使智能体能够生成专门的子智能体以实现上下文隔离。这有助于保持主智能体的上下文简洁，同时深入处理特定的子任务。

长期记忆

通过 LangGraph 的 Store，可以为智能体扩展跨线程的持久化内存。智能体能够保存和检索之前的对话信息。

自定义 Deep Agents

您可以向 createDeepAgent 传递多个参数来创建您自己的自定义深度智能体。

model

默认情况下，deepagents 使用 "claude-sonnet-4-5-20250929"。您可以通过传递任何 LangChain 模型对象 来自定义此设置。

import { ChatAnthropic } from "@langchain/anthropic";
import { ChatOpenAI } from "@langchain/openai";
import { createDeepAgent } from "deepagents";

// 使用 Anthropic
const agent = createDeepAgent({
  model: new ChatAnthropic({
    model: "claude-sonnet-4-20250514",
    temperature: 0,
  }),
});

// 使用 OpenAI
const agent2 = createDeepAgent({
  model: new ChatOpenAI({
    model: "gpt-5",
    temperature: 0,
  }),
});

systemPrompt

Deep Agents 配备了内置的系统提示词。这是一个相对详细的提示词，其设计深受 尝试 和 复现 Claude Code 系统提示词的影响。相比 Claude Code 的系统提示词，它更具通用性。默认提示词包含了关于如何使用内置规划工具、文件系统工具和子智能体的详细说明。

针对特定用例定制的每个深度智能体都应包含与其用例相关的自定义系统提示词。提示词在构建成功的深度智能体中的重要性怎么强调都不为过。

import { createDeepAgent } from "deepagents";

const researchInstructions = `你是一位专家级研究员。你的工作是进行彻底的研究，然后撰写一份精炼的报告。`;

const agent = createDeepAgent({
  systemPrompt: researchInstructions,
});

tools

与调用工具的智能体一样，您也可以为深度智能体提供一组它可以访问的工具。

import { tool } from "langchain";
import { TavilySearch } from "@langchain/tavily";
import { createDeepAgent } from "deepagents";
import { z } from "zod";

const internetSearch = tool(
  async ({
    query,
    maxResults = 5,
    topic = "general",
    includeRawContent = false,
  }: {
    query: string;
    maxResults?: number;
    topic?: "general" | "news" | "finance";
    includeRawContent?: boolean;
  }) => {
    const tavilySearch = new TavilySearch({
      maxResults,
      tavilyApiKey: process.env.TAVILY_API_KEY,
      includeRawContent,
      topic,
    });
    return await tavilySearch._call({ query });
  },
  {
    name: "internet_search",
    description: "执行网络搜索",
    schema: z.object({
      query: z.string().describe("搜索查询"),
      maxResults: z.number().optional().default(5),
      topic: z
        .enum(["general", "news", "finance"])
        .optional()
        .default("general"),
      includeRawContent: z.boolean().optional().default(false),
    }),
  },
);

const agent = createDeepAgent({
  tools: [internetSearch],
});

middleware

createDeepAgent 是基于中间件实现的，这些中间件可以被自定义。您可以提供额外的中间件来扩展功能、添加工具或实现自定义钩子。

import { tool } from "langchain";
import { createDeepAgent } from "deepagents";
import type { AgentMiddleware } from "langchain";
import { z } from "zod";

const getWeather = tool(
  async ({ city }: { city: string }) => {
    return `${city} 的天气是晴朗的。`;
  },
  {
    name: "get_weather",
    description: "获取某个城市的天气。",
    schema: z.object({
      city: z.string().describe("要查询天气的城市"),
    }),
  },
);

const getTemperature = tool(
  async ({ city }: { city: string }) => {
    return `在 ${city}，气温为 70 华氏度。`;
  },
  {
    name: "get_temperature",
    description: "获取某个城市的气温。",
    schema: z.object({
      city: z.string().describe("要查询气温的城市"),
    }),
  },
);

class WeatherMiddleware implements AgentMiddleware {
  tools = [getWeather, getTemperature];
}

const agent = createDeepAgent({
  model: "claude-sonnet-4-20250514",
  middleware: [new WeatherMiddleware()],
});

subagents

Deep Agents 的一项主要特性是能够生成子代理。您可以在 subagents 参数中指定自定义子代理，以便您的主代理可以将任务转交给它们。子代理对于上下文隔离（有助于避免污染主代理的整体上下文）以及自定义指令非常有用。

subagents 应该是一个遵循 SubAgent 接口的对象列表：

interface SubAgent {
  name: string;
  description: string;
  systemPrompt: string;
  tools?: StructuredTool[];
  model?: LanguageModelLike | string;
  middleware?: AgentMiddleware[];
  interruptOn?: Record<string, boolean | InterruptOnConfig>;
  skills?: string[];
}

SubAgent 字段：

• name：这是子代理的名称，也是主代理调用该子代理时使用的名称。
• description：这是显示给主代理的子代理描述。
• systemPrompt：这是用于子代理的提示词。
• tools：这是子代理可访问的工具列表。
• model：可选的模型名称或模型实例。
• middleware：附加到子代理的额外中间件。有关中间件及其与 createAgent 配合使用方式的介绍，请参阅 此处。
• interruptOn：一个自定义中断配置，用于指定针对您工具的人工介入交互。
• skills：子代理的技能来源路径（例如，["/skills/research/"]）。请参阅下面的技能继承部分。

技能继承

当您通过 createDeepAgent 在主代理上配置 skills 时，不同类型的子代理行为会有所不同：

• 通用型子代理：会自动继承主代理的技能。此子代理可以访问与主代理完全相同的技能。
• 自定义子代理：默认情况下不会继承主代理的技能。如果您希望自定义子代理也能访问技能，则必须显式地为该子代理定义 skills 属性。

const agent = createDeepAgent({
  model: "claude-sonnet-4-20250514",
  skills: ["/skills/"], // 主代理和通用型子代理都会获得这些技能
  subagents: [
    {
      name: "researcher",
      description: "研究助理",
      systemPrompt: "你是一名研究人员。",
      // 此子代理将无法从主代理继承 /skills/
    },
    {
      name: "coder",
      description: "编码助手",
      systemPrompt: "你是一名编码员。",
      skills: ["/skills/coding/"], // 该子代理拥有自己的技能
    },
  ],
});

这种设计确保了上下文隔离——自定义子代理仅能访问其明确需要的技能，从而防止技能在不同专业代理之间意外泄露。

使用 SubAgent

import { tool } from "langchain";
import { TavilySearch } from "@langchain/tavily";
import { createDeepAgent, type SubAgent } from "deepagents";
import { z } from "zod";

const internetSearch = tool(
  async ({
    query,
    maxResults = 5,
    topic = "general",
    includeRawContent = false,
  }: {
    query: string;
    maxResults?: number;
    topic?: "general" | "news" | "finance";
    includeRawContent?: boolean;
  }) => {
    const tavilySearch = new TavilySearch({
      maxResults,
      tavilyApiKey: process.env.TAVILY_API_KEY,
      includeRawContent,
      topic,
    });
    return await tavilySearch._call({ query });
  },
  {
    name: "internet_search",
    description: "执行网络搜索",
    schema: z.object({
      query: z.string(),
      maxResults: z.number().optional().default(5),
      topic: z
        .enum(["general", "news", "finance"])
        .optional()
        .default("general"),
      includeRawContent: z.boolean().optional().default(false),
    }),
  },
);

const researchSubagent: SubAgent = {
  name: "research-agent",
  description: "用于深入研究问题",
  systemPrompt: "你是一位出色的研究人员",
  tools: [internetSearch],
  model: "gpt-4o", // 可选覆盖，默认为主代理模型
};

const subagents = [researchSubagent];

const agent = createDeepAgent({
  model: "claude-sonnet-4-20250514",
  subagents: subagents,
});

interruptOn

对于代理来说，常见的情况是某些工具操作可能较为敏感，在执行前需要人工批准。Deep Agents 通过 LangGraph 的中断功能支持人机协作工作流。您可以使用检查点程序来配置哪些工具需要审批。

这些工具配置会被传递给我们预构建的 HITL 中间件，从而使代理在执行已配置的工具之前暂停，并等待用户的反馈。

import { tool } from "langchain";
import { createDeepAgent } from "deepagents";
import { z } from "zod";

const getWeather = tool(
  async ({ city }: { city: string }) => {
    return `The weather in ${city} is sunny.`;
  },
  {
    name: "get_weather",
    description: "获取某个城市的天气。",
    schema: z.object({
      city: z.string(),
    }),
  },
);

const agent = createDeepAgent({
  model: "claude-sonnet-4-20250514",
  tools: [getWeather],
  interruptOn: {
    get_weather: {
      allowedDecisions: ["approve", "edit", "reject"],
    },
  },
});

backend

Deep Agents 使用后端来管理文件系统操作和内存存储。您可以根据需求配置不同的后端：

import {
  createDeepAgent,
  StateBackend,
  StoreBackend,
  FilesystemBackend,
  LocalShellBackend,
  CompositeBackend,
} from "deepagents";
import { MemorySaver } from "@langchain/langgraph";
import { InMemoryStore } from "@langchain/langgraph-checkpoint";

// 默认：StateBackend（内存中，临时）
const agent1 = createDeepAgent({
  // 未指定后端 - 默认使用 StateBackend
});

// StoreBackend：使用 LangGraph Store 进行持久化存储
const agent2 = createDeepAgent({
  backend: (config) => new StoreBackend(config),
  store: new InMemoryStore(), // 提供存储
  checkpointer: new MemorySaver(), // 可选：用于对话持久化
});

// FilesystemBackend：将文件存储在实际文件系统中
const agent3 = createDeepAgent({
  backend: (config) => new FilesystemBackend({ rootDir: "./agent-workspace" }),
});

// LocalShellBackend：提供文件系统访问权限及本地 shell 命令执行能力
const agent4 = createDeepAgent({
  backend: new LocalShellBackend({
    rootDir: "./agent-workspace",
    inheritEnv: true,
  }),
});

// CompositeBackend：结合多个后端
const agent5 = createDeepAgent({
  backend: (config) =>
    new CompositeBackend({
      state: new StateBackend(config),
      store: config.store ? new StoreBackend(config) : undefined,
    }),
  store: new InMemoryStore(),
  checkpointer: new MemorySaver(),
});

有关每种后端类型的详细示例，请参阅 examples/backends/。

沙箱执行

对于需要运行 Shell 命令的代理，可以通过扩展 BaseSandbox 来创建一个沙箱后端。这将启用 execute 工具，使代理能够在隔离的环境中运行任意 Shell 命令。

import {
  createDeepAgent,
  BaseSandbox,
  type ExecuteResponse,
  type FileUploadResponse,
  type FileDownloadResponse,
} from "deepagents";
import { spawn } from "child_process";

// 通过扩展 BaseSandbox 创建具体的沙箱实现
class LocalShellSandbox extends BaseSandbox {
  readonly id = "local-shell";
  private readonly workingDirectory: string;

  constructor(workingDirectory: string) {
    super();
    this.workingDirectory = workingDirectory;
  }

  // 只需实现 execute() 方法——BaseSandbox 已经实现了所有文件操作
  async execute(command: string): Promise<ExecuteResponse> {
    return new Promise((resolve) => {
      const child = spawn("/bin/bash", ["-c", command], {
        cwd: this.workingDirectory,
      });

      const chunks: string[] = [];
      child.stdout.on("data", (data) => chunks.push(data.toString()));
      child.stderr.on("data", (data) => chunks.push(data.toString()));

      child.on("close", (exitCode) => {
        resolve({
          output: chunks.join(""),
          exitCode,
          truncated: false,
        });
      });
    });
  }

  async uploadFiles(
    files: Array<[string, Uint8Array]>,
  ): Promise<FileUploadResponse[]> {
    // 实现文件上传逻辑
    return files.map(([path]) => ({ path, error: null }));
  }

  async downloadFiles(paths: string[]): Promise<FileDownloadResponse[]> {
    // 实现文件下载逻辑
    return paths.map((path) => ({
      path,
      content: null,
      error: "file_not_found",
    }));
  }
}

// 将沙箱与你的代理一起使用
const sandbox = new LocalShellSandbox("./workspace");

const agent = createDeepAgent({
  backend: sandbox,
  systemPrompt: "你可以使用 execute 工具来运行 Shell 命令。",
});

当使用沙箱后端时，代理将获得一个 execute 工具，可以用来运行 Shell 命令。该工具会自动返回命令的输出、退出码以及输出是否被截断的信息。

完整的实现请参阅 examples/sandbox/local-sandbox.ts。

Deep Agents 中间件

Deep Agents 采用模块化的中间件架构构建。提醒一下，Deep Agents 具备以下功能：

• 计划工具
• 用于存储上下文和长期记忆的文件系统
• 派生子代理的能力

这些功能中的每一项都以独立的中间件形式实现。当你使用 createDeepAgent 创建深度代理时，我们会自动为你的代理附加 todoListMiddleware、FilesystemMiddleware 和 SubAgentMiddleware。

中间件是一个可组合的概念，你可以根据具体用例选择为代理添加多少个中间件。这意味着你也可以单独使用上述任何中间件！

TodoListMiddleware

规划是解决复杂问题不可或缺的一部分。如果你最近使用过 Claude Code，就会注意到它在处理复杂的多步骤任务之前会先列出一个待办事项清单，并且随着更多信息的不断涌入，它还能动态地调整和更新这个清单。

todoListMiddleware 为你的代理提供了一个专门用于更新待办事项清单的工具。在执行多步骤任务之前及过程中，代理会被提示使用 write_todos 工具来记录自己正在做什么以及还需要完成哪些工作。

import { createAgent, todoListMiddleware } from "langchain";

// 默认情况下，createDeepAgent 已包含 todoListMiddleware
// 如果你构建自定义代理，也可以对其进行自定义
const agent = createAgent({
  model: "claude-sonnet-4-20250514",
  middleware: [
    todoListMiddleware({
      // 可选：自定义系统提示
      systemPrompt: "使用 write_todos 工具来...",
    }),
  ],
});

FilesystemMiddleware

上下文工程是构建高效代理的主要挑战之一。当使用可能返回不同长度结果的工具（例如网络搜索、RAG）时，这一点尤为困难，因为较长的工具结果会迅速填满你的上下文窗口。

FilesystemMiddleware 为你的代理提供了与短期和长期记忆交互的工具：

• ls：列出文件系统中的文件
• read_file：读取整个文件或文件中的指定行数
• write_file：向文件系统中写入新文件
• edit_file：编辑文件系统中的现有文件
• glob：查找匹配特定模式的文件
• grep：在文件中搜索文本
• execute：运行 Shell 命令（仅在使用 SandboxBackendProtocol 时可用）

import { createAgent } from "langchain";
import { createFilesystemMiddleware } from "deepagents";

// 默认情况下，createDeepAgent 已包含 FilesystemMiddleware
// 如果你构建自定义代理，也可以对其进行自定义
const agent = createAgent({
  model: "claude-sonnet-4-20250514",
  middleware: [
    createFilesystemMiddleware({
      backend: ..., // 可选：自定义存储后端
      systemPrompt: "在……时写入文件系统"， // 可选的自定义系统提示覆盖
      customToolDescriptions: {
        ls: "在……时使用 ls 工具",
        read_file: "使用 read_file 工具来……",
      }, // 可选：自定义文件系统工具描述
    }),
  ],
});

SubAgentMiddleware

将任务交给子代理是一种很好的方式，可以在保持主代理（监督者）上下文窗口整洁的同时，深入处理任务。子代理中间件允许你通过任务工具来分配子代理。

子代理由名称、描述、系统提示和工具定义。你还可以为子代理指定自定义模型或额外的中间件。这在你需要让子代理与主代理共享额外的状态键时特别有用。

import { tool } from "langchain";
import { createAgent } from "langchain";
import { createSubAgentMiddleware, type SubAgent } from "deepagents";
import { z } from "zod";

const getWeather = tool(
  async ({ city }: { city: string }) => {
    return `The weather in ${city} is sunny.`;
  },
  {
    name: "get_weather",
    description: "获取某个城市的天气。",
    schema: z.object({
      city: z.string(),
    }),
  },
);

const weatherSubagent: SubAgent = {
  name: "weather",
  description: "该子代理可以获取城市天气。",
  systemPrompt: "使用 get_weather 工具获取城市天气。",
  tools: [getWeather],
  model: "gpt-4o",
  middleware: [],
};

const agent = createAgent({
  model: "claude-sonnet-4-20250514",
  middleware: [
    createSubAgentMiddleware({
      defaultModel: "claude-sonnet-4-20250514",
      defaultTools: [],
      subagents: [weatherSubagent],
    }),
  ],
});

ACP（代理客户端协议）支持

Deep Agents 可以作为 Agent Client Protocol 服务器暴露出来，通过基于 stdio 的标准化 JSON-RPC 2.0 协议，实现与 Zed、JetBrains 等 IDE 以及其他兼容 ACP 的客户端的集成。

deepagents-acp 包为您的 Deep Agent 提供了 ACP 支持：

npm install deepagents-acp

最快速的入门方式是使用 CLI：

npx deepagents-acp --name my-agent --workspace /path/to/project

或者以编程方式启动：

import { startServer } from "deepagents-acp";

await startServer({
  agents: {
    name: "coding-assistant",
    description: "具有文件系统访问权限的 AI 编程助手",
    skills: ["./skills/"],
  },
  workspaceRoot: process.cwd(),
});

若要与 Zed 集成，请在 Zed 的设置中添加以下配置：

{
  "agent": {
    "profiles": {
      "deepagents": {
        "name": "DeepAgents",
        "command": "npx",
        "args": ["deepagents-acp"]
      }
    }
  }
}

完整的文档和高级配置信息，请参阅 deepagents-acp 的 README 和 ACP 服务器示例。

deepagentsjs 快速上手指南

deepagentsjs 是一个基于 TypeScript 的 AI 智能体框架，旨在解决传统智能体在复杂长任务中规划能力不足的问题。它通过内置任务规划、子智能体（Sub-agents）、文件系统访问和详细提示词四大核心组件，帮助开发者轻松构建类似 "Deep Research" 或 "Claude Code" 的深度智能体应用。

环境准备

在开始之前，请确保您的开发环境满足以下要求：

• Node.js: 建议版本 18+
• TypeScript: 版本 5.0+
• 包管理器: npm, yarn 或 pnpm
• API Key: 若使用示例中的搜索功能，需准备 Tavily API Key (或其他 LLM 提供商的 Key)

安装步骤

使用您喜欢的包管理器安装 deepagents 核心库。如果您打算运行官方示例中的网络搜索功能，还需安装 @langchain/tavily。

# 使用 npm
npm install deepagents @langchain/tavily

# 使用 yarn
yarn add deepagents @langchain/tavily

# 使用 pnpm
pnpm add deepagents @langchain/tavily

注意：请确保在环境变量中设置 TAVILY_API_KEY，以便搜索工具正常工作。

基本使用

以下是一个最简示例，展示如何创建一个具备网络搜索能力的深度研究智能体。该智能体能够自动规划步骤、调用搜索工具并生成报告。

import { tool } from "langchain";
import { TavilySearch } from "@langchain/tavily";
import { createDeepAgent } from "deepagents";
import { z } from "zod";

// 1. 定义网络搜索工具
const internetSearch = tool(
  async ({
    query,
    maxResults = 5,
    topic = "general",
    includeRawContent = false,
  }: {
    query: string;
    maxResults?: number;
    topic?: "general" | "news" | "finance";
    includeRawContent?: boolean;
  }) => {
    const tavilySearch = new TavilySearch({
      maxResults,
      tavilyApiKey: process.env.TAVILY_API_KEY,
      includeRawContent,
      topic,
    });
    return await tavilySearch._call({ query });
  },
  {
    name: "internet_search",
    description: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      maxResults: z
        .number()
        .optional()
        .default(5)
        .describe("Maximum number of results to return"),
      topic: z
        .enum(["general", "news", "finance"])
        .optional()
        .default("general")
        .describe("Search topic category"),
      includeRawContent: z
        .boolean()
        .optional()
        .default(false)
        .describe("Whether to include raw content"),
    }),
  },
);

// 2. 设定系统提示词，赋予智能体专家角色
const researchInstructions = `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.
`;

// 3. 创建深度智能体
const agent = createDeepAgent({
  tools: [internetSearch],
  systemPrompt: researchInstructions,
  // 可选：自定义模型，默认使用 claude-sonnet-4-5-20250929
  // model: new ChatOpenAI({ model: "gpt-4o" }), 
});

// 4. 调用智能体执行任务
const result = await agent.invoke({
  messages: [{ role: "user", content: "What is langgraph?" }],
});

console.log(result.messages[result.messages.length - 1].content);

核心特性说明

• 自动规划：内置 write_todos 工具，智能体会自动将复杂问题拆解为步骤并跟踪进度。
• 文件操作：支持 ls, read_file, write_file 等工具，用于管理长上下文和持久化状态。
• 子智能体：可通过 task 工具派生专用子智能体处理特定子任务，隔离上下文干扰。
• 流式支持：完全兼容 LangGraph 的流式输出，支持实时查看 Token 生成和任务进度。