> ## Documentation Index
> Fetch the complete documentation index at: https://langchain-docs-zh.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# 定制 Deep Agents

> 学习如何通过系统提示词、工具、子智能体等自定义 Deep Agents

围绕你的目标构建框架。`create_deep_agent`为你提供生产就绪的基础：将其连接到你的数据，塑造其行为，并添加你的用例所需的功能。

:::python

```python Google theme={null}
from deepagents import create_deep_agent

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    system_prompt="You are a helpful assistant.",
    tools=[search, fetch_url],
    memory=["./AGENTS.md"],
    skills=["./skills/"],
)
```

```python OpenAI theme={null}
from deepagents import create_deep_agent

agent = create_deep_agent(
    model="openai:gpt-5.5",
    system_prompt="You are a helpful assistant.",
    tools=[search, fetch_url],
    memory=["./AGENTS.md"],
    skills=["./skills/"],
)
```

```python Anthropic theme={null}
from deepagents import create_deep_agent

agent = create_deep_agent(
    model="anthropic:claude-sonnet-5",
    system_prompt="You are a helpful assistant.",
    tools=[search, fetch_url],
    memory=["./AGENTS.md"],
    skills=["./skills/"],
)
```

```python OpenRouter theme={null}
from deepagents import create_deep_agent

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    system_prompt="You are a helpful assistant.",
    tools=[search, fetch_url],
    memory=["./AGENTS.md"],
    skills=["./skills/"],
)
```

```python Fireworks theme={null}
from deepagents import create_deep_agent

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    system_prompt="You are a helpful assistant.",
    tools=[search, fetch_url],
    memory=["./AGENTS.md"],
    skills=["./skills/"],
)
```

```python Baseten theme={null}
from deepagents import create_deep_agent

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    system_prompt="You are a helpful assistant.",
    tools=[search, fetch_url],
    memory=["./AGENTS.md"],
    skills=["./skills/"],
)
```

```python Ollama theme={null}
from deepagents import create_deep_agent

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    system_prompt="You are a helpful assistant.",
    tools=[search, fetch_url],
    memory=["./AGENTS.md"],
    skills=["./skills/"],
)
```

| 参数 | 功能 |
| - | - |
| [`model=`](#模型) | 使用哪个模型 |
| [`system_prompt=`](#系统提示词) | 智能体的自定义指令 |
| [`tools=`](#工具) | 智能体可以调用的领域工具 |
| [`memory=`](#记忆) | 启动时加载的 AGENTS.md 文件 |
| [`skills=`](#技能) | 按需知识技能目录 |
| [`backend=`](#后端) | 文件系统后端（默认为 StateBackend） |
| [`permissions=`](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/permissions) | 文件系统路径级访问控制 |
| [`subagents=`](#子代理) | 用于委托任务的定制子智能体 |
| [`middleware=`](#中间件) | 额外中间件合并到 [Deep Agents stack](#deep-agents-堆栈)；一个 `.name` 匹配内置条目的实例会替换它，其他任何内容都会放在核心中间件条目之后、配置、提示词缓存和记忆之前 |
| [`interrupt_on=`](#人机交互) | 在工具调用前暂停以供人工批准 |
| [`response_format=`](#结构化输出) | 结构化输出模式 |
| [`state_schema=`](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/context-engineering#自定义状态模式) | 定制图状态模式 |
| [`context_schema=`](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/context-engineering#运行时上下文) | 每次运行时运行时上下文模式（用户 ID、API 密钥、功能标志） |
| [profiles](#配置文件) | 每个模型的默认值作为一个可重用的包 |

> [accordion] Full function signature
>
> ```python theme={null}
> create_deep_agent(
>     model: str | BaseChatModel | None = None,
>     tools: Sequence[BaseTool | Callable | dict[str, Any]] | None = None,
>     *,
>     system_prompt: str | SystemMessage | None = None,
>     middleware: Sequence[AgentMiddleware[StateT_co, ContextT]] = (),
>     subagents: Sequence[SubAgent | CompiledSubAgent | AsyncSubAgent] | None = None,
>     skills: list[str] | None = None,
>     memory: list[str] | None = None,
>     permissions: list[FilesystemPermission] | None = None,
>     backend: BackendProtocol | None = None,
>     interrupt_on: dict[str, bool | InterruptOnConfig] | None = None,
>     response_format: ResponseFormat[ResponseT] | type[ResponseT] | dict[str, Any] | None = None,
>     state_schema: type[DeepAgentState] | None = None,
>     context_schema: type[ContextT] | None = None,
>     checkpointer: Checkpointer | None = None,
>     store: BaseStore | None = None,
>     debug: bool = False,
>     name: str | None = None,
>     cache: BaseCache | None = None
> ) -> CompiledStateGraph[AgentState[ResponseT], ContextT, InputAgentState, OutputAgentState[ResponseT]]
> ```

有关完整参数列表，请参阅 @\[`create_deep_agent` API 参考。要从头开始构建完全定制的 harness，请参阅 [配置 harness](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/agents.md#配置执行框架) 或遵循 [从头构建 deep agent](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/deep-agent-from-scratch.md) 的分步指南。
:::

:::js

`createDeepAgent` 附带了一个预组装的 harness：默认包含文件系统、摘要、子智能体和提示词缓存。以下参数允许您定义智能体的角色，将其连接到您的数据和工具，并通过额外的中间件扩展 [Deep Agents stack](#deep-agents-堆栈)。

```ts Google theme={null}
import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "google:gemini-3.6-flash",
  systemPrompt: "You are a helpful assistant.",
  tools: [search, fetchUrl],
  memory: ["./AGENTS.md"],
  skills: ["./skills/"],
});
```

```ts OpenAI theme={null}
import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "openai:gpt-5.5",
  systemPrompt: "You are a helpful assistant.",
  tools: [search, fetchUrl],
  memory: ["./AGENTS.md"],
  skills: ["./skills/"],
});
```

```ts Anthropic theme={null}
import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-5",
  systemPrompt: "You are a helpful assistant.",
  tools: [search, fetchUrl],
  memory: ["./AGENTS.md"],
  skills: ["./skills/"],
});
```

```ts OpenRouter theme={null}
import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "openrouter:z-ai/glm-5.2",
  systemPrompt: "You are a helpful assistant.",
  tools: [search, fetchUrl],
  memory: ["./AGENTS.md"],
  skills: ["./skills/"],
});
```

```ts Fireworks theme={null}
import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  systemPrompt: "You are a helpful assistant.",
  tools: [search, fetchUrl],
  memory: ["./AGENTS.md"],
  skills: ["./skills/"],
});
```

```ts Baseten theme={null}
import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  systemPrompt: "You are a helpful assistant.",
  tools: [search, fetchUrl],
  memory: ["./AGENTS.md"],
  skills: ["./skills/"],
});
```

```ts Ollama theme={null}
import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  systemPrompt: "You are a helpful assistant.",
  tools: [search, fetchUrl],
  memory: ["./AGENTS.md"],
  skills: ["./skills/"],
});
```

| 参数 | 功能 |
| - | - |
| `model` | 使用哪个模型 |
| `systemPrompt` | 智能体的自定义指令 |
| `tools` | 智能体可以调用的领域工具 |
| `memory` | 启动时加载的 AGENTS.md 文件 |
| `skills` | 按需知识技能目录 |
| `backend` | 文件系统后端（默认为 StateBackend） |
| `permissions` | 文件系统路径级访问控制 |
| `subagents` | 用于委托任务的定制子智能体 |
| `middleware` | 额外中间件追加到 [Deep Agents stack](#deep-agents-堆栈) |
| `interruptOn` | 在工具调用前暂停以供人工批准 |
| `responseFormat` | 结构化输出模式 |
| [`contextSchema`](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/context-engineering#运行时上下文) | 每次运行时运行时上下文模式（用户 ID、API 密钥、功能标志） |

有关完整参数列表，请参阅 [`createDeepAgent`](https://reference.langchain.com/javascript/deepagents/types/CreateDeepAgentParams) API 参考。要从头开始构建完全定制的 harness，请参阅 [配置 harness](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/agents.md#配置执行框架)，或遵循 [从头构建 deep agent](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/deep-agent-from-scratch.md) 的分步指南。

> [!TIP]
>
> 当你添加工具、子智能体和后端时，使用 [LangSmith](https://smith.langchain.com) 跟踪它们如何协同工作。按照 [可观测性快速入门](https://docs.langchain.com/langsmith/observability-quickstart) 设置即可。
>
> 我们建议你同时设置 [LangSmith 引擎](https://docs.langchain.com/langsmith/engine)，它监控你的跟踪记录、检测问题并建议解决方案。

## 模型

传递一个 `model` 字符串（`provider:model` 格式），或一个已初始化的模型实例。查看 [支持的所有模型](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/models.md#支持的模型)，以及 [推荐测试模型](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/models.md#推荐的模型) 获取经过测试的建议。

> [!TIP]
>
> 使用 `provider:model` 格式（例如 `openai:gpt-5.5`）快速切换模型。

:::python

> [tab] OpenAI
>
> 👉 请阅读 [OpenAI 对话模型集成文档](https://langchain-docs-zh.mintlify.site/langchain/oss/python/integrations/chat/openai.md)
>
> ```bash pip theme={null}
> pip install -U "langchain[openai]"
> ```
>
> ```bash uv theme={null}
> uv add "langchain[openai]"
> ```
>
> ```python default parameters theme={null}
> import os
> from deepagents import create_deep_agent
>
> os.environ["OPENAI_API_KEY"] = "sk-..."
>
> agent = create_deep_agent(model="openai:gpt-5.5")
> # this calls init_chat_model for the specified model with default parameters
> # to use specific model parameters, use init_chat_model directly
> ```
>
> ```python init_chat_model theme={null}
> import os
> from langchain.chat_models import init_chat_model
> from deepagents import create_deep_agent
>
> os.environ["OPENAI_API_KEY"] = "sk-..."
>
> model = init_chat_model(model="openai:gpt-5.5")
> agent = create_deep_agent(model=model)
> ```
>
> ```python model class theme={null}
> import os
> from langchain_openai import ChatOpenAI
> from deepagents import create_deep_agent
>
> os.environ["OPENAI_API_KEY"] = "sk-..."
>
> model = ChatOpenAI(model="gpt-5.5")
> agent = create_deep_agent(model=model)
> ```

> [tab] Anthropic
>
> 👉 请阅读 [Anthropic 对话模型集成文档](https://langchain-docs-zh.mintlify.site/langchain/oss/python/integrations/chat/anthropic.md)
>
> ```bash pip theme={null}
> pip install -U "langchain[anthropic]"
> ```
>
> ```bash uv theme={null}
> uv add "langchain[anthropic]"
> ```
>
> ```python default parameters theme={null}
> import os
> from deepagents import create_deep_agent
>
> os.environ["ANTHROPIC_API_KEY"] = "sk-..."
>
> agent = create_deep_agent(model="anthropic:claude-sonnet-4-6")
> # this calls init_chat_model for the specified model with default parameters
> # to use specific model parameters, use init_chat_model directly
> ```
>
> ```python init_chat_model theme={null}
> import os
> from langchain.chat_models import init_chat_model
> from deepagents import create_deep_agent
>
> os.environ["ANTHROPIC_API_KEY"] = "sk-..."
>
> model = init_chat_model(model="claude-sonnet-4-6")
> agent = create_deep_agent(model=model)
> ```
>
> ```python model class theme={null}
> import os
> from langchain_anthropic import ChatAnthropic
> from deepagents import create_deep_agent
>
> os.environ["ANTHROPIC_API_KEY"] = "sk-..."
>
> model = ChatAnthropic(model="claude-sonnet-4-6")
> agent = create_deep_agent(model=model)
> ```

> [tab] Azure
>
> 👉 请阅读 [Azure 对话模型集成文档](https://langchain-docs-zh.mintlify.site/langchain/oss/python/integrations/chat/azure_chat_openai.md)
>
> ```bash pip theme={null}
> pip install -U "langchain[openai]"
> ```
>
> ```bash uv theme={null}
> uv add "langchain[openai]"
> ```
>
> ```python default parameters theme={null}
> import os
> from deepagents import create_deep_agent
>
> os.environ["AZURE_OPENAI_API_KEY"] = "..."
> os.environ["AZURE_OPENAI_ENDPOINT"] = "..."
> os.environ["OPENAI_API_VERSION"] = "2025-03-01-preview"
>
> agent = create_deep_agent(model="azure_openai:gpt-5.5")
> # this calls init_chat_model for the specified model with default parameters
> # to use specific model parameters, use init_chat_model directly
> ```
>
> ```python init_chat_model theme={null}
> import os
> from langchain.chat_models import init_chat_model
> from deepagents import create_deep_agent
>
> os.environ["AZURE_OPENAI_API_KEY"] = "..."
> os.environ["AZURE_OPENAI_ENDPOINT"] = "..."
> os.environ["OPENAI_API_VERSION"] = "2025-03-01-preview"
>
> model = init_chat_model(
>     model="azure_openai:gpt-5.5",
>     azure_deployment=os.environ["AZURE_OPENAI_DEPLOYMENT_NAME"],
> )
> agent = create_deep_agent(model=model)
> ```
>
> ```python model class theme={null}
> import os
> from langchain_openai import AzureChatOpenAI
> from deepagents import create_deep_agent
>
> os.environ["AZURE_OPENAI_API_KEY"] = "..."
> os.environ["AZURE_OPENAI_ENDPOINT"] = "..."
> os.environ["OPENAI_API_VERSION"] = "2025-03-01-preview"
>
> model = AzureChatOpenAI(
>     model="gpt-5.5",
>     azure_deployment=os.environ["AZURE_OPENAI_DEPLOYMENT_NAME"],
> )
> agent = create_deep_agent(model=model)
> ```

> [tab] Google Gemini
>
> 👉 请阅读 [Google GenAI 对话模型集成文档](https://langchain-docs-zh.mintlify.site/langchain/oss/python/integrations/chat/google_generative_ai.md)
>
> ```bash pip theme={null}
> pip install -U "langchain[google-genai]"
> ```
>
> ```bash uv theme={null}
> uv add "langchain[google-genai]"
> ```
>
> ```python default parameters theme={null}
> import os
> from deepagents import create_deep_agent
>
> os.environ["GOOGLE_API_KEY"] = "..."
>
> agent = create_deep_agent(model="google_genai:gemini-3.6-flash")
> # this calls init_chat_model for the specified model with default parameters
> # to use specific model parameters, use init_chat_model directly
> ```
>
> ```python init_chat_model theme={null}
> import os
> from langchain.chat_models import init_chat_model
> from deepagents import create_deep_agent
>
> os.environ["GOOGLE_API_KEY"] = "..."
>
> model = init_chat_model(model="google_genai:gemini-3.6-flash")
> agent = create_deep_agent(model=model)
> ```
>
> ```python model class theme={null}
> import os
> from langchain_google_genai import ChatGoogleGenerativeAI
> from deepagents import create_deep_agent
>
> os.environ["GOOGLE_API_KEY"] = "..."
>
> model = ChatGoogleGenerativeAI(model="gemini-3.6-flash")
> agent = create_deep_agent(model=model)
> ```

> [tab] AWS Bedrock
>
> 👉 请阅读 [AWS Bedrock 对话模型集成文档](https://langchain-docs-zh.mintlify.site/langchain/oss/python/integrations/chat/bedrock.md)
>
> ```bash pip theme={null}
> pip install -U "langchain[aws]"
> ```
>
> ```bash uv theme={null}
> uv add "langchain[aws]"
> ```
>
> ```python default parameters theme={null}
> from deepagents import create_deep_agent
>
> # Follow the steps here to configure your credentials:
> # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
>
> agent = create_deep_agent(
>     model="anthropic.claude-sonnet-4-6",
>     model_provider="bedrock_converse",
> )
> # this calls init_chat_model for the specified model with default parameters
> # to use specific model parameters, use init_chat_model directly
> ```
>
> ```python init_chat_model theme={null}
> from langchain.chat_models import init_chat_model
> from deepagents import create_deep_agent
>
> # Follow the steps here to configure your credentials:
> # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
>
> model = init_chat_model(
>     model="anthropic.claude-sonnet-4-6",
>     model_provider="bedrock_converse",
> )
> agent = create_deep_agent(model=model)
> ```
>
> ```python model class theme={null}
> from langchain_aws import ChatBedrock
> from deepagents import create_deep_agent
>
> # Follow the steps here to configure your credentials:
> # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
>
> model = ChatBedrock(model="anthropic.claude-sonnet-4-6")
> agent = create_deep_agent(model=model)
> ```

> [tab] HuggingFace
>
> 👉 请阅读 [HuggingFace 对话模型集成文档](https://langchain-docs-zh.mintlify.site/langchain/oss/python/integrations/chat/huggingface.md)
>
> ```bash pip theme={null}
> pip install -U "langchain[huggingface]"
> ```
>
> ```bash uv theme={null}
> uv add "langchain[huggingface]"
> ```
>
> ```python default parameters theme={null}
> import os
> from deepagents import create_deep_agent
>
> os.environ["HUGGINGFACEHUB_API_TOKEN"] = "hf_..."
>
> agent = create_deep_agent(
>     model="microsoft/Phi-3-mini-4k-instruct",
>     model_provider="huggingface",
>     temperature=0.7,
>     max_tokens=1024,
> )
> # this calls init_chat_model for the specified model with default parameters
> # to use specific model parameters, use init_chat_model directly
> ```
>
> ```python init_chat_model theme={null}
> import os
> from langchain.chat_models import init_chat_model
> from deepagents import create_deep_agent
>
> os.environ["HUGGINGFACEHUB_API_TOKEN"] = "hf_..."
>
> model = init_chat_model(
>     model="microsoft/Phi-3-mini-4k-instruct",
>     model_provider="huggingface",
>     temperature=0.7,
>     max_tokens=1024,
> )
> agent = create_deep_agent(model=model)
> ```
>
> ```python model class theme={null}
> import os
> from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
> from deepagents import create_deep_agent
>
> os.environ["HUGGINGFACEHUB_API_TOKEN"] = "hf_..."
>
> llm = HuggingFaceEndpoint(
>     repo_id="microsoft/Phi-3-mini-4k-instruct",
>     temperature=0.7,
>     max_length=1024,
> )
> model = ChatHuggingFace(llm=llm)
> agent = create_deep_agent(model=model)
> ```

> [tab] Other
>
> 传递任何 [支持的模型字符串](https://docs.langchain.com/oss/python/deepagents/models#supported-models)，或已初始化的模型实例。例如：
>
> ```bash pip theme={null}
> pip install -U "langchain[deepseek]"
> ```
>
> ```bash uv theme={null}
> uv add "langchain[deepseek]"
> ```
>
> ```python default parameters theme={null}
> from deepagents import create_deep_agent
>
> agent = create_deep_agent(model="provider:model-name")
> ```
>
> ```python init_chat_model theme={null}
> from deepagents import create_deep_agent
> from langchain.chat_models import init_chat_model
>
> model = init_chat_model("provider:model-name")
> agent = create_deep_agent(model=model)
> ```
>
> ```python model class theme={null}
> from langchain_<provider> import Chat<Provider>
> # from langchain_deepseek import ChatDeepSeek
>
> from deepagents import create_deep_agent
>
> model = Chat<Provider>(model="model-name")
> # model = ChatDeepSeek(model="deepseek-v4-pro")
>
> agent = create_deep_agent(model=model)
> ```

:::

:::js

> [tab] OpenAI
>
> 👉 阅读 [OpenAI 对话模型集成文档](https://langchain-docs-zh.mintlify.site/langchain/oss/javascript/integrations/chat/openai.md)
>
> ```bash npm theme={null}
> npm install @langchain/openai deepagents
> ```
>
> ```bash pnpm theme={null}
> pnpm install @langchain/openai deepagents
> ```
>
> ```bash yarn theme={null}
> yarn add @langchain/openai deepagents
> ```
>
> ```bash bun theme={null}
> bun add @langchain/openai deepagents
> ```
>
> ```typescript default parameters theme={null}
> import { createDeepAgent } from "deepagents";
>
> process.env.OPENAI_API_KEY = "your-api-key";
>
> const agent = createDeepAgent({ model: "gpt-5.5" });
> // this calls initChatModel for the specified model with default parameters
> // to use specific model parameters, use initChatModel directly
> ```
>
> ```typescript initChatModel theme={null}
> import { initChatModel } from "langchain";
> import { createDeepAgent } from "deepagents";
>
> process.env.OPENAI_API_KEY = "your-api-key";
>
> const model = await initChatModel("gpt-5.5");
> const agent = createDeepAgent({
>   model,
>   temperature: 0,
> });
> ```
>
> ```typescript Model Class theme={null}
> import { ChatOpenAI } from "@langchain/openai";
> import { createDeepAgent } from "deepagents";
>
> const agent = createDeepAgent({
>   model: new ChatOpenAI({
>     model: "gpt-5.5",
>     apiKey: "your-api-key",
>     temperature: 0,
>   }),
> });
> ```

> [tab] Anthropic
>
> 👉 阅读 [Anthropic 对话模型集成文档](https://langchain-docs-zh.mintlify.site/langchain/oss/javascript/integrations/chat/anthropic.md)
>
> ```bash npm theme={null}
> npm install @langchain/anthropic deepagents
> ```
>
> ```bash pnpm theme={null}
> pnpm install @langchain/anthropic deepagents
> ```
>
> ```bash yarn theme={null}
> yarn add @langchain/anthropic deepagents
> ```
>
> ```bash bun theme={null}
> bun add @langchain/anthropic deepagents
> ```
>
> ```typescript default parameters theme={null}
> import { createDeepAgent } from "deepagents";
>
> process.env.ANTHROPIC_API_KEY = "your-api-key";
>
> const agent = createDeepAgent({ model: "anthropic:claude-sonnet-4-6" });
> // this calls initChatModel for the specified model with default parameters
> // to use specific model parameters, use initChatModel directly
> ```
>
> ```typescript initChatModel theme={null}
> import { initChatModel } from "langchain";
> import { createDeepAgent } from "deepagents";
>
> process.env.ANTHROPIC_API_KEY = "your-api-key";
>
> const model = await initChatModel("claude-sonnet-4-6");
> const agent = createDeepAgent({
>   model,
>   temperature: 0,
> });
> ```
>
> ```typescript Model Class theme={null}
> import { ChatAnthropic } from "@langchain/anthropic";
> import { createDeepAgent } from "deepagents";
>
> const agent = createDeepAgent({
>   model: new ChatAnthropic({
>     model: "claude-sonnet-4-6",
>     apiKey: "your-api-key",
>     temperature: 0,
>   }),
> });
> ```

> [tab] Azure
>
> 👉 阅读 [Azure 对话模型集成文档](https://langchain-docs-zh.mintlify.site/langchain/oss/javascript/integrations/chat/azure.md)
>
> ```bash npm theme={null}
> npm install @langchain/azure deepagents
> ```
>
> ```bash pnpm theme={null}
> pnpm install @langchain/azure deepagents
> ```
>
> ```bash yarn theme={null}
> yarn add @langchain/azure deepagents
> ```
>
> ```bash bun theme={null}
> bun add @langchain/azure deepagents
> ```
>
> ```typescript default parameters theme={null}
> import { createDeepAgent } from "deepagents";
>
> process.env.AZURE_OPENAI_API_KEY = "your-api-key";
> process.env.AZURE_OPENAI_ENDPOINT = "your-endpoint";
> process.env.OPENAI_API_VERSION = "your-api-version";
>
> const agent = createDeepAgent({ model: "azure_openai:gpt-5.5" });
> // this calls initChatModel for the specified model with default parameters
> // to use specific model parameters, use initChatModel directly
> ```
>
> ```typescript initChatModel theme={null}
> import { initChatModel } from "langchain";
> import { createDeepAgent } from "deepagents";
>
> process.env.AZURE_OPENAI_API_KEY = "your-api-key";
> process.env.AZURE_OPENAI_ENDPOINT = "your-endpoint";
> process.env.OPENAI_API_VERSION = "your-api-version";
>
> const model = await initChatModel("azure_openai:gpt-5.5");
> const agent = createDeepAgent({
>   model,
>   temperature: 0,
> });
> ```
>
> ```typescript Model Class theme={null}
> import { AzureChatOpenAI } from "@langchain/openai";
> import { createDeepAgent } from "deepagents";
>
> const agent = createDeepAgent({
>   model: new AzureChatOpenAI({
>     model: "gpt-5.5",
>     azureOpenAIApiKey: "your-api-key",
>     azureOpenAIApiEndpoint: "your-endpoint",
>     azureOpenAIApiVersion: "your-api-version",
>     temperature: 0,
>   }),
> });
> ```

> [tab] Google Gemini
>
> 👉 阅读 [ChatGoogle 对话模型集成文档](https://langchain-docs-zh.mintlify.site/langchain/oss/javascript/integrations/chat/google.md)
>
> ```bash npm theme={null}
> npm install @langchain/google deepagents
> ```
>
> ```bash pnpm theme={null}
> pnpm install @langchain/google deepagents
> ```
>
> ```bash yarn theme={null}
> yarn add @langchain/google deepagents
> ```
>
> ```bash bun theme={null}
> bun add @langchain/google deepagents
> ```
>
> ```typescript default parameters theme={null}
> import { createDeepAgent } from "deepagents";
>
> process.env.GOOGLE_API_KEY = "your-api-key";
>
> const agent = createDeepAgent({ model: "google:gemini-3.1-pro-preview" });
> // this calls initChatModel for the specified model with default parameters
> // to use specific model parameters, use initChatModel directly
> ```
>
> ```typescript initChatModel theme={null}
> import { initChatModel } from "langchain";
> import { createDeepAgent } from "deepagents";
>
> process.env.GOOGLE_API_KEY = "your-api-key";
>
> const model = await initChatModel("google:gemini-3.1-pro-preview");
> const agent = createDeepAgent({
>   model,
>   temperature: 0,
> });
> ```
>
> ```typescript Model Class theme={null}
> import { ChatGoogle } from "@langchain/google/node";
> import { createDeepAgent } from "deepagents";
>
> const agent = createDeepAgent({
>   model: new ChatGoogle({
>     model: "gemini-3.1-pro-preview",
>     apiKey: "your-api-key",
>     temperature: 0,
>   }),
> });
> ```

> [tab] Bedrock Converse
>
> 👉 阅读 [AWS Bedrock 对话模型集成文档](https://langchain-docs-zh.mintlify.site/langchain/oss/javascript/integrations/chat/bedrock_converse.md)
>
> ```bash npm theme={null}
> npm install @langchain/aws deepagents
> ```
>
> ```bash pnpm theme={null}
> pnpm install @langchain/aws deepagents
> ```
>
> ```bash yarn theme={null}
> yarn add @langchain/aws deepagents
> ```
>
> ```bash bun theme={null}
> bun add @langchain/aws deepagents
> ```
>
> ```typescript default parameters theme={null}
> import { createDeepAgent } from "deepagents";
>
> // Follow the steps here to configure your credentials:
> // https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
>
> const agent = createDeepAgent({ model: "bedrock:anthropic.claude-sonnet-4-6" });
> // this calls initChatModel for the specified model with default parameters
> // to use specific model parameters, use initChatModel directly
> ```
>
> ```typescript initChatModel theme={null}
> import { initChatModel } from "langchain";
> import { createDeepAgent } from "deepagents";
>
> // Follow the steps here to configure your credentials:
> // https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
>
> const model = await initChatModel("bedrock:anthropic.claude-sonnet-4-6");
> const agent = createDeepAgent({
>   model,
>   temperature: 0,
> });
> ```
>
> ```typescript Model Class theme={null}
> import { ChatBedrockConverse } from "@langchain/aws";
> import { createDeepAgent } from "deepagents";
>
> // Follow the steps here to configure your credentials:
> // https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
>
> const agent = createDeepAgent({
>   model: new ChatBedrockConverse({
>     model: "anthropic.claude-sonnet-4-6",
>     region: "us-east-2",
>     temperature: 0,
>   }),
> });
> ```

> [tab] Other
>
> 支持任何 [兼容的模型字符串](https://docs.langchain.com/oss/javascript/deepagents/models#supported-models)，或已初始化的模型实例：
>
> ```typescript theme={null}
> import { initChatModel } from "langchain";
> import { createDeepAgent } from "deepagents";
>
> const model = await initChatModel("provider:model-name");
> const agent = createDeepAgent({ model });
> ```

:::

> [!TIP]
>
> 对话模型会自动重试瞬态 API 失败（使用指数退避）。关于默认值、限制和调整代码示例，请参考 LangChain 的 [模型](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/models.md#连接弹性) 页面 `max_retries` / `timeout`。

## 工具

除了用于文件管理和子智能体创建的 [内置工具](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/overview.md#执行环境)，您还可以提供自定义工具：

:::python

```python Google theme={null}
import os
from typing import Literal
from tavily import TavilyClient
from deepagents import create_deep_agent

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


def internet_search(
    query: str,
    max_results: int = 5,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = False,
):
    """Run a web search"""
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )


agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    tools=[internet_search],
)
```

```python OpenAI theme={null}
import os
from typing import Literal
from tavily import TavilyClient
from deepagents import create_deep_agent

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


def internet_search(
    query: str,
    max_results: int = 5,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = False,
):
    """Run a web search"""
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )


agent = create_deep_agent(
    model="openai:gpt-5.5",
    tools=[internet_search],
)
```

```python Anthropic theme={null}
import os
from typing import Literal
from tavily import TavilyClient
from deepagents import create_deep_agent

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


def internet_search(
    query: str,
    max_results: int = 5,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = False,
):
    """Run a web search"""
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )


agent = create_deep_agent(
    model="anthropic:claude-sonnet-5",
    tools=[internet_search],
)
```

```python OpenRouter theme={null}
import os
from typing import Literal
from tavily import TavilyClient
from deepagents import create_deep_agent

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


def internet_search(
    query: str,
    max_results: int = 5,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = False,
):
    """Run a web search"""
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )


agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    tools=[internet_search],
)
```

```python Fireworks theme={null}
import os
from typing import Literal
from tavily import TavilyClient
from deepagents import create_deep_agent

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


def internet_search(
    query: str,
    max_results: int = 5,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = False,
):
    """Run a web search"""
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )


agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    tools=[internet_search],
)
```

```python Baseten theme={null}
import os
from typing import Literal
from tavily import TavilyClient
from deepagents import create_deep_agent

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


def internet_search(
    query: str,
    max_results: int = 5,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = False,
):
    """Run a web search"""
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )


agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    tools=[internet_search],
)
```

```python Ollama theme={null}
import os
from typing import Literal
from tavily import TavilyClient
from deepagents import create_deep_agent

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


def internet_search(
    query: str,
    max_results: int = 5,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = False,
):
    """Run a web search"""
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )


agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    tools=[internet_search],
)
```

:::

:::js

```ts Google theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      maxResults: z.number().optional().default(5),
      topic: z
        .enum(["general", "news", "finance"])
        .optional()
        .default("general"),
      includeRawContent: z.boolean().optional().default(false),
    }),
  },
);

const agent = createDeepAgent({
  model: "google:gemini-3.6-flash",
  tools: [internetSearch],
});
```

```ts OpenAI theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      maxResults: z.number().optional().default(5),
      topic: z
        .enum(["general", "news", "finance"])
        .optional()
        .default("general"),
      includeRawContent: z.boolean().optional().default(false),
    }),
  },
);

const agent = createDeepAgent({
  model: "openai:gpt-5.5",
  tools: [internetSearch],
});
```

```ts Anthropic theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      maxResults: z.number().optional().default(5),
      topic: z
        .enum(["general", "news", "finance"])
        .optional()
        .default("general"),
      includeRawContent: z.boolean().optional().default(false),
    }),
  },
);

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-5",
  tools: [internetSearch],
});
```

```ts OpenRouter theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      maxResults: z.number().optional().default(5),
      topic: z
        .enum(["general", "news", "finance"])
        .optional()
        .default("general"),
      includeRawContent: z.boolean().optional().default(false),
    }),
  },
);

const agent = createDeepAgent({
  model: "openrouter:z-ai/glm-5.2",
  tools: [internetSearch],
});
```

```ts Fireworks theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      maxResults: z.number().optional().default(5),
      topic: z
        .enum(["general", "news", "finance"])
        .optional()
        .default("general"),
      includeRawContent: z.boolean().optional().default(false),
    }),
  },
);

const agent = createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools: [internetSearch],
});
```

```ts Baseten theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      maxResults: z.number().optional().default(5),
      topic: z
        .enum(["general", "news", "finance"])
        .optional()
        .default("general"),
      includeRawContent: z.boolean().optional().default(false),
    }),
  },
);

const agent = createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools: [internetSearch],
});
```

```ts Ollama theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      maxResults: z.number().optional().default(5),
      topic: z
        .enum(["general", "news", "finance"])
        .optional()
        .default("general"),
      includeRawContent: z.boolean().optional().default(false),
    }),
  },
);

const agent = createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  tools: [internetSearch],
});
```

:::

### MCP 工具

> [!TIP]
>
> Deep Agents 完全支持 [模型上下文协议 (MCP)](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/mcp.md) 工具。您可以从任何 MCP 服务器（数据库、API、文件系统等）加载工具，并直接将它们传递给 `create_deep_agent`。

:::python
使用 `mcp` 额外功能安装 LangChain 以连接到 MCP 服务器：

```bash theme={null}
pip install "langchain[mcp]"
```

```python Google theme={null}
import asyncio

from deepagents import create_deep_agent
from langchain.mcp import MCPAdapter


async def main():
    config = {"mcpServers": {"my_server": {"url": "http://localhost:8000/mcp"}}}
    async with MCPAdapter(config) as adapter:
        tools = await adapter.list_tools()
        agent = create_deep_agent(
            model="google_genai:gemini-3.6-flash",
            tools=tools,
        )
        await agent.ainvoke(
            {
                "messages": [
                    {"role": "user", "content": "Use the MCP server to help me."}
                ]
            },
            config={"configurable": {"thread_id": "1"}},
        )
```

```python OpenAI theme={null}
import asyncio

from deepagents import create_deep_agent
from langchain.mcp import MCPAdapter


async def main():
    config = {"mcpServers": {"my_server": {"url": "http://localhost:8000/mcp"}}}
    async with MCPAdapter(config) as adapter:
        tools = await adapter.list_tools()
        agent = create_deep_agent(
            model="openai:gpt-5.5",
            tools=tools,
        )
        await agent.ainvoke(
            {
                "messages": [
                    {"role": "user", "content": "Use the MCP server to help me."}
                ]
            },
            config={"configurable": {"thread_id": "1"}},
        )
```

```python Anthropic theme={null}
import asyncio

from deepagents import create_deep_agent
from langchain.mcp import MCPAdapter


async def main():
    config = {"mcpServers": {"my_server": {"url": "http://localhost:8000/mcp"}}}
    async with MCPAdapter(config) as adapter:
        tools = await adapter.list_tools()
        agent = create_deep_agent(
            model="anthropic:claude-sonnet-5",
            tools=tools,
        )
        await agent.ainvoke(
            {
                "messages": [
                    {"role": "user", "content": "Use the MCP server to help me."}
                ]
            },
            config={"configurable": {"thread_id": "1"}},
        )
```

```python OpenRouter theme={null}
import asyncio

from deepagents import create_deep_agent
from langchain.mcp import MCPAdapter


async def main():
    config = {"mcpServers": {"my_server": {"url": "http://localhost:8000/mcp"}}}
    async with MCPAdapter(config) as adapter:
        tools = await adapter.list_tools()
        agent = create_deep_agent(
            model="openrouter:z-ai/glm-5.2",
            tools=tools,
        )
        await agent.ainvoke(
            {
                "messages": [
                    {"role": "user", "content": "Use the MCP server to help me."}
                ]
            },
            config={"configurable": {"thread_id": "1"}},
        )
```

```python Fireworks theme={null}
import asyncio

from deepagents import create_deep_agent
from langchain.mcp import MCPAdapter


async def main():
    config = {"mcpServers": {"my_server": {"url": "http://localhost:8000/mcp"}}}
    async with MCPAdapter(config) as adapter:
        tools = await adapter.list_tools()
        agent = create_deep_agent(
            model="fireworks:accounts/fireworks/models/glm-5p2",
            tools=tools,
        )
        await agent.ainvoke(
            {
                "messages": [
                    {"role": "user", "content": "Use the MCP server to help me."}
                ]
            },
            config={"configurable": {"thread_id": "1"}},
        )
```

```python Baseten theme={null}
import asyncio

from deepagents import create_deep_agent
from langchain.mcp import MCPAdapter


async def main():
    config = {"mcpServers": {"my_server": {"url": "http://localhost:8000/mcp"}}}
    async with MCPAdapter(config) as adapter:
        tools = await adapter.list_tools()
        agent = create_deep_agent(
            model="baseten:zai-org/GLM-5.2",
            tools=tools,
        )
        await agent.ainvoke(
            {
                "messages": [
                    {"role": "user", "content": "Use the MCP server to help me."}
                ]
            },
            config={"configurable": {"thread_id": "1"}},
        )
```

```python Ollama theme={null}
import asyncio

from deepagents import create_deep_agent
from langchain.mcp import MCPAdapter


async def main():
    config = {"mcpServers": {"my_server": {"url": "http://localhost:8000/mcp"}}}
    async with MCPAdapter(config) as adapter:
        tools = await adapter.list_tools()
        agent = create_deep_agent(
            model="ollama:north-mini-code-1.0",
            tools=tools,
        )
        await agent.ainvoke(
            {
                "messages": [
                    {"role": "user", "content": "Use the MCP server to help me."}
                ]
            },
            config={"configurable": {"thread_id": "1"}},
        )
```

:::

:::js
使用 `@langchain/mcp-adapters` 连接到 MCP 服务器：

```bash theme={null}
npm install @langchain/mcp-adapters
```

```ts Google theme={null}
import { createDeepAgent } from "deepagents";

const { MultiServerMCPClient } = await import("@langchain/mcp-adapters");

const client = new MultiServerMCPClient({
    my_server: {
        transport: "http",
        url: "http://localhost:8000/mcp",
    },
});

const tools = await client.getTools();

const agent = await createDeepAgent({
    model: "google:gemini-3.6-flash",
    tools,
});

const result = await agent.invoke({
    messages: [{ role: "user", content: "Use the MCP server to help me." }],
});
```

```ts OpenAI theme={null}
import { createDeepAgent } from "deepagents";

const { MultiServerMCPClient } = await import("@langchain/mcp-adapters");

const client = new MultiServerMCPClient({
    my_server: {
        transport: "http",
        url: "http://localhost:8000/mcp",
    },
});

const tools = await client.getTools();

const agent = await createDeepAgent({
    model: "openai:gpt-5.5",
    tools,
});

const result = await agent.invoke({
    messages: [{ role: "user", content: "Use the MCP server to help me." }],
});
```

```ts Anthropic theme={null}
import { createDeepAgent } from "deepagents";

const { MultiServerMCPClient } = await import("@langchain/mcp-adapters");

const client = new MultiServerMCPClient({
    my_server: {
        transport: "http",
        url: "http://localhost:8000/mcp",
    },
});

const tools = await client.getTools();

const agent = await createDeepAgent({
    model: "anthropic:claude-sonnet-5",
    tools,
});

const result = await agent.invoke({
    messages: [{ role: "user", content: "Use the MCP server to help me." }],
});
```

```ts OpenRouter theme={null}
import { createDeepAgent } from "deepagents";

const { MultiServerMCPClient } = await import("@langchain/mcp-adapters");

const client = new MultiServerMCPClient({
    my_server: {
        transport: "http",
        url: "http://localhost:8000/mcp",
    },
});

const tools = await client.getTools();

const agent = await createDeepAgent({
    model: "openrouter:z-ai/glm-5.2",
    tools,
});

const result = await agent.invoke({
    messages: [{ role: "user", content: "Use the MCP server to help me." }],
});
```

```ts Fireworks theme={null}
import { createDeepAgent } from "deepagents";

const { MultiServerMCPClient } = await import("@langchain/mcp-adapters");

const client = new MultiServerMCPClient({
    my_server: {
        transport: "http",
        url: "http://localhost:8000/mcp",
    },
});

const tools = await client.getTools();

const agent = await createDeepAgent({
    model: "fireworks:accounts/fireworks/models/glm-5p2",
    tools,
});

const result = await agent.invoke({
    messages: [{ role: "user", content: "Use the MCP server to help me." }],
});
```

```ts Baseten theme={null}
import { createDeepAgent } from "deepagents";

const { MultiServerMCPClient } = await import("@langchain/mcp-adapters");

const client = new MultiServerMCPClient({
    my_server: {
        transport: "http",
        url: "http://localhost:8000/mcp",
    },
});

const tools = await client.getTools();

const agent = await createDeepAgent({
    model: "baseten:zai-org/GLM-5.2",
    tools,
});

const result = await agent.invoke({
    messages: [{ role: "user", content: "Use the MCP server to help me." }],
});
```

```ts Ollama theme={null}
import { createDeepAgent } from "deepagents";

const { MultiServerMCPClient } = await import("@langchain/mcp-adapters");

const client = new MultiServerMCPClient({
    my_server: {
        transport: "http",
        url: "http://localhost:8000/mcp",
    },
});

const tools = await client.getTools();

const agent = await createDeepAgent({
    model: "ollama:north-mini-code-1.0",
    tools,
});

const result = await agent.invoke({
    messages: [{ role: "user", content: "Use the MCP server to help me." }],
});
```

:::

有关详细配置选项，包括 stdio 服务器、OAuth 身份验证、工具过滤和有状态会话，请参阅完整的 [MCP 指南](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/mcp.md)。

## 系统提示词

将 `system_prompt=` 传递给智能体以提供您的自定义指令：

:::python

```python Google theme={null}
from deepagents import create_deep_agent

research_instructions = """\
You are an expert researcher. Your job is to conduct \
thorough research, and then write a polished report. \
"""

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    system_prompt=research_instructions,
)
```

```python OpenAI theme={null}
from deepagents import create_deep_agent

research_instructions = """\
You are an expert researcher. Your job is to conduct \
thorough research, and then write a polished report. \
"""

agent = create_deep_agent(
    model="openai:gpt-5.5",
    system_prompt=research_instructions,
)
```

```python Anthropic theme={null}
from deepagents import create_deep_agent

research_instructions = """\
You are an expert researcher. Your job is to conduct \
thorough research, and then write a polished report. \
"""

agent = create_deep_agent(
    model="anthropic:claude-sonnet-5",
    system_prompt=research_instructions,
)
```

```python OpenRouter theme={null}
from deepagents import create_deep_agent

research_instructions = """\
You are an expert researcher. Your job is to conduct \
thorough research, and then write a polished report. \
"""

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    system_prompt=research_instructions,
)
```

```python Fireworks theme={null}
from deepagents import create_deep_agent

research_instructions = """\
You are an expert researcher. Your job is to conduct \
thorough research, and then write a polished report. \
"""

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    system_prompt=research_instructions,
)
```

```python Baseten theme={null}
from deepagents import create_deep_agent

research_instructions = """\
You are an expert researcher. Your job is to conduct \
thorough research, and then write a polished report. \
"""

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    system_prompt=research_instructions,
)
```

```python Ollama theme={null}
from deepagents import create_deep_agent

research_instructions = """\
You are an expert researcher. Your job is to conduct \
thorough research, and then write a polished report. \
"""

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    system_prompt=research_instructions,
)
```

:::

:::js

```ts Google theme={null}
import { createDeepAgent } from "deepagents";

const researchInstructions =
  `You are an expert researcher. ` +
  `Your job is to conduct thorough research, and then ` +
  `write a polished report.`;

const agent = createDeepAgent({
  model: "google:gemini-3.6-flash",
  systemPrompt: researchInstructions,
});
```

```ts OpenAI theme={null}
import { createDeepAgent } from "deepagents";

const researchInstructions =
  `You are an expert researcher. ` +
  `Your job is to conduct thorough research, and then ` +
  `write a polished report.`;

const agent = createDeepAgent({
  model: "openai:gpt-5.5",
  systemPrompt: researchInstructions,
});
```

```ts Anthropic theme={null}
import { createDeepAgent } from "deepagents";

const researchInstructions =
  `You are an expert researcher. ` +
  `Your job is to conduct thorough research, and then ` +
  `write a polished report.`;

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-5",
  systemPrompt: researchInstructions,
});
```

```ts OpenRouter theme={null}
import { createDeepAgent } from "deepagents";

const researchInstructions =
  `You are an expert researcher. ` +
  `Your job is to conduct thorough research, and then ` +
  `write a polished report.`;

const agent = createDeepAgent({
  model: "openrouter:z-ai/glm-5.2",
  systemPrompt: researchInstructions,
});
```

```ts Fireworks theme={null}
import { createDeepAgent } from "deepagents";

const researchInstructions =
  `You are an expert researcher. ` +
  `Your job is to conduct thorough research, and then ` +
  `write a polished report.`;

const agent = createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  systemPrompt: researchInstructions,
});
```

```ts Baseten theme={null}
import { createDeepAgent } from "deepagents";

const researchInstructions =
  `You are an expert researcher. ` +
  `Your job is to conduct thorough research, and then ` +
  `write a polished report.`;

const agent = createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  systemPrompt: researchInstructions,
});
```

```ts Ollama theme={null}
import { createDeepAgent } from "deepagents";

const researchInstructions =
  `You are an expert researcher. ` +
  `Your job is to conduct thorough research, and then ` +
  `write a polished report.`;

const agent = createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  systemPrompt: researchInstructions,
});
```

:::

> [!NOTE]
>
> 除了字符串，主要智能体还接受一个 @\[`SystemMessage`] 结构化 [内容块](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/messages.md#标准内容块)；Deep Agents 保留这些块（[子智能体](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/subagents.md)字典规范保持为字符串）。

> [accordion] Subagent prompts
>
> 声明式[子智能体](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/subagents.md)根据其自身模型解析配置覆盖，然后将解析后的配置的`base_system_prompt`/`system_prompt_suffix`应用于子智能体编写的`system_prompt`。仅包含`system_prompt_suffix`的配置（内置Anthropic/OpenAI配置的常见情况）将追加到编写的提示词中。设置`base_system_prompt`的配置将完全替换它。

> [accordion] General-purpose subagent prompt
>
> 自动添加的[通用子智能体](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/subagents.md#通用子智能体)将其基础提示词解析为\*\*`general_purpose_subagent.system_prompt`（如果设置）-> `HarnessProfile.base_system_prompt`（如果设置）-> SDK通用默认值\*\*，并在顶部叠加配置后缀。当两个覆盖字段都设置时，通用特定字段优先，因此同时调整两个字段的调用者不会看到其通用覆盖被无声丢弃：
>
> ```python theme={null}
> from deepagents import (
>     GeneralPurposeSubagentProfile,
>     HarnessProfile,
>     register_harness_profile,
> )
>
> register_harness_profile(
>     "anthropic",
>     HarnessProfile(
>         base_system_prompt="You are ACME's support orchestrator.",  # main agent
>         general_purpose_subagent=GeneralPurposeSubagentProfile(
>             system_prompt="You are a research subagent. Cite sources.",  # GP subagent
>         ),
>         system_prompt_suffix="Always think step by step.",
>     ),
> )
> ```
>
> | 栈 | 最终系统提示词 |
> | - | - |
> | 主智能体 | `"You are ACME's support orchestrator." + SUFFIX` |
> | 通用子智能体 | `"You are a research subagent. Cite sources." + SUFFIX` |

## 中间件

深度智能体支持任何[中间件](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/middleware/overview.md)，包括以下内置中间件、LangChain预构建的中间件、特定提供者的中间件以及您自己编写的自定义中间件。

:::python
将中间件传递给`create_deep_agent`的`middleware`参数。每个实例通过将其`.name`与栈中已有的内置条目进行匹配，合并到[深度智能体栈](#deep-agents-堆栈)中：匹配则替换该实例，不匹配则插入@\[`PatchToolCallsMiddleware`]之后。参见[覆盖默认中间件实例](#覆盖默认中间件实例)。
:::

将中间件传递给 `middleware` 的 `createDeepAgent` 参数。每个实例通过其 `.name` 被合并到 [Deep Agents stack](#deep-agents-堆栈) 中。名称与内置条目匹配的实例会替换该条目。其他内容则插入到 @\[`PatchToolCallsMiddleware`] 之后。

### Deep Agents 堆栈

:::python
`create_deep_agent` 以固定顺序构建中间件。[bare stack](#裸栈模式) 是仅包含模型时得到的结果。[full stack](#全栈) 是完整的组装顺序，包括仅在传递可选参数或解析的 [harness profile](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/profiles.md) 贡献时出现的槽位。
:::

:::js
`createDeepAgent` 以固定顺序构建中间件。[bare stack](#裸栈模式) 是仅包含模型时得到的结果。[full stack](#全栈) 是完整的组装顺序，包括仅在传递可选参数或解析的 [harness profile](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/profiles.md) 贡献时出现的槽位。
:::

#### 裸栈模式

:::python
仅包含 `model`（无其他可选参数）时，主智能体通常包括：

1. @\[`FilesystemMiddleware`]
2. @\[`SubAgentMiddleware`]（[因为通用子智能体](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/subagents.md#默认子智能体)会自动添加，除非 harness profile 禁用它）
3. @\[`SummarizationMiddleware`]
4. @\[`PatchToolCallsMiddleware`]
5. **提示词缓存**中间件（始终注册；对不支持的模型，每个条目不执行操作）
6. **Harness profile 附加功能**和**排除工具过滤**，如果解析的模型配置定义了它们
   :::

:::js
仅有一个`model`（无其他可选参数），主智能体通常包括：

1. @\[`FilesystemMiddleware`]
2. @\[`SubAgentMiddleware`]（[因为通用子智能体](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/subagents.md#默认子智能体)会自动添加，除非 harness profile 禁用它）
3. @\[`SummarizationMiddleware`]
4. @\[`PatchToolCallsMiddleware`]
5. **提示词缓存**中间件（为支持的提供者添加；其他地方不执行操作）
6. **Harness profile 附加功能**和**排除工具过滤**，如果解析的模型配置定义了它们
7. @\[`UnsupportedContentMiddleware`]
   :::

#### 全栈

从第一到最后一层：

:::python

1. @\[`FilesystemMiddleware`]: 处理文件系统操作，如读取、写入和导航目录。当你传递 `permissions` 时，这里包含文件系统权限强制执行，以便它可以评估智能体可能调用的每个工具。

2. @\[`SubAgentMiddleware`]: 仅当至少有一个同步子智能体可用时。生成和协调子智能体以委托任务。包含在 [裸栈](#裸栈模式) 中，因为通用子智能体默认自动添加；通过禁用该子智能体并传递无同步 `subagents` 来省略它。参见 [无子智能体运行](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/subagents.md#不使用子智能体)。

3. @\[`SummarizationMiddleware`]: 当对话变长时（通过 @\[create\_summarization\_middleware]），将消息历史压缩以保持在上下文限制内。

4. @\[`PatchToolCallsMiddleware`]: 在消息历史中修复悬空工具调用，当运行在中断后恢复或接收格式错误的工具调用参数时。在Anthropic提示缓存和下方的尾栈之前 **运行**。

5. @\[`AsyncSubAgentMiddleware`]: 仅当你配置异步子智能体时。

6. **你的中间件参数**: 作为 `middleware` 参数传递的可选中间件在Patch之后但在堆栈其余部分之前合并。其 `.name` 与上面内置条目之一匹配的实例会替换该实例，而不是复制它；其他任何内容都会放在这里。参见 [覆盖默认中间件实例](#覆盖默认中间件实例)。

7. **利用配置文件附加**: 解析的模型配置文件提供的特定于提供者的中间件，如果有的话。

8. @\[`SkillsMiddleware`]: 仅当你传递 `skills` 时。在您的中间件之后、提示缓存之前运行，因此它看到总结的对话和实际调用的模型。传递一个名为 `SkillsMiddleware` 的中间件会将其就地替换。

9. **提示缓存** (@\[`AnthropicPromptCachingMiddleware`] 和 @\[`BedrockPromptCachingMiddleware`]): 两者始终注册并在Patch之后以及您的中间件之后运行，以便缓存的prefix与实际发送到模型的匹配。它们在它们不支持的模型上执行no-ops (`unsupported_model_behavior="ignore"`)，因此Anthropic中间件适用于Anthropic模型，Bedrock中间件适用于具有缓存支持的AWS Bedrock模型。

10. @\[`MemoryMiddleware`]: 仅当你传递 `memory` 时。

    > [!NOTE]
    >
    > `MemoryMiddleware` 放在 **profile extras** 和提示缓存中间件之后，因此注入记忆的更新不太可能使缓存prefix失效。在 `create_deep_agent` 实现注释中也提到了相同的排序问题。

11. `HumanInTheLoopMiddleware`: 仅当通过 `interrupt_on` 时。在配置的工具调用处暂停，等待人工批准或输入。

12. **排除工具过滤**: 当 harness profile 列出排除的工具时，中间件会从智能体中移除这些工具。

:::

:::js

1. @\[`FilesystemMiddleware`]: 处理文件系统操作，如读取、写入和导航目录。当通过 `permissions` 时，文件系统权限强制执行包含在内，以便它可以评估智能体可能调用的每个工具。

2. @\[`SubAgentMiddleware`]: 仅当至少有一个同步子智能体可用时。生成和协调子智能体以委托任务。包含在 [裸栈](#裸栈模式) 中，因为通用子智能体默认自动添加；通过禁用该子智能体并传递无同步 `subagents` 来省略它。参见 [无子智能体运行](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/subagents.md#不使用子智能体)。

3. @\[`SummarizationMiddleware`]: 当对话变长时，通过 @\[createSummarizationMiddleware] 将消息历史压缩以保持在上下文限制内。

4. @\[`PatchToolCallsMiddleware`]: 在运行中断后恢复或接收到格式错误的工具调用参数时，修复消息历史中的悬空工具调用。运行 **在** Anthropic 提示词缓存和下方的尾栈 **之前**。

5. @\[`AsyncSubAgentMiddleware`]: 仅当您配置异步子智能体时。

6. **您的中间件参数**: 作为 `middleware` 参数传递的可选中间件在 Patch 之后但在其余栈之前合并。其 `.name` 与内置条目匹配的实例会原位替换该条目，而不是重复它。其他内容会放在这里。

7. **Harness profile 附加**: 从解析的模型 profile 中提供的特定于提供者的中间件，如果有的话。

8. @\[`SkillsMiddleware`]: 仅当通过 `skills`，或通过 `createSkillsMiddleware` 实例传递到 `middleware`。无论如何，它都在您的中间件之后、提示词缓存之前运行，因此可以看到总结的对话和实际调用的模型。

9. **提示词缓存** (@\[`AnthropicPromptCachingMiddleware`] 和 @\[`BedrockPromptCachingMiddleware`]): 分别为 Anthropic 模型和 Amazon Bedrock Converse 模型自动添加。两者都在 Patch 之后和您的中间件之后运行，因此缓存的prefix与实际发送给模型的内容匹配。

10. @\[`MemoryMiddleware`]: 仅当通过 `memory`。

    > [!NOTE]
    >
    > `MemoryMiddleware` 放置在 profile 附加和提示词缓存中间件 **之后**，因此注入的记忆更新不太可能使缓存前缀失效。在 `createDeepAgent` 实现评论中也提到了相同的排序问题。

11. `HumanInTheLoopMiddleware`: 仅当传递 `interruptOn` 时。在配置的工具调用处暂停，等待人工批准或输入。

12. **排除工具过滤**: 当 harness profile 列出排除的工具时，中间件会从智能体中移除这些工具。

13. @\[`UnsupportedContentMiddleware`]: 使用文本占位符重写请求中的不支持的多元模态内容。

:::

### 同步子智能体栈

:::python

内置的 **通用** 子智能体和每个声明式的同步 `SubAgent` 图使用一个栈，`create_deep_agent` 在代码中构建。它在大致形状上与主智能体匹配（文件系统、摘要、Patch、配置文件额外信息、技能、Anthropic 和 Bedrock 缓存、可选权限），但子智能体图中 **没有** @\[`SubAgentMiddleware`]（只有父智能体暴露 `task` 工具）。

当声明式子智能体设置 `interrupt_on` 时，该值会被转发到 `create_agent` 以供子智能体使用，这会为配置的工具调用设置人工参与处理。

:::

:::js

内置的 **通用** 子智能体和每个声明式的同步 `SubAgent` 图使用一个栈，`createDeepAgent` 在代码中构建。它在大致形状上与主智能体匹配（文件系统、摘要、Patch、配置文件额外信息、技能、Anthropic 和 Bedrock 缓存、可选权限），但子智能体图中 **没有** @\[`SubAgentMiddleware`]（只有父智能体暴露 `task` 工具）。

当声明式子智能体设置 `interruptOn` 时，该值会被转发到 `createAgent` 以供子智能体使用，这会为配置的工具调用设置人工参与处理。

:::

### 预构建的中间件

LangChain 提供了额外的预构建中间件，允许你添加各种功能，如重试、回退或 PII 检测。更多详情请参见 [预构建的中间件](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/middleware/built-in.md)。

:::python

`deepagents` 库还暴露了 @\[`create_summarization_tool_middleware`]，使智能体能够在适当时机触发摘要——例如在任务之间——而不是在固定的 Token 间隔。更多详情请参见 [摘要](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/context-engineering.md#摘要)。

:::

:::js

`deepagents` 包还为相同的工作流程暴露了 @\[`createSummarizationMiddleware`]。更多详情请参见 [摘要](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/context-engineering.md#摘要)。

:::

### 提供商特定的中间件

有关针对特定 LLM 提供商优化的提供商特定中间件，请参见 [中间件集成](https://langchain-docs-zh.mintlify.site/langchain/oss/python/integrations/middleware.md)。

### 自定义中间件

你可以提供额外的中间件来扩展功能、添加工具或实现自定义钩子：

:::python

```python Google theme={null}
from langchain.agents.middleware import wrap_tool_call
from langchain.tools import tool
from deepagents import create_deep_agent


@tool
def get_weather(city: str) -> str:
    """Get the weather in a city."""
    return f"The weather in {city} is sunny."


call_count = [0]  # Use list to allow modification in nested function


@wrap_tool_call
def log_tool_calls(request, handler):
    """Intercept and log every tool call - demonstrates cross-cutting concern."""
    call_count[0] += 1
    tool_name = request.name if hasattr(request, "name") else str(request)

    print(f"[Middleware] Tool call #{call_count[0]}: {tool_name}")
    print(f"[Middleware] Arguments: {request.args if hasattr(request, 'args') else 'N/A'}")

    # Execute the tool call
    result = handler(request)

    # Log the result
    print(f"[Middleware] Tool call #{call_count[0]} completed")

    return result


agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    tools=[get_weather],
    middleware=[log_tool_calls],
)
```

```python OpenAI theme={null}
from langchain.agents.middleware import wrap_tool_call
from langchain.tools import tool
from deepagents import create_deep_agent


@tool
def get_weather(city: str) -> str:
    """Get the weather in a city."""
    return f"The weather in {city} is sunny."


call_count = [0]  # Use list to allow modification in nested function


@wrap_tool_call
def log_tool_calls(request, handler):
    """Intercept and log every tool call - demonstrates cross-cutting concern."""
    call_count[0] += 1
    tool_name = request.name if hasattr(request, "name") else str(request)

    print(f"[Middleware] Tool call #{call_count[0]}: {tool_name}")
    print(f"[Middleware] Arguments: {request.args if hasattr(request, 'args') else 'N/A'}")

    # Execute the tool call
    result = handler(request)

    # Log the result
    print(f"[Middleware] Tool call #{call_count[0]} completed")

    return result


agent = create_deep_agent(
    model="openai:gpt-5.5",
    tools=[get_weather],
    middleware=[log_tool_calls],
)
```

```python Anthropic theme={null}
from langchain.agents.middleware import wrap_tool_call
from langchain.tools import tool
from deepagents import create_deep_agent


@tool
def get_weather(city: str) -> str:
    """Get the weather in a city."""
    return f"The weather in {city} is sunny."


call_count = [0]  # Use list to allow modification in nested function


@wrap_tool_call
def log_tool_calls(request, handler):
    """Intercept and log every tool call - demonstrates cross-cutting concern."""
    call_count[0] += 1
    tool_name = request.name if hasattr(request, "name") else str(request)

    print(f"[Middleware] Tool call #{call_count[0]}: {tool_name}")
    print(f"[Middleware] Arguments: {request.args if hasattr(request, 'args') else 'N/A'}")

    # Execute the tool call
    result = handler(request)

    # Log the result
    print(f"[Middleware] Tool call #{call_count[0]} completed")

    return result


agent = create_deep_agent(
    model="anthropic:claude-sonnet-5",
    tools=[get_weather],
    middleware=[log_tool_calls],
)
```

```python OpenRouter theme={null}
from langchain.agents.middleware import wrap_tool_call
from langchain.tools import tool
from deepagents import create_deep_agent


@tool
def get_weather(city: str) -> str:
    """Get the weather in a city."""
    return f"The weather in {city} is sunny."


call_count = [0]  # Use list to allow modification in nested function


@wrap_tool_call
def log_tool_calls(request, handler):
    """Intercept and log every tool call - demonstrates cross-cutting concern."""
    call_count[0] += 1
    tool_name = request.name if hasattr(request, "name") else str(request)

    print(f"[Middleware] Tool call #{call_count[0]}: {tool_name}")
    print(f"[Middleware] Arguments: {request.args if hasattr(request, 'args') else 'N/A'}")

    # Execute the tool call
    result = handler(request)

    # Log the result
    print(f"[Middleware] Tool call #{call_count[0]} completed")

    return result


agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    tools=[get_weather],
    middleware=[log_tool_calls],
)
```

```python Fireworks theme={null}
from langchain.agents.middleware import wrap_tool_call
from langchain.tools import tool
from deepagents import create_deep_agent


@tool
def get_weather(city: str) -> str:
    """Get the weather in a city."""
    return f"The weather in {city} is sunny."


call_count = [0]  # Use list to allow modification in nested function


@wrap_tool_call
def log_tool_calls(request, handler):
    """Intercept and log every tool call - demonstrates cross-cutting concern."""
    call_count[0] += 1
    tool_name = request.name if hasattr(request, "name") else str(request)

    print(f"[Middleware] Tool call #{call_count[0]}: {tool_name}")
    print(f"[Middleware] Arguments: {request.args if hasattr(request, 'args') else 'N/A'}")

    # Execute the tool call
    result = handler(request)

    # Log the result
    print(f"[Middleware] Tool call #{call_count[0]} completed")

    return result


agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    tools=[get_weather],
    middleware=[log_tool_calls],
)
```

```python Baseten theme={null}
from langchain.agents.middleware import wrap_tool_call
from langchain.tools import tool
from deepagents import create_deep_agent


@tool
def get_weather(city: str) -> str:
    """Get the weather in a city."""
    return f"The weather in {city} is sunny."


call_count = [0]  # Use list to allow modification in nested function


@wrap_tool_call
def log_tool_calls(request, handler):
    """Intercept and log every tool call - demonstrates cross-cutting concern."""
    call_count[0] += 1
    tool_name = request.name if hasattr(request, "name") else str(request)

    print(f"[Middleware] Tool call #{call_count[0]}: {tool_name}")
    print(f"[Middleware] Arguments: {request.args if hasattr(request, 'args') else 'N/A'}")

    # Execute the tool call
    result = handler(request)

    # Log the result
    print(f"[Middleware] Tool call #{call_count[0]} completed")

    return result


agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    tools=[get_weather],
    middleware=[log_tool_calls],
)
```

```python Ollama theme={null}
from langchain.agents.middleware import wrap_tool_call
from langchain.tools import tool
from deepagents import create_deep_agent


@tool
def get_weather(city: str) -> str:
    """Get the weather in a city."""
    return f"The weather in {city} is sunny."


call_count = [0]  # Use list to allow modification in nested function


@wrap_tool_call
def log_tool_calls(request, handler):
    """Intercept and log every tool call - demonstrates cross-cutting concern."""
    call_count[0] += 1
    tool_name = request.name if hasattr(request, "name") else str(request)

    print(f"[Middleware] Tool call #{call_count[0]}: {tool_name}")
    print(f"[Middleware] Arguments: {request.args if hasattr(request, 'args') else 'N/A'}")

    # Execute the tool call
    result = handler(request)

    # Log the result
    print(f"[Middleware] Tool call #{call_count[0]} completed")

    return result


agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    tools=[get_weather],
    middleware=[log_tool_calls],
)
```

:::

:::js

```ts Google theme={null}
import { tool, createMiddleware } from "langchain";
import { createDeepAgent } from "deepagents";
import * as z from "zod";

const getWeather = tool(
  ({ city }: { city: string }) => {
    return `The weather in ${city} is sunny.`;
  },
  {
    name: "get_weather",
    description: "Get the weather in a city.",
    schema: z.object({
      city: z.string(),
    }),
  },
);

let callCount = 0;

const logToolCallsMiddleware = createMiddleware({
  name: "LogToolCallsMiddleware",
  wrapToolCall: async (request, handler) => {
    // Intercept and log every tool call - demonstrates cross-cutting concern
    callCount += 1;
    const toolName = request.toolCall.name;

    console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
    console.log(
      `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
    );

    // Execute the tool call
    const result = await handler(request);

    // Log the result
    console.log(`[Middleware] Tool call #${callCount} completed`);

    return result;
  },
});

const agent = await createDeepAgent({
  model: "google:gemini-3.6-flash",
  tools: [getWeather] as any,
  middleware: [logToolCallsMiddleware] as any,
});
```

```ts OpenAI theme={null}
import { tool, createMiddleware } from "langchain";
import { createDeepAgent } from "deepagents";
import * as z from "zod";

const getWeather = tool(
  ({ city }: { city: string }) => {
    return `The weather in ${city} is sunny.`;
  },
  {
    name: "get_weather",
    description: "Get the weather in a city.",
    schema: z.object({
      city: z.string(),
    }),
  },
);

let callCount = 0;

const logToolCallsMiddleware = createMiddleware({
  name: "LogToolCallsMiddleware",
  wrapToolCall: async (request, handler) => {
    // Intercept and log every tool call - demonstrates cross-cutting concern
    callCount += 1;
    const toolName = request.toolCall.name;

    console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
    console.log(
      `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
    );

    // Execute the tool call
    const result = await handler(request);

    // Log the result
    console.log(`[Middleware] Tool call #${callCount} completed`);

    return result;
  },
});

const agent = await createDeepAgent({
  model: "openai:gpt-5.5",
  tools: [getWeather] as any,
  middleware: [logToolCallsMiddleware] as any,
});
```

```ts Anthropic theme={null}
import { tool, createMiddleware } from "langchain";
import { createDeepAgent } from "deepagents";
import * as z from "zod";

const getWeather = tool(
  ({ city }: { city: string }) => {
    return `The weather in ${city} is sunny.`;
  },
  {
    name: "get_weather",
    description: "Get the weather in a city.",
    schema: z.object({
      city: z.string(),
    }),
  },
);

let callCount = 0;

const logToolCallsMiddleware = createMiddleware({
  name: "LogToolCallsMiddleware",
  wrapToolCall: async (request, handler) => {
    // Intercept and log every tool call - demonstrates cross-cutting concern
    callCount += 1;
    const toolName = request.toolCall.name;

    console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
    console.log(
      `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
    );

    // Execute the tool call
    const result = await handler(request);

    // Log the result
    console.log(`[Middleware] Tool call #${callCount} completed`);

    return result;
  },
});

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-5",
  tools: [getWeather] as any,
  middleware: [logToolCallsMiddleware] as any,
});
```

```ts OpenRouter theme={null}
import { tool, createMiddleware } from "langchain";
import { createDeepAgent } from "deepagents";
import * as z from "zod";

const getWeather = tool(
  ({ city }: { city: string }) => {
    return `The weather in ${city} is sunny.`;
  },
  {
    name: "get_weather",
    description: "Get the weather in a city.",
    schema: z.object({
      city: z.string(),
    }),
  },
);

let callCount = 0;

const logToolCallsMiddleware = createMiddleware({
  name: "LogToolCallsMiddleware",
  wrapToolCall: async (request, handler) => {
    // Intercept and log every tool call - demonstrates cross-cutting concern
    callCount += 1;
    const toolName = request.toolCall.name;

    console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
    console.log(
      `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
    );

    // Execute the tool call
    const result = await handler(request);

    // Log the result
    console.log(`[Middleware] Tool call #${callCount} completed`);

    return result;
  },
});

const agent = await createDeepAgent({
  model: "openrouter:z-ai/glm-5.2",
  tools: [getWeather] as any,
  middleware: [logToolCallsMiddleware] as any,
});
```

```ts Fireworks theme={null}
import { tool, createMiddleware } from "langchain";
import { createDeepAgent } from "deepagents";
import * as z from "zod";

const getWeather = tool(
  ({ city }: { city: string }) => {
    return `The weather in ${city} is sunny.`;
  },
  {
    name: "get_weather",
    description: "Get the weather in a city.",
    schema: z.object({
      city: z.string(),
    }),
  },
);

let callCount = 0;

const logToolCallsMiddleware = createMiddleware({
  name: "LogToolCallsMiddleware",
  wrapToolCall: async (request, handler) => {
    // Intercept and log every tool call - demonstrates cross-cutting concern
    callCount += 1;
    const toolName = request.toolCall.name;

    console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
    console.log(
      `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
    );

    // Execute the tool call
    const result = await handler(request);

    // Log the result
    console.log(`[Middleware] Tool call #${callCount} completed`);

    return result;
  },
});

const agent = await createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  tools: [getWeather] as any,
  middleware: [logToolCallsMiddleware] as any,
});
```

```ts Baseten theme={null}
import { tool, createMiddleware } from "langchain";
import { createDeepAgent } from "deepagents";
import * as z from "zod";

const getWeather = tool(
  ({ city }: { city: string }) => {
    return `The weather in ${city} is sunny.`;
  },
  {
    name: "get_weather",
    description: "Get the weather in a city.",
    schema: z.object({
      city: z.string(),
    }),
  },
);

let callCount = 0;

const logToolCallsMiddleware = createMiddleware({
  name: "LogToolCallsMiddleware",
  wrapToolCall: async (request, handler) => {
    // Intercept and log every tool call - demonstrates cross-cutting concern
    callCount += 1;
    const toolName = request.toolCall.name;

    console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
    console.log(
      `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
    );

    // Execute the tool call
    const result = await handler(request);

    // Log the result
    console.log(`[Middleware] Tool call #${callCount} completed`);

    return result;
  },
});

const agent = await createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  tools: [getWeather] as any,
  middleware: [logToolCallsMiddleware] as any,
});
```

```ts Ollama theme={null}
import { tool, createMiddleware } from "langchain";
import { createDeepAgent } from "deepagents";
import * as z from "zod";

const getWeather = tool(
  ({ city }: { city: string }) => {
    return `The weather in ${city} is sunny.`;
  },
  {
    name: "get_weather",
    description: "Get the weather in a city.",
    schema: z.object({
      city: z.string(),
    }),
  },
);

let callCount = 0;

const logToolCallsMiddleware = createMiddleware({
  name: "LogToolCallsMiddleware",
  wrapToolCall: async (request, handler) => {
    // Intercept and log every tool call - demonstrates cross-cutting concern
    callCount += 1;
    const toolName = request.toolCall.name;

    console.log(`[Middleware] Tool call #${callCount}: ${toolName}`);
    console.log(
      `[Middleware] Arguments: ${JSON.stringify(request.toolCall.args)}`,
    );

    // Execute the tool call
    const result = await handler(request);

    // Log the result
    console.log(`[Middleware] Tool call #${callCount} completed`);

    return result;
  },
});

const agent = await createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  tools: [getWeather] as any,
  middleware: [logToolCallsMiddleware] as any,
});
```

:::

> [!WARNING]
>
> **初始化后不要修改属性**
>
> 如果你需要在钩子调用之间跟踪值（例如计数器或累积数据），请使用图状态。
> 图状态按设计是线程范围的，因此并发下的更新是安全的。
>
> **请这样做：**
>
> :::python
>
> ```python theme={null}
> from langchain.agents.middleware import AgentMiddleware
>
>
> class CustomMiddleware(AgentMiddleware):
>     def __init__(self):
>         pass
>
>     def before_agent(self, state, runtime):
>         return {"x": state.get("x", 0) + 1}  # Update graph state instead
> ```
>
> :::
>
> :::js
>
> ```ts theme={null}
> const customMiddleware = createMiddleware({
>   name: "CustomMiddleware",
>   beforeAgent: async (state) => {
>     return { x: (state.x ?? 0) + 1 }; // Update graph state instead
>   },
> });
> ```
>
> :::
>
> **不要这样做：**
>
> :::python
>
> ```python theme={null}
> class CustomMiddlewareBad(AgentMiddleware):
>     def __init__(self):
>         self.x = 1
>
>     def before_agent(self, state, runtime):
>         self.x += 1  # Mutation causes race conditions
> ```
>
> :::
>
> :::js
>
> ```ts theme={null}
> let x = 1;
>
> const customMiddlewareBad = createMiddleware({
>   name: "CustomMiddleware",
>   beforeAgent: async () => {
>     x += 1; // Mutation causes race conditions
>   },
> });
> ```
>
> :::
>
> :::python
> 原地修改，例如在 `before_agent` 中修改 `self.x` 或在钩子中更改其他共享值，可能会导致细微的bug和竞态条件，因为许多操作并发运行（子智能体、并行工具和不同线程上的并行调用）。
>
> 有关使用自定义属性扩展状态的详细信息，请参阅 [自定义中间件 - 自定义状态模式](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/middleware/custom.md#自定义状态模式)。
> :::
> :::js
> 原地修改，例如在 `beforeAgent` 中修改 `state.x`、在 `beforeAgent` 中变异共享变量，或在钩子中更改其他共享值，可能会导致细微的bug和竞态条件，因为许多操作并发运行（子智能体、并行工具和不同线程上的并行调用）。
> :::
>
> 如果你必须在自定义中间件中使用原地修改，请考虑当子智能体、并行工具或并发智能体调用同时运行时会发生什么。

### 覆盖默认中间件实例

:::python

> [!NOTE]
>
> 通过匹配 `.name` 来覆盖默认中间件需要 `deepagents>=0.7`。

将一个中间件实例传递给 `.name`，使其匹配 [深度智能体堆栈](#deep-agents-堆栈) 中的条目，例如 @\[`SummarizationMiddleware`]，以替换该内置实例，而不是追加一个副本。任何你传递的中间件实例，其 `.name` **不**匹配内置条目，都不会被替换，它位于最后一个核心中间件条目之后，以及配置文件、提示词缓存和记忆之前。参见 [完整堆栈](#全栈) 了解完整顺序。

```python theme={null}
from deepagents import create_deep_agent
from deepagents.backends import StateBackend
from deepagents.middleware import SummarizationMiddleware

backend = StateBackend()
model = "openai:gpt-5.5"

custom_summarization = SummarizationMiddleware(
    model=model,
    backend=backend,
    summary_prompt="Your custom summary prompt here.",
)

agent = create_deep_agent(
    model=model,
    middleware=[custom_summarization],  # replaces the default SummarizationMiddleware
)
```

> [!NOTE]
>
> 覆盖 **替换** 默认中间件实例，而不是与其合并。这意味着你的替换必须配置所有它需要的设置。这对于 `FilesystemMiddleware` 特别重要：如果你覆盖它，你必须将 `backend`（如果适用，则为 `permissions`）直接传递给你的自定义实例，因为它不会继承传递给 `create_deep_agent()` 的 `backend=` 和 `permissions=`。要限制可用的文件系统工具，请将 `tools` 允许列表传递给你的自定义 @\[`FilesystemMiddleware`] 实例；参见 [虚拟文件系统访问](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/overview.md#虚拟文件系统访问) 的“限制文件系统工具”示例。

通用子智能体（深度智能体会自动添加），会从主智能体继承默认中间件的覆盖，而不会传递主智能体特有的中间件。

通过 `subagents=` 定义的声明式子智能体不会继承主智能体的中间件定制。将覆盖直接传递到该子智能体自己的 [`middleware`](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/subagents#子智能体（基于字典）) 字段中以应用；该字段与 `middleware=` [相同的方式匹配于同步子智能体栈](#同步子智能体栈)。

#### 示例

> [accordion] Adjust when summarization triggers
>
> 使用自定义 `trigger` 和 `keep` 阈值覆盖 @\[`SummarizationMiddleware`]，以便比默认值更早或更晚地压缩对话历史，并控制每次压缩后有多少条最近消息得以保留。
>
> ```python theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
> from deepagents.middleware import SummarizationMiddleware
>
> backend = StateBackend()
> model = "anthropic:claude-sonnet-4-6"
>
> agent = create_deep_agent(
>     model=model,
>     middleware=[
>         SummarizationMiddleware(
>             model=model,
>             backend=backend,
>             trigger=("tokens", 100000),  # summarize once the conversation exceeds 100k tokens
>             keep=("messages", 20),  # keep the most recent 20 messages verbatim
>         ),
>     ],
> )
> ```
>
> `trigger` 也接受 `("fraction", ...)` 作为模型上下文窗口的百分比，并且阈值列表使用 OR 语义将它们组合在一起。参见 @\[`SummarizationMiddleware`] 参考文档以获取完整选项集。

> [accordion] 使用更便宜的模型生成摘要
>
> > [!NOTE]
> >
> > `summarizer` 参数需要 `deepagents>=0.7.26`。
>
> 使用 `summarizer=` 覆盖 @\[`SummarizationMiddleware`]，以便用不同的模型或自定义可调用对象生成摘要。主 `model` 仍然提供配置文件和 Token 计数。
>
> 传入模型名称字符串或 `BaseChatModel` 实例，即可使用该模型和 `summary_prompt` 生成摘要。传入 `Runnable` 或可调用对象直接生成摘要文本；此时不使用 `summary_prompt`。
>
> ```python theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
> from deepagents.middleware import SummarizationMiddleware
>
> backend = StateBackend()
> model = "anthropic:claude-sonnet-4-6"
>
> agent = create_deep_agent(
>     model=model,
>     middleware=[
>         SummarizationMiddleware(
>             model=model,  # profile and token counting
>             backend=backend,
>             summarizer="anthropic:claude-haiku-5-5",  # cheaper model writes the summary
>         ),
>     ],
> )
> ```

> [accordion] Update the prompt cache TTL
>
> 覆盖 @\[`AnthropicPromptCachingMiddleware`] 以延长缓存寿命，超过默认的 `5m` TTL，适用于在回合之间有较长间隔的智能体。参见 [提示词缓存](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/overview.md#提示词缓存) 了解默认情况下缓存的用法。
>
> ```python theme={null}
> from deepagents import create_deep_agent
> from langchain_anthropic.middleware import AnthropicPromptCachingMiddleware
>
> agent = create_deep_agent(
>     model="anthropic:claude-sonnet-4-6",
>     middleware=[
>         AnthropicPromptCachingMiddleware(ttl="1h"),  # replaces the default 5m TTL
>     ],
> )
> ```

> [accordion] Restrict the enabled filesystem tools
>
> > [!NOTE]
> >
> > `FilesystemMiddleware` 上的 `tools` 允许列表需要 `deepagents>=0.7`。
>
> 使用 `tools` 允许列表覆盖 @\[`FilesystemMiddleware`]，仅向模型暴露文件系统工具的子集，而不是完整的默认集。
>
> ```python theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
> from deepagents.middleware import FilesystemMiddleware
>
> backend = StateBackend()
>
> # Read-only agent: write_file, edit_file, delete, and execute are never shown
> agent = create_deep_agent(
>     model="anthropic:claude-sonnet-4-6",
>     backend=backend,
>     middleware=[
>         FilesystemMiddleware(backend=backend, tools=["read_file", "ls", "glob", "grep"]),
>     ],
> )
> ```
>
> 更多详情请参见 [限制文件系统工具](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/overview.md#虚拟文件系统访问)。

> [accordion] Customize how the skill catalog appears in the system prompt
>
> 使用自定义 `system_prompt=` 模板覆盖 @\[`SkillsMiddleware`]，以控制自动生成的技能目录的呈现方式——例如，添加周边上下文、重新排序部分，或将路由提示（优先级、类别偏差）放置在与目录相同的块中。模板必须包含 `{skills_locations}`、`{skills_list}` 和 `{skills_load_warnings}` 插槽，中间件在每次回合时都会替换这些插槽——因此，随着技能的添加、重命名或删除，目录会自动保持同步。
>
> 以下示例将路由提示与目录并置：
>
> ```python theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends.filesystem import FilesystemBackend
> from deepagents.middleware.skills import SkillsMiddleware
>
> backend = FilesystemBackend(root_dir="/path/to/skills")
>
> custom_skills_prompt = """## Skills
>
> Routing hints:
> - For research topics → prefer arxiv-search first
> - For general questions → use web-research
> - For LangGraph documentation → langgraph-docs
>
> {skills_locations}
>
> {skills_list}
>
> {skills_load_warnings}
> """
>
> agent = create_deep_agent(
>     model="anthropic:claude-sonnet-4-6",
>     middleware=[
>         SkillsMiddleware(
>             backend=backend,
>             sources=["/path/to/skills"],
>             system_prompt=custom_skills_prompt,
>         ),
>     ],
> )
> ```
>
> 不要在此情况下将 `skills=` 传递给 `create_deep_agent`：覆盖实例
> 已经拥有 `backend` 和 `sources`。任何缺失的槽位（`{skills_locations}`，
> `{skills_list}`，`{skills_load_warnings}`）在构建时引发 `ValueError`。

> [accordion] Suppress the auto-generated skill catalog
>
> 使用 `system_prompt=None` 覆盖 @\[`SkillsMiddleware`] 来加载技能，而完全不
> 在系统提示词中追加技能部分。技能保留在 `state["skills_metadata"]` 中，
> 技能文件可以通过文件系统工具保持可访问性，
> 因此，如果调用者更喜欢在 `create_deep_agent(system_prompt=...)` 中编写自己的描述块（例如，
> 一个紧凑的手写路由摘要），他们可以添加他们需要的精确指导，
> 而无需内置的指导。
>
> ```python theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends.filesystem import FilesystemBackend
> from deepagents.middleware.skills import SkillsMiddleware
>
> backend = FilesystemBackend(root_dir="/path/to/skills")
>
> agent = create_deep_agent(
>     model="anthropic:claude-sonnet-4-6",
>     system_prompt="""You are a research assistant.
>
> Skills (read the SKILL.md file when relevant):
> - /path/to/skills/arxiv-search/SKILL.md — papers
> - /path/to/skills/web-research/SKILL.md — general web lookups
> - /path/to/skills/langgraph-docs/SKILL.md — LangGraph documentation
> """,
>     middleware=[
>         SkillsMiddleware(
>             backend=backend,
>             sources=["/path/to/skills"],
>             system_prompt=None,
>         ),
>     ],
> )
> ```
>
> 技能名称、路径以及在 `create_deep_agent` 的 `system_prompt` 中
> 任何手写的提示都是调用者负责在技能变化时保持同步。

:::

:::js
传递一个中间件实例，其 `.name` 与 [Deep Agents 堆栈](#deep-agents-堆栈) 中的条目匹配，
例如 @\[`SummarizationMiddleware`]，以替换该内置实例，而不是追加重复项。任何你传递的中间件，
其 `.name` **不** 与内置条目匹配，都不会被替换，
它位于最后一个核心中间件条目之后，以及配置文件、提示词缓存和记忆之前。参见
[完整堆栈](#全栈) 了解完整顺序。

```js theme={null}
import {
  createDeepAgent,
  createSummarizationMiddleware,
  StateBackend,
} from "deepagents";

const backend = new StateBackend();
const model = "openai:gpt-5.5";

const customSummarization = createSummarizationMiddleware({
  model,
  backend,
  summaryPrompt: "Your custom summary prompt here.",
});

const agent = createDeepAgent({
  model,
  middleware: [customSummarization], // replaces the default SummarizationMiddleware
});
```

> [!NOTE]
>
> 覆盖 **替换** 默认中间件实例，它不会与该实例合并。这意味着你的替换必须
> 完全配置它需要的任何设置。这对于 `FilesystemMiddleware` 特别重要：如果你覆盖它，
> 你必须将 `backend`（如果适用，则包括 `permissions`）直接传递给 `createFilesystemMiddleware`，
> 因为它不会继承传递给 `createDeepAgent` 的 `backend` 和 `permissions`。要限制可用的文件系统工具，
> 将一个 `tools` 允许列表传递给你的自定义 @\[`FilesystemMiddleware`] 实例；参见
> [虚拟文件系统访问](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/overview.md#虚拟文件系统访问)。

通用子智能体，Deep Agents 自动添加的，会从主智能体继承默认中间件的覆盖，
而不会传递主智能体特有的中间件。

通过 `subagents` 定义的声明式子智能体不会继承主智能体的中间件定制。将覆盖直接
传递到该子智能体自己的 [`middleware`](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/subagents#子智能体（基于字典）) 字段中以应用它；该字段与 [同步子智能体堆栈](#同步子智能体栈) 匹配，
方式与 `middleware` 与主智能体匹配相同。

#### 示例

> [accordion] Keep binary file content out of checkpointed history
>
> 使用 `offloadBinaryContent: true` 覆盖 @\[`FilesystemMiddleware`] 以在 `/blobs` 后端存储二进制 `read_file` 负载和内联 `HumanMessage` 媒体，而不是在检查点消息历史中存储。状态保持一个小型引用；模型请求从每个运行的缓存或后端重新水化。这使代理在多个回合中读取许多二进制文件时保持检查点大小较小。
>
> > [!NOTE]
> >
> > 二进制内容卸载需要 `deepagents>=1.14.2`。使用一个后端，该后端将对象存储在图状态之外，例如沙盒或 `FilesystemBackend`。当 `/blobs` 路由到 `StateBackend` 时，卸载没有效果。将您传递给 `createFilesystemMiddleware` 的相同 `backend` 传递给 `createDeepAgent`。
>
> ```js theme={null}
> import {
>   createDeepAgent,
>   createFilesystemMiddleware,
>   FilesystemBackend,
> } from "deepagents";
>
> const backend = new FilesystemBackend({
>   rootDir: "/path/to/project",
>   virtualMode: true,
> });
>
> const agent = createDeepAgent({
>   model: "anthropic:claude-sonnet-4-6",
>   backend,
>   middleware: [
>     createFilesystemMiddleware({ backend, offloadBinaryContent: true }),
>   ],
> });
> ```
>
> 更多信息，请参阅 [Offload binary content](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/backends.md#离线二进制内容)。

:::

### 解释器

使用 [interpreters](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/interpreters.md) 添加一个 `eval` 工具，该工具在作用域 QuickJS 运行时中运行 JavaScript。当代理需要以编程方式组合工具、批量处理工作、在代码中处理错误或在不完整 shell 环境中转换结构化数据时，解释器很有用。

:::python

```python Google theme={null}
from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    middleware=[CodeInterpreterMiddleware()],
)
```

```python OpenAI theme={null}
from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="openai:gpt-5.5",
    middleware=[CodeInterpreterMiddleware()],
)
```

```python Anthropic theme={null}
from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="anthropic:claude-sonnet-5",
    middleware=[CodeInterpreterMiddleware()],
)
```

```python OpenRouter theme={null}
from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    middleware=[CodeInterpreterMiddleware()],
)
```

```python Fireworks theme={null}
from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    middleware=[CodeInterpreterMiddleware()],
)
```

```python Baseten theme={null}
from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    middleware=[CodeInterpreterMiddleware()],
)
```

```python Ollama theme={null}
from deepagents import create_deep_agent
from langchain_quickjs import CodeInterpreterMiddleware

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    middleware=[CodeInterpreterMiddleware()],
)
```

:::

:::js

```ts Google theme={null}
import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "google:gemini-3.6-flash",
  middleware: [createCodeInterpreterMiddleware()],
});
```

```ts OpenAI theme={null}
import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openai:gpt-5.5",
  middleware: [createCodeInterpreterMiddleware()],
});
```

```ts Anthropic theme={null}
import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "anthropic:claude-sonnet-5",
  middleware: [createCodeInterpreterMiddleware()],
});
```

```ts OpenRouter theme={null}
import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "openrouter:z-ai/glm-5.2",
  middleware: [createCodeInterpreterMiddleware()],
});
```

```ts Fireworks theme={null}
import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  middleware: [createCodeInterpreterMiddleware()],
});
```

```ts Baseten theme={null}
import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  middleware: [createCodeInterpreterMiddleware()],
});
```

```ts Ollama theme={null}
import { createDeepAgent } from "deepagents";
import { createCodeInterpreterMiddleware } from "@langchain/quickjs";

const agent = createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  middleware: [createCodeInterpreterMiddleware()],
});
```

:::

有关设置、程序化工具调用、子代理编排和限制的信息，请参阅 [Interpreters](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/interpreters.md)。

## 子代理

为了隔离详细工作并避免上下文膨胀，请使用子代理：

:::python

```python theme={null}
import os
from typing import Literal

from deepagents import create_deep_agent
from tavily import TavilyClient

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


def internet_search(
    query: str,
    max_results: int = 5,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = False,
):
    """Run a web search"""
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )


research_subagent = {
    "name": "research-agent",
    "description": "Used to research more in depth questions",
    "system_prompt": "You are a great researcher",
    "tools": [internet_search],
    "model": "openai:gpt-5.5",  # Optional override, defaults to main agent model
}
subagents = [research_subagent]

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    subagents=subagents,
)
```

:::

:::js

```ts Google theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      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: "Used to research more in depth questions",
  systemPrompt: "You are a great researcher",
  tools: [internetSearch],
  model: "google:gemini-3.6-flash", // Optional override, defaults to main agent model
};
const subagents = [researchSubagent];

const agent = createDeepAgent({
  model: "google:gemini-3.6-flash",
  subagents,
});
```

```ts OpenAI theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      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: "Used to research more in depth questions",
  systemPrompt: "You are a great researcher",
  tools: [internetSearch],
  model: "openai:gpt-5.5", // Optional override, defaults to main agent model
};
const subagents = [researchSubagent];

const agent = createDeepAgent({
  model: "google:gemini-3.6-flash",
  subagents,
});
```

```ts Anthropic theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      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: "Used to research more in depth questions",
  systemPrompt: "You are a great researcher",
  tools: [internetSearch],
  model: "anthropic:claude-sonnet-5", // Optional override, defaults to main agent model
};
const subagents = [researchSubagent];

const agent = createDeepAgent({
  model: "google:gemini-3.6-flash",
  subagents,
});
```

```ts OpenRouter theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      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: "Used to research more in depth questions",
  systemPrompt: "You are a great researcher",
  tools: [internetSearch],
  model: "openrouter:z-ai/glm-5.2", // Optional override, defaults to main agent model
};
const subagents = [researchSubagent];

const agent = createDeepAgent({
  model: "google:gemini-3.6-flash",
  subagents,
});
```

```ts Fireworks theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      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: "Used to research more in depth questions",
  systemPrompt: "You are a great researcher",
  tools: [internetSearch],
  model: "fireworks:accounts/fireworks/models/glm-5p2", // Optional override, defaults to main agent model
};
const subagents = [researchSubagent];

const agent = createDeepAgent({
  model: "google:gemini-3.6-flash",
  subagents,
});
```

```ts Baseten theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      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: "Used to research more in depth questions",
  systemPrompt: "You are a great researcher",
  tools: [internetSearch],
  model: "baseten:zai-org/GLM-5.2", // Optional override, defaults to main agent model
};
const subagents = [researchSubagent];

const agent = createDeepAgent({
  model: "google:gemini-3.6-flash",
  subagents,
});
```

```ts Ollama theme={null}
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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      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: "Used to research more in depth questions",
  systemPrompt: "You are a great researcher",
  tools: [internetSearch],
  model: "ollama:north-mini-code-1.0", // Optional override, defaults to main agent model
};
const subagents = [researchSubagent];

const agent = createDeepAgent({
  model: "google:gemini-3.6-flash",
  subagents,
});
```

:::

更多信息，请参阅 [Subagents](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/subagents.md)。

## 后端

深度代理的工具可以使用虚拟文件系统来存储、访问和编辑文件。默认情况下，深度代理使用一个 @\[`StateBackend`]。

如果您正在使用 [skills](#技能) 或 [memory](#记忆)，您必须在创建代理之前将预期的技能或内存文件添加到后端。

> [tab] StateBackend
>
> 一个线程作用域文件系统后端存储在 `langgraph` 状态中。
>
> 文件在线程内（通过您的检查点器）跨回合持久化，并且不会跨线程共享。
>
> :::python
>
> ```python Google theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
>
> # By default we provide a StateBackend
> agent = create_deep_agent(model="google_genai:gemini-3.6-flash")
>
> # Under the hood, it looks like
> agent2 = create_deep_agent(
>     model="google_genai:gemini-3.6-flash",
>     backend=StateBackend(),
> )
> ```
>
> ```python OpenAI theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
>
> # By default we provide a StateBackend
> agent = create_deep_agent(model="openai:gpt-5.5")
>
> # Under the hood, it looks like
> agent2 = create_deep_agent(
>     model="openai:gpt-5.5",
>     backend=StateBackend(),
> )
> ```
>
> ```python Anthropic theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
>
> # By default we provide a StateBackend
> agent = create_deep_agent(model="anthropic:claude-sonnet-5")
>
> # Under the hood, it looks like
> agent2 = create_deep_agent(
>     model="anthropic:claude-sonnet-5",
>     backend=StateBackend(),
> )
> ```
>
> ```python OpenRouter theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
>
> # By default we provide a StateBackend
> agent = create_deep_agent(model="openrouter:z-ai/glm-5.2")
>
> # Under the hood, it looks like
> agent2 = create_deep_agent(
>     model="openrouter:z-ai/glm-5.2",
>     backend=StateBackend(),
> )
> ```
>
> ```python Fireworks theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
>
> # By default we provide a StateBackend
> agent = create_deep_agent(model="fireworks:accounts/fireworks/models/glm-5p2")
>
> # Under the hood, it looks like
> agent2 = create_deep_agent(
>     model="fireworks:accounts/fireworks/models/glm-5p2",
>     backend=StateBackend(),
> )
> ```
>
> ```python Baseten theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
>
> # By default we provide a StateBackend
> agent = create_deep_agent(model="baseten:zai-org/GLM-5.2")
>
> # Under the hood, it looks like
> agent2 = create_deep_agent(
>     model="baseten:zai-org/GLM-5.2",
>     backend=StateBackend(),
> )
> ```
>
> ```python Ollama theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
>
> # By default we provide a StateBackend
> agent = create_deep_agent(model="ollama:north-mini-code-1.0")
>
> # Under the hood, it looks like
> agent2 = create_deep_agent(
>     model="ollama:north-mini-code-1.0",
>     backend=StateBackend(),
> )
> ```
>
> :::
>
> :::js
>
> ```ts theme={null}
> import { createDeepAgent, StateBackend } from "deepagents";
>
> // By default we provide a StateBackend
> const agent = createDeepAgent();
>
> // Under the hood, it looks like
> const agent2 = createDeepAgent({
>   backend: new StateBackend(),
> });
> ```
>
> :::

> [tab] FilesystemBackend
>
> 本地计算机的文件系统。
>
> > [!WARNING]
> >
> > 此后端授予代理直接文件系统读写访问权限。
> > 小心使用，仅在适当的环境中使用。
> > 更多信息，请参阅 [`FilesystemBackend`](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/backends#filesystembackend（本地磁盘）)。
>
> :::python
>
> ```python Google theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
>
> agent = create_deep_agent(
>     model="google_genai:gemini-3.6-flash",
>     backend=FilesystemBackend(root_dir=".", virtual_mode=True),
> )
> ```
>
> ```python OpenAI theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
>
> agent = create_deep_agent(
>     model="openai:gpt-5.5",
>     backend=FilesystemBackend(root_dir=".", virtual_mode=True),
> )
> ```
>
> ```python Anthropic theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
>
> agent = create_deep_agent(
>     model="anthropic:claude-sonnet-5",
>     backend=FilesystemBackend(root_dir=".", virtual_mode=True),
> )
> ```
>
> ```python OpenRouter theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
>
> agent = create_deep_agent(
>     model="openrouter:z-ai/glm-5.2",
>     backend=FilesystemBackend(root_dir=".", virtual_mode=True),
> )
> ```
>
> ```python Fireworks theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
>
> agent = create_deep_agent(
>     model="fireworks:accounts/fireworks/models/glm-5p2",
>     backend=FilesystemBackend(root_dir=".", virtual_mode=True),
> )
> ```
>
> ```python Baseten theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
>
> agent = create_deep_agent(
>     model="baseten:zai-org/GLM-5.2",
>     backend=FilesystemBackend(root_dir=".", virtual_mode=True),
> )
> ```
>
> ```python Ollama theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
>
> agent = create_deep_agent(
>     model="ollama:north-mini-code-1.0",
>     backend=FilesystemBackend(root_dir=".", virtual_mode=True),
> )
> ```
>
> :::
>
> :::js
>
> ```ts Google theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
>
> const agent = createDeepAgent({
>   model: "google:gemini-3.6-flash",
>   backend: new FilesystemBackend({ rootDir: ".", virtualMode: true }),
> });
> ```
>
> ```ts OpenAI theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
>
> const agent = createDeepAgent({
>   model: "openai:gpt-5.5",
>   backend: new FilesystemBackend({ rootDir: ".", virtualMode: true }),
> });
> ```
>
> ```ts Anthropic theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
>
> const agent = createDeepAgent({
>   model: "anthropic:claude-sonnet-5",
>   backend: new FilesystemBackend({ rootDir: ".", virtualMode: true }),
> });
> ```
>
> ```ts OpenRouter theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
>
> const agent = createDeepAgent({
>   model: "openrouter:z-ai/glm-5.2",
>   backend: new FilesystemBackend({ rootDir: ".", virtualMode: true }),
> });
> ```
>
> ```ts Fireworks theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
>
> const agent = createDeepAgent({
>   model: "fireworks:accounts/fireworks/models/glm-5p2",
>   backend: new FilesystemBackend({ rootDir: ".", virtualMode: true }),
> });
> ```
>
> ```ts Baseten theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
>
> const agent = createDeepAgent({
>   model: "baseten:zai-org/GLM-5.2",
>   backend: new FilesystemBackend({ rootDir: ".", virtualMode: true }),
> });
> ```
>
> ```ts Ollama theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
>
> const agent = createDeepAgent({
>   model: "ollama:north-mini-code-1.0",
>   backend: new FilesystemBackend({ rootDir: ".", virtualMode: true }),
> });
> ```
>
> :::
>
> > [!TIP]
> >
> > 将 `FilesystemBackend` 封装在 `CompositeBackend` 中，以防止内部智能体数据（卸载的工具结果、对话历史）与您的项目文件一起写入磁盘。请参阅 [推荐模式](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/backends.md#filesystembackend（本地磁盘）)。

> [tab] LocalShellBackend
>
> 一种主机上直接执行 shell 命令的文件系统。提供文件系统工具以及用于运行命令的 `execute` 工具。
>
> > [!WARNING]
> >
> > 此后端授予智能体直接文件系统读写访问权限 **并且** 在主机上不受限制地执行 shell 命令。
> > 请谨慎使用，仅在适当的环境中使用。
> > 更多信息，请参阅 [`LocalShellBackend`](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/backends#localshellbackend-本地-shell)。
>
> :::python
>
> ```python Google theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import LocalShellBackend
>
> agent = create_deep_agent(
>     model="google_genai:gemini-3.6-flash",
>     backend=LocalShellBackend(root_dir=".", virtual_mode=True, env={"PATH": "/usr/bin:/bin"}),
> )
> ```
>
> ```python OpenAI theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import LocalShellBackend
>
> agent = create_deep_agent(
>     model="openai:gpt-5.5",
>     backend=LocalShellBackend(root_dir=".", virtual_mode=True, env={"PATH": "/usr/bin:/bin"}),
> )
> ```
>
> ```python Anthropic theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import LocalShellBackend
>
> agent = create_deep_agent(
>     model="anthropic:claude-sonnet-5",
>     backend=LocalShellBackend(root_dir=".", virtual_mode=True, env={"PATH": "/usr/bin:/bin"}),
> )
> ```
>
> ```python OpenRouter theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import LocalShellBackend
>
> agent = create_deep_agent(
>     model="openrouter:z-ai/glm-5.2",
>     backend=LocalShellBackend(root_dir=".", virtual_mode=True, env={"PATH": "/usr/bin:/bin"}),
> )
> ```
>
> ```python Fireworks theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import LocalShellBackend
>
> agent = create_deep_agent(
>     model="fireworks:accounts/fireworks/models/glm-5p2",
>     backend=LocalShellBackend(root_dir=".", virtual_mode=True, env={"PATH": "/usr/bin:/bin"}),
> )
> ```
>
> ```python Baseten theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import LocalShellBackend
>
> agent = create_deep_agent(
>     model="baseten:zai-org/GLM-5.2",
>     backend=LocalShellBackend(root_dir=".", virtual_mode=True, env={"PATH": "/usr/bin:/bin"}),
> )
> ```
>
> ```python Ollama theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import LocalShellBackend
>
> agent = create_deep_agent(
>     model="ollama:north-mini-code-1.0",
>     backend=LocalShellBackend(root_dir=".", virtual_mode=True, env={"PATH": "/usr/bin:/bin"}),
> )
> ```
>
> :::
>
> :::js
>
> ```ts Google theme={null}
> import { createDeepAgent, LocalShellBackend } from "deepagents";
>
> const backend = new LocalShellBackend({ workingDirectory: "." });
>
> const agent = createDeepAgent({
>   model: "google:gemini-3.6-flash",
>   backend,
> });
> ```
>
> ```ts OpenAI theme={null}
> import { createDeepAgent, LocalShellBackend } from "deepagents";
>
> const backend = new LocalShellBackend({ workingDirectory: "." });
>
> const agent = createDeepAgent({
>   model: "openai:gpt-5.5",
>   backend,
> });
> ```
>
> ```ts Anthropic theme={null}
> import { createDeepAgent, LocalShellBackend } from "deepagents";
>
> const backend = new LocalShellBackend({ workingDirectory: "." });
>
> const agent = createDeepAgent({
>   model: "anthropic:claude-sonnet-5",
>   backend,
> });
> ```
>
> ```ts OpenRouter theme={null}
> import { createDeepAgent, LocalShellBackend } from "deepagents";
>
> const backend = new LocalShellBackend({ workingDirectory: "." });
>
> const agent = createDeepAgent({
>   model: "openrouter:z-ai/glm-5.2",
>   backend,
> });
> ```
>
> ```ts Fireworks theme={null}
> import { createDeepAgent, LocalShellBackend } from "deepagents";
>
> const backend = new LocalShellBackend({ workingDirectory: "." });
>
> const agent = createDeepAgent({
>   model: "fireworks:accounts/fireworks/models/glm-5p2",
>   backend,
> });
> ```
>
> ```ts Baseten theme={null}
> import { createDeepAgent, LocalShellBackend } from "deepagents";
>
> const backend = new LocalShellBackend({ workingDirectory: "." });
>
> const agent = createDeepAgent({
>   model: "baseten:zai-org/GLM-5.2",
>   backend,
> });
> ```
>
> ```ts Ollama theme={null}
> import { createDeepAgent, LocalShellBackend } from "deepagents";
>
> const backend = new LocalShellBackend({ workingDirectory: "." });
>
> const agent = createDeepAgent({
>   model: "ollama:north-mini-code-1.0",
>   backend,
> });
> ```
>
> :::

> [tab] StoreBackend
>
> 一种提供长期存储的文件系统，该存储 *跨线程持久化*。
>
> :::python
>
> ```python Google theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="google_genai:gemini-3.6-flash",
>     backend=StoreBackend(
>         namespace=lambda rt: (rt.server_info.user.identity,),
>     ),
>     store=InMemoryStore(),  # Good for local dev; omit for LangSmith Deployment
> )
> ```
>
> ```python OpenAI theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="openai:gpt-5.5",
>     backend=StoreBackend(
>         namespace=lambda rt: (rt.server_info.user.identity,),
>     ),
>     store=InMemoryStore(),  # Good for local dev; omit for LangSmith Deployment
> )
> ```
>
> ```python Anthropic theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="anthropic:claude-sonnet-5",
>     backend=StoreBackend(
>         namespace=lambda rt: (rt.server_info.user.identity,),
>     ),
>     store=InMemoryStore(),  # Good for local dev; omit for LangSmith Deployment
> )
> ```
>
> ```python OpenRouter theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="openrouter:z-ai/glm-5.2",
>     backend=StoreBackend(
>         namespace=lambda rt: (rt.server_info.user.identity,),
>     ),
>     store=InMemoryStore(),  # Good for local dev; omit for LangSmith Deployment
> )
> ```
>
> ```python Fireworks theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="fireworks:accounts/fireworks/models/glm-5p2",
>     backend=StoreBackend(
>         namespace=lambda rt: (rt.server_info.user.identity,),
>     ),
>     store=InMemoryStore(),  # Good for local dev; omit for LangSmith Deployment
> )
> ```
>
> ```python Baseten theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="baseten:zai-org/GLM-5.2",
>     backend=StoreBackend(
>         namespace=lambda rt: (rt.server_info.user.identity,),
>     ),
>     store=InMemoryStore(),  # Good for local dev; omit for LangSmith Deployment
> )
> ```
>
> ```python Ollama theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="ollama:north-mini-code-1.0",
>     backend=StoreBackend(
>         namespace=lambda rt: (rt.server_info.user.identity,),
>     ),
>     store=InMemoryStore(),  # Good for local dev; omit for LangSmith Deployment
> )
> ```
>
> :::
>
> :::js
>
> ```ts Google theme={null}
> import { createDeepAgent, StoreBackend } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore(); // Good for local dev; omit for LangSmith Deployment
>
> const agent = createDeepAgent({
>   model: "google:gemini-3.6-flash",
>   backend: new StoreBackend({
>     namespace: (rt) => [rt.serverInfo.user.identity],
>   }),
>   store,
> });
> ```
>
> ```ts OpenAI theme={null}
> import { createDeepAgent, StoreBackend } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore(); // Good for local dev; omit for LangSmith Deployment
>
> const agent = createDeepAgent({
>   model: "openai:gpt-5.5",
>   backend: new StoreBackend({
>     namespace: (rt) => [rt.serverInfo.user.identity],
>   }),
>   store,
> });
> ```
>
> ```ts Anthropic theme={null}
> import { createDeepAgent, StoreBackend } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore(); // Good for local dev; omit for LangSmith Deployment
>
> const agent = createDeepAgent({
>   model: "anthropic:claude-sonnet-5",
>   backend: new StoreBackend({
>     namespace: (rt) => [rt.serverInfo.user.identity],
>   }),
>   store,
> });
> ```
>
> ```ts OpenRouter theme={null}
> import { createDeepAgent, StoreBackend } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore(); // Good for local dev; omit for LangSmith Deployment
>
> const agent = createDeepAgent({
>   model: "openrouter:z-ai/glm-5.2",
>   backend: new StoreBackend({
>     namespace: (rt) => [rt.serverInfo.user.identity],
>   }),
>   store,
> });
> ```
>
> ```ts Fireworks theme={null}
> import { createDeepAgent, StoreBackend } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore(); // Good for local dev; omit for LangSmith Deployment
>
> const agent = createDeepAgent({
>   model: "fireworks:accounts/fireworks/models/glm-5p2",
>   backend: new StoreBackend({
>     namespace: (rt) => [rt.serverInfo.user.identity],
>   }),
>   store,
> });
> ```
>
> ```ts Baseten theme={null}
> import { createDeepAgent, StoreBackend } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore(); // Good for local dev; omit for LangSmith Deployment
>
> const agent = createDeepAgent({
>   model: "baseten:zai-org/GLM-5.2",
>   backend: new StoreBackend({
>     namespace: (rt) => [rt.serverInfo.user.identity],
>   }),
>   store,
> });
> ```
>
> ```ts Ollama theme={null}
> import { createDeepAgent, StoreBackend } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore(); // Good for local dev; omit for LangSmith Deployment
>
> const agent = createDeepAgent({
>   model: "ollama:north-mini-code-1.0",
>   backend: new StoreBackend({
>     namespace: (rt) => [rt.serverInfo.user.identity],
>   }),
>   store,
> });
> ```
>
> :::
>
> > [!NOTE]
> >
> > 部署到 [LangSmith 部署](https://docs.langchain.com/langsmith/deployment) 时，请省略 `store` 参数。平台会自动为您的智能体配置存储。
>
> > [!TIP]
> >
> > `namespace` 参数控制数据隔离。对于多用户部署，始终设置一个 [命名空间工厂](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/backends.md#命名空间工厂) 以按用户或租户隔离数据。

> [tab] ContextHubBackend
>
> LangSmith Hub 仓库中的持久文件系统存储。
>
> :::python
>
> ```python Google theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import ContextHubBackend
>
> agent = create_deep_agent(
>     model="google_genai:gemini-3.6-flash",
>     backend=ContextHubBackend("my-agent"),
> )
> ```
>
> ```python OpenAI theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import ContextHubBackend
>
> agent = create_deep_agent(
>     model="openai:gpt-5.5",
>     backend=ContextHubBackend("my-agent"),
> )
> ```
>
> ```python Anthropic theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import ContextHubBackend
>
> agent = create_deep_agent(
>     model="anthropic:claude-sonnet-5",
>     backend=ContextHubBackend("my-agent"),
> )
> ```
>
> ```python OpenRouter theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import ContextHubBackend
>
> agent = create_deep_agent(
>     model="openrouter:z-ai/glm-5.2",
>     backend=ContextHubBackend("my-agent"),
> )
> ```
>
> ```python Fireworks theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import ContextHubBackend
>
> agent = create_deep_agent(
>     model="fireworks:accounts/fireworks/models/glm-5p2",
>     backend=ContextHubBackend("my-agent"),
> )
> ```
>
> ```python Baseten theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import ContextHubBackend
>
> agent = create_deep_agent(
>     model="baseten:zai-org/GLM-5.2",
>     backend=ContextHubBackend("my-agent"),
> )
> ```
>
> ```python Ollama theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import ContextHubBackend
>
> agent = create_deep_agent(
>     model="ollama:north-mini-code-1.0",
>     backend=ContextHubBackend("my-agent"),
> )
> ```
>
> :::
>
> 更多详情，请参阅 [`ContextHubBackend`](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/backends#contexthubbackend)。

> [tab] CompositeBackend
>
> 一种灵活的后端，您可以在其中指定文件系统中的不同路由，以指向不同的后端。
>
> :::python
>
> ```python Google theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="google_genai:gemini-3.6-flash",
>     backend=CompositeBackend(
>         default=StateBackend(),
>         routes={
>             "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
>         },
>     ),
>     store=InMemoryStore(),  # Store passed to create_deep_agent, not backend
> )
> ```
>
> ```python OpenAI theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="openai:gpt-5.5",
>     backend=CompositeBackend(
>         default=StateBackend(),
>         routes={
>             "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
>         },
>     ),
>     store=InMemoryStore(),  # Store passed to create_deep_agent, not backend
> )
> ```
>
> ```python Anthropic theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="anthropic:claude-sonnet-5",
>     backend=CompositeBackend(
>         default=StateBackend(),
>         routes={
>             "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
>         },
>     ),
>     store=InMemoryStore(),  # Store passed to create_deep_agent, not backend
> )
> ```
>
> ```python OpenRouter theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="openrouter:z-ai/glm-5.2",
>     backend=CompositeBackend(
>         default=StateBackend(),
>         routes={
>             "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
>         },
>     ),
>     store=InMemoryStore(),  # Store passed to create_deep_agent, not backend
> )
> ```
>
> ```python Fireworks theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="fireworks:accounts/fireworks/models/glm-5p2",
>     backend=CompositeBackend(
>         default=StateBackend(),
>         routes={
>             "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
>         },
>     ),
>     store=InMemoryStore(),  # Store passed to create_deep_agent, not backend
> )
> ```
>
> ```python Baseten theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="baseten:zai-org/GLM-5.2",
>     backend=CompositeBackend(
>         default=StateBackend(),
>         routes={
>             "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
>         },
>     ),
>     store=InMemoryStore(),  # Store passed to create_deep_agent, not backend
> )
> ```
>
> ```python Ollama theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> agent = create_deep_agent(
>     model="ollama:north-mini-code-1.0",
>     backend=CompositeBackend(
>         default=StateBackend(),
>         routes={
>             "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
>         },
>     ),
>     store=InMemoryStore(),  # Store passed to create_deep_agent, not backend
> )
> ```
>
> :::
>
> :::js
>
> ```ts Google theme={null}
> import {
>   createDeepAgent,
>   CompositeBackend,
>   StateBackend,
>   StoreBackend,
> } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore();
>
> const agent = createDeepAgent({
>   model: "google:gemini-3.6-flash",
>   backend: new CompositeBackend(new StateBackend(), {
>     "/memories/": new StoreBackend({
>       namespace: () => ["memories"],
>     }),
>   }),
>   store,
> });
> ```
>
> ```ts OpenAI theme={null}
> import {
>   createDeepAgent,
>   CompositeBackend,
>   StateBackend,
>   StoreBackend,
> } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore();
>
> const agent = createDeepAgent({
>   model: "openai:gpt-5.5",
>   backend: new CompositeBackend(new StateBackend(), {
>     "/memories/": new StoreBackend({
>       namespace: () => ["memories"],
>     }),
>   }),
>   store,
> });
> ```
>
> ```ts Anthropic theme={null}
> import {
>   createDeepAgent,
>   CompositeBackend,
>   StateBackend,
>   StoreBackend,
> } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore();
>
> const agent = createDeepAgent({
>   model: "anthropic:claude-sonnet-5",
>   backend: new CompositeBackend(new StateBackend(), {
>     "/memories/": new StoreBackend({
>       namespace: () => ["memories"],
>     }),
>   }),
>   store,
> });
> ```
>
> ```ts OpenRouter theme={null}
> import {
>   createDeepAgent,
>   CompositeBackend,
>   StateBackend,
>   StoreBackend,
> } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore();
>
> const agent = createDeepAgent({
>   model: "openrouter:z-ai/glm-5.2",
>   backend: new CompositeBackend(new StateBackend(), {
>     "/memories/": new StoreBackend({
>       namespace: () => ["memories"],
>     }),
>   }),
>   store,
> });
> ```
>
> ```ts Fireworks theme={null}
> import {
>   createDeepAgent,
>   CompositeBackend,
>   StateBackend,
>   StoreBackend,
> } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore();
>
> const agent = createDeepAgent({
>   model: "fireworks:accounts/fireworks/models/glm-5p2",
>   backend: new CompositeBackend(new StateBackend(), {
>     "/memories/": new StoreBackend({
>       namespace: () => ["memories"],
>     }),
>   }),
>   store,
> });
> ```
>
> ```ts Baseten theme={null}
> import {
>   createDeepAgent,
>   CompositeBackend,
>   StateBackend,
>   StoreBackend,
> } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore();
>
> const agent = createDeepAgent({
>   model: "baseten:zai-org/GLM-5.2",
>   backend: new CompositeBackend(new StateBackend(), {
>     "/memories/": new StoreBackend({
>       namespace: () => ["memories"],
>     }),
>   }),
>   store,
> });
> ```
>
> ```ts Ollama theme={null}
> import {
>   createDeepAgent,
>   CompositeBackend,
>   StateBackend,
>   StoreBackend,
> } from "deepagents";
> import { InMemoryStore } from "@langchain/langgraph";
>
> const store = new InMemoryStore();
>
> const agent = createDeepAgent({
>   model: "ollama:north-mini-code-1.0",
>   backend: new CompositeBackend(new StateBackend(), {
>     "/memories/": new StoreBackend({
>       namespace: () => ["memories"],
>     }),
>   }),
>   store,
> });
> ```
>
> :::

更多信息，请参阅 [后端](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/backends.md)。

### 沙盒

沙盒是特殊的 [后端](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/backends.md)，它们在隔离环境中运行智能体代码，拥有自己的文件系统和用于 shell 命令的 `execute` 工具。
当您希望深度智能体在本地机器上不更改任何内容的情况下写入文件、安装依赖项和运行命令时，请使用沙盒后端。

您通过在创建深度智能体时将沙盒后端传递给 `backend` 来配置沙盒：

:::python

> [tab] LangSmith
>
> ```bash pip theme={null}
> pip install langsmith
> ```
>
> ```bash uv theme={null}
> uv add langsmith
> ```
>
> ```python theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import LangSmithSandbox
> from langchain_anthropic import ChatAnthropic
> from langsmith.sandbox import SandboxClient
>
> client = SandboxClient()
> ls_sandbox = client.create_sandbox()
> backend = LangSmithSandbox(sandbox=ls_sandbox)
>
> agent = create_deep_agent(
>     model=ChatAnthropic(model="claude-sonnet-4-6"),
>     system_prompt="You are a Python coding assistant with sandbox access.",
>     backend=backend,
> )
> try:
>     result = agent.invoke(
>         {
>             "messages": [
>                 {
>                     "role": "user",
>                     "content": "Create a small Python package and run pytest",
>                 }
>             ]
>         }
>     )
> finally:
>     client.delete_sandbox(ls_sandbox.name)
> ```

> [tab] Daytona
>
> ```bash pip theme={null}
> pip install langchain-daytona
> ```
>
> ```bash uv theme={null}
> uv add langchain-daytona
> ```
>
> ```python theme={null}
> from daytona import Daytona
> from deepagents import create_deep_agent
> from langchain_anthropic import ChatAnthropic
> from langchain_daytona import DaytonaSandbox
>
> sandbox = Daytona().create()
> backend = DaytonaSandbox(sandbox=sandbox)
>
> agent = create_deep_agent(
>     model=ChatAnthropic(model="claude-sonnet-4-6"),
>     system_prompt="You are a Python coding assistant with sandbox access.",
>     backend=backend,
> )
>
> try:
>     result = agent.invoke(
>         {
>             "messages": [
>                 {
>                     "role": "user",
>                     "content": "Create a small Python package and run pytest",
>                 }
>             ]
>         }
>     )
> finally:
>     sandbox.stop()
> ```

> [tab] E2B
>
> ```bash pip theme={null}
> pip install langchain-e2b
> ```
>
> ```bash uv theme={null}
> uv add langchain-e2b
> ```
>
> ```python theme={null}
> from e2b import Sandbox
> from deepagents import create_deep_agent
> from langchain_anthropic import ChatAnthropic
> from langchain_e2b import E2BSandbox
>
> e2b_sandbox = Sandbox.create()
> backend = E2BSandbox(sandbox=e2b_sandbox)
>
> agent = create_deep_agent(
>     model=ChatAnthropic(model="claude-sonnet-4-6"),
>     system_prompt="You are a Python coding assistant with sandbox access.",
>     backend=backend,
> )
>
> try:
>     result = agent.invoke(
>         {
>             "messages": [
>                 {
>                     "role": "user",
>                     "content": "Create a small Python package and run pytest",
>                 }
>             ]
>         }
>     )
> finally:
>     e2b_sandbox.kill()
> ```

> [tab] Modal
>
> ```bash pip theme={null}
> pip install langchain-modal
> ```
>
> ```bash uv theme={null}
> uv add langchain-modal
> ```
>
> ```python theme={null}
> import modal
> from deepagents import create_deep_agent
> from langchain_anthropic import ChatAnthropic
> from langchain_modal import ModalSandbox
>
> app = modal.App.lookup("your-app")
> modal_sandbox = modal.Sandbox.create(app=app)
> backend = ModalSandbox(sandbox=modal_sandbox)
>
> agent = create_deep_agent(
>     model=ChatAnthropic(model="claude-sonnet-4-6"),
>     system_prompt="You are a Python coding assistant with sandbox access.",
>     backend=backend,
> )
> try:
>     result = agent.invoke(
>         {
>             "messages": [
>                 {
>                     "role": "user",
>                     "content": "Create a small Python package and run pytest",
>                 }
>             ]
>         }
>     )
> finally:
>     modal_sandbox.terminate()
> ```

> [tab] Runloop
>
> ```bash pip theme={null}
> pip install langchain-runloop
> ```
>
> ```bash uv theme={null}
> uv add langchain-runloop
> ```
>
> ```python theme={null}
> import os
>
> from deepagents import create_deep_agent
> from langchain_anthropic import ChatAnthropic
> from langchain_runloop import RunloopSandbox
> from runloop_api_client import RunloopSDK
>
> client = RunloopSDK(bearer_token=os.environ["RUNLOOP_API_KEY"])
>
> devbox = client.devbox.create()
> backend = RunloopSandbox(devbox=devbox)
>
> agent = create_deep_agent(
>     model=ChatAnthropic(model="claude-sonnet-4-6"),
>     system_prompt="You are a Python coding assistant with sandbox access.",
>     backend=backend,
> )
>
> try:
>     result = agent.invoke(
>         {
>             "messages": [
>                 {
>                     "role": "user",
>                     "content": "Create a small Python package and run pytest",
>                 }
>             ]
>         }
>     )
> finally:
>     devbox.shutdown()
> ```

> [tab] Vercel
>
> ```bash pip theme={null}
> pip install langchain-vercel-sandbox
> ```
>
> ```bash uv theme={null}
> uv add langchain-vercel-sandbox
> ```
>
> ```python theme={null}
> from deepagents import create_deep_agent
> from langchain_anthropic import ChatAnthropic
> from langchain_vercel_sandbox import VercelSandbox
> from vercel.sandbox import Sandbox
>
> sandbox = Sandbox.create(runtime="python3.13")
> backend = VercelSandbox(sandbox=sandbox)
>
> agent = create_deep_agent(
>     model=ChatAnthropic(model="claude-sonnet-4-6"),
>     system_prompt="You are a Python coding assistant with sandbox access.",
>     backend=backend,
> )
>
> try:
>     result = agent.invoke(
>         {
>             "messages": [
>                 {
>                     "role": "user",
>                     "content": "Create a small Python package and run pytest",
>                 }
>             ]
>         }
>     )
> finally:
>     sandbox.stop()
> ```

:::

:::js

```typescript theme={null}
import { createDeepAgent, LangSmithSandbox } from "deepagents";
import { ChatAnthropic } from "@langchain/anthropic";
import { SandboxClient } from "langsmith/sandbox";

const client = new SandboxClient();
const lsSandbox = await client.createSandbox();

try {
  const agent = createDeepAgent({
    model: new ChatAnthropic({ model: "claude-opus-4-8" }),
    systemPrompt: "You are a coding assistant with sandbox access.",
    backend: new LangSmithSandbox({ sandbox: lsSandbox }),
  });

  const result = await agent.invoke({
    messages: [
      {
        role: "user",
        content: "Create a hello world Python script and run it",
      },
    ],
  });
} finally {
  await client.deleteSandbox(lsSandbox.name);
}
```

:::

更多信息，请参阅 [沙盒](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/sandboxes.md)。

## 人机交互

某些工具操作可能敏感，需要在执行前获得人工批准。
您可以配置每个工具的批准：

:::python

```python Google theme={null}
from langchain.tools import tool
from deepagents import create_deep_agent
from langgraph.checkpoint.memory import MemorySaver


@tool
def remove_file(path: str) -> str:
    """Delete a file from the filesystem."""
    return f"Deleted {path}"


@tool
def fetch_file(path: str) -> str:
    """Read a file from the filesystem."""
    return f"Contents of {path}"


@tool
def notify_email(to: str, subject: str, body: str) -> str:
    """Send an email."""
    return f"Sent email to {to}"


# Checkpointer is REQUIRED for human-in-the-loop
checkpointer = MemorySaver()

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    tools=[remove_file, fetch_file, notify_email],
    interrupt_on={
        "remove_file": True,  # Default: approve, edit, reject, respond
        "fetch_file": False,  # No interrupts needed
        "notify_email": {"allowed_decisions": ["approve", "reject"]},  # No editing
    },
    checkpointer=checkpointer,  # Required!
)
```

```python OpenAI theme={null}
from langchain.tools import tool
from deepagents import create_deep_agent
from langgraph.checkpoint.memory import MemorySaver


@tool
def remove_file(path: str) -> str:
    """Delete a file from the filesystem."""
    return f"Deleted {path}"


@tool
def fetch_file(path: str) -> str:
    """Read a file from the filesystem."""
    return f"Contents of {path}"


@tool
def notify_email(to: str, subject: str, body: str) -> str:
    """Send an email."""
    return f"Sent email to {to}"


# Checkpointer is REQUIRED for human-in-the-loop
checkpointer = MemorySaver()

agent = create_deep_agent(
    model="openai:gpt-5.5",
    tools=[remove_file, fetch_file, notify_email],
    interrupt_on={
        "remove_file": True,  # Default: approve, edit, reject, respond
        "fetch_file": False,  # No interrupts needed
        "notify_email": {"allowed_decisions": ["approve", "reject"]},  # No editing
    },
    checkpointer=checkpointer,  # Required!
)
```

```python Anthropic theme={null}
from langchain.tools import tool
from deepagents import create_deep_agent
from langgraph.checkpoint.memory import MemorySaver


@tool
def remove_file(path: str) -> str:
    """Delete a file from the filesystem."""
    return f"Deleted {path}"


@tool
def fetch_file(path: str) -> str:
    """Read a file from the filesystem."""
    return f"Contents of {path}"


@tool
def notify_email(to: str, subject: str, body: str) -> str:
    """Send an email."""
    return f"Sent email to {to}"


# Checkpointer is REQUIRED for human-in-the-loop
checkpointer = MemorySaver()

agent = create_deep_agent(
    model="anthropic:claude-sonnet-5",
    tools=[remove_file, fetch_file, notify_email],
    interrupt_on={
        "remove_file": True,  # Default: approve, edit, reject, respond
        "fetch_file": False,  # No interrupts needed
        "notify_email": {"allowed_decisions": ["approve", "reject"]},  # No editing
    },
    checkpointer=checkpointer,  # Required!
)
```

```python OpenRouter theme={null}
from langchain.tools import tool
from deepagents import create_deep_agent
from langgraph.checkpoint.memory import MemorySaver


@tool
def remove_file(path: str) -> str:
    """Delete a file from the filesystem."""
    return f"Deleted {path}"


@tool
def fetch_file(path: str) -> str:
    """Read a file from the filesystem."""
    return f"Contents of {path}"


@tool
def notify_email(to: str, subject: str, body: str) -> str:
    """Send an email."""
    return f"Sent email to {to}"


# Checkpointer is REQUIRED for human-in-the-loop
checkpointer = MemorySaver()

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    tools=[remove_file, fetch_file, notify_email],
    interrupt_on={
        "remove_file": True,  # Default: approve, edit, reject, respond
        "fetch_file": False,  # No interrupts needed
        "notify_email": {"allowed_decisions": ["approve", "reject"]},  # No editing
    },
    checkpointer=checkpointer,  # Required!
)
```

```python Fireworks theme={null}
from langchain.tools import tool
from deepagents import create_deep_agent
from langgraph.checkpoint.memory import MemorySaver


@tool
def remove_file(path: str) -> str:
    """Delete a file from the filesystem."""
    return f"Deleted {path}"


@tool
def fetch_file(path: str) -> str:
    """Read a file from the filesystem."""
    return f"Contents of {path}"


@tool
def notify_email(to: str, subject: str, body: str) -> str:
    """Send an email."""
    return f"Sent email to {to}"


# Checkpointer is REQUIRED for human-in-the-loop
checkpointer = MemorySaver()

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    tools=[remove_file, fetch_file, notify_email],
    interrupt_on={
        "remove_file": True,  # Default: approve, edit, reject, respond
        "fetch_file": False,  # No interrupts needed
        "notify_email": {"allowed_decisions": ["approve", "reject"]},  # No editing
    },
    checkpointer=checkpointer,  # Required!
)
```

```python Baseten theme={null}
from langchain.tools import tool
from deepagents import create_deep_agent
from langgraph.checkpoint.memory import MemorySaver


@tool
def remove_file(path: str) -> str:
    """Delete a file from the filesystem."""
    return f"Deleted {path}"


@tool
def fetch_file(path: str) -> str:
    """Read a file from the filesystem."""
    return f"Contents of {path}"


@tool
def notify_email(to: str, subject: str, body: str) -> str:
    """Send an email."""
    return f"Sent email to {to}"


# Checkpointer is REQUIRED for human-in-the-loop
checkpointer = MemorySaver()

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    tools=[remove_file, fetch_file, notify_email],
    interrupt_on={
        "remove_file": True,  # Default: approve, edit, reject, respond
        "fetch_file": False,  # No interrupts needed
        "notify_email": {"allowed_decisions": ["approve", "reject"]},  # No editing
    },
    checkpointer=checkpointer,  # Required!
)
```

```python Ollama theme={null}
from langchain.tools import tool
from deepagents import create_deep_agent
from langgraph.checkpoint.memory import MemorySaver


@tool
def remove_file(path: str) -> str:
    """Delete a file from the filesystem."""
    return f"Deleted {path}"


@tool
def fetch_file(path: str) -> str:
    """Read a file from the filesystem."""
    return f"Contents of {path}"


@tool
def notify_email(to: str, subject: str, body: str) -> str:
    """Send an email."""
    return f"Sent email to {to}"


# Checkpointer is REQUIRED for human-in-the-loop
checkpointer = MemorySaver()

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    tools=[remove_file, fetch_file, notify_email],
    interrupt_on={
        "remove_file": True,  # Default: approve, edit, reject, respond
        "fetch_file": False,  # No interrupts needed
        "notify_email": {"allowed_decisions": ["approve", "reject"]},  # No editing
    },
    checkpointer=checkpointer,  # Required!
)
```

:::

:::js

```ts theme={null}
import { tool } from "langchain";
import { createDeepAgent } from "deepagents";
import { MemorySaver } from "@langchain/langgraph";
import { z } from "zod";

const removeFile = tool(
  async ({ path }: { path: string }) => {
    return `Deleted ${path}`;
  },
  {
    name: "remove_file",
    description: "Delete a file from the filesystem.",
    schema: z.object({
      path: z.string(),
    }),
  },
);

const fetchFile = tool(
  async ({ path }: { path: string }) => {
    return `Contents of ${path}`;
  },
  {
    name: "fetch_file",
    description: "Read a file from the filesystem.",
    schema: z.object({
      path: z.string(),
    }),
  },
);

const notifyEmail = tool(
  async ({
    to,
    subject,
    body,
  }: {
    to: string;
    subject: string;
    body: string;
  }) => {
    return `Sent email to ${to}`;
  },
  {
    name: "notify_email",
    description: "Send an email.",
    schema: z.object({
      to: z.string(),
      subject: z.string(),
      body: z.string(),
    }),
  },
);

// Checkpointer is REQUIRED for human-in-the-loop
const checkpointer = new MemorySaver();

const agent = createDeepAgent({
  model: "google:gemini-3.6-flash",
  tools: [removeFile, fetchFile, notifyEmail],
  interruptOn: {
    remove_file: true, // Default: approve, edit, reject, respond
    fetch_file: false, // No interrupts needed
    notify_email: { allowedDecisions: ["approve", "reject"] }, // No editing
  },
  checkpointer, // Required!
});
```

:::

您可以在工具调用以及工具调用内部配置智能体和子智能体的中断。
更多信息，请参阅 [Human-in-the-loop](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/human-in-the-loop.md)。

## 技能

您可以使用 [skills](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/overview.md) 为您的深度智能体提供新的能力和专业知识。
虽然 [tools](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/customization.md#工具) 往往涵盖较低级别的功能，如原生文件系统操作，但技能可以包含完成任务的详细说明、参考资料和其他资源，例如模板。
这些文件仅在智能体确定该技能对当前提示有用时才会被加载。
这种渐进式披露减少了智能体在启动时需要考虑的 Token 数量和上下文。

示例技能，请参阅 [Deep Agents example skills](https://github.com/langchain-ai/deepagentsjs/tree/main/examples/skills)。

要将技能添加到您的深度智能体，请将它们作为参数传递给 `create_deep_agent`：

:::python

> [tab] StateBackend
>
> ```python Google theme={null}
> from urllib.request import urlopen
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> checkpointer = MemorySaver()
> backend = StateBackend()
>
> skill_url = "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/libs/code/examples/skills/langgraph-docs/SKILL.md"
> with urlopen(skill_url) as response:
>     skill_content = response.read().decode('utf-8')
>
> skills_files = {
>     "/skills/langgraph-docs/SKILL.md": create_file_data(skill_content),
> }
>
> agent = create_deep_agent(
>     model="google_genai:gemini-3.6-flash",
>     backend=backend,
>     skills=["/skills/"],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [{"role": "user", "content": "What is langgraph?"}],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": skills_files,
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python OpenAI theme={null}
> from urllib.request import urlopen
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> checkpointer = MemorySaver()
> backend = StateBackend()
>
> skill_url = "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/libs/code/examples/skills/langgraph-docs/SKILL.md"
> with urlopen(skill_url) as response:
>     skill_content = response.read().decode('utf-8')
>
> skills_files = {
>     "/skills/langgraph-docs/SKILL.md": create_file_data(skill_content),
> }
>
> agent = create_deep_agent(
>     model="openai:gpt-5.5",
>     backend=backend,
>     skills=["/skills/"],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [{"role": "user", "content": "What is langgraph?"}],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": skills_files,
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python Anthropic theme={null}
> from urllib.request import urlopen
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> checkpointer = MemorySaver()
> backend = StateBackend()
>
> skill_url = "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/libs/code/examples/skills/langgraph-docs/SKILL.md"
> with urlopen(skill_url) as response:
>     skill_content = response.read().decode('utf-8')
>
> skills_files = {
>     "/skills/langgraph-docs/SKILL.md": create_file_data(skill_content),
> }
>
> agent = create_deep_agent(
>     model="anthropic:claude-sonnet-5",
>     backend=backend,
>     skills=["/skills/"],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [{"role": "user", "content": "What is langgraph?"}],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": skills_files,
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python OpenRouter theme={null}
> from urllib.request import urlopen
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> checkpointer = MemorySaver()
> backend = StateBackend()
>
> skill_url = "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/libs/code/examples/skills/langgraph-docs/SKILL.md"
> with urlopen(skill_url) as response:
>     skill_content = response.read().decode('utf-8')
>
> skills_files = {
>     "/skills/langgraph-docs/SKILL.md": create_file_data(skill_content),
> }
>
> agent = create_deep_agent(
>     model="openrouter:z-ai/glm-5.2",
>     backend=backend,
>     skills=["/skills/"],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [{"role": "user", "content": "What is langgraph?"}],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": skills_files,
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python Fireworks theme={null}
> from urllib.request import urlopen
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> checkpointer = MemorySaver()
> backend = StateBackend()
>
> skill_url = "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/libs/code/examples/skills/langgraph-docs/SKILL.md"
> with urlopen(skill_url) as response:
>     skill_content = response.read().decode('utf-8')
>
> skills_files = {
>     "/skills/langgraph-docs/SKILL.md": create_file_data(skill_content),
> }
>
> agent = create_deep_agent(
>     model="fireworks:accounts/fireworks/models/glm-5p2",
>     backend=backend,
>     skills=["/skills/"],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [{"role": "user", "content": "What is langgraph?"}],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": skills_files,
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python Baseten theme={null}
> from urllib.request import urlopen
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> checkpointer = MemorySaver()
> backend = StateBackend()
>
> skill_url = "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/libs/code/examples/skills/langgraph-docs/SKILL.md"
> with urlopen(skill_url) as response:
>     skill_content = response.read().decode('utf-8')
>
> skills_files = {
>     "/skills/langgraph-docs/SKILL.md": create_file_data(skill_content),
> }
>
> agent = create_deep_agent(
>     model="baseten:zai-org/GLM-5.2",
>     backend=backend,
>     skills=["/skills/"],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [{"role": "user", "content": "What is langgraph?"}],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": skills_files,
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python Ollama theme={null}
> from urllib.request import urlopen
> from deepagents import create_deep_agent
> from deepagents.backends import StateBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> checkpointer = MemorySaver()
> backend = StateBackend()
>
> skill_url = "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/libs/code/examples/skills/langgraph-docs/SKILL.md"
> with urlopen(skill_url) as response:
>     skill_content = response.read().decode('utf-8')
>
> skills_files = {
>     "/skills/langgraph-docs/SKILL.md": create_file_data(skill_content),
> }
>
> agent = create_deep_agent(
>     model="ollama:north-mini-code-1.0",
>     backend=backend,
>     skills=["/skills/"],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [{"role": "user", "content": "What is langgraph?"}],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": skills_files,
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```

> [tab] StoreBackend
>
> ```python theme={null}
> from urllib.request import urlopen
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from langgraph.store.memory import InMemoryStore
>
> store = InMemoryStore()
> backend = StoreBackend(
>     namespace=lambda _rt: ("filesystem",),
>     store=store,
> )
>
> skill_url = "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/libs/code/examples/skills/langgraph-docs/SKILL.md"
> with urlopen(skill_url) as response:
>     skill_content = response.read().decode('utf-8')
>
> backend.upload_files(
>     [("/skills/langgraph-docs/SKILL.md", skill_content.encode("utf-8"))]
> )
>
> agent = create_deep_agent(
>     model="google_genai:gemini-3.6-flash",
>     backend=backend,
>     store=store,
>     skills=["/skills/"],
> )
>
> result = agent.invoke(
>     {"messages": [{"role": "user", "content": "What is langgraph?"}]},
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```

> [tab] FilesystemBackend
>
> ```python theme={null}
> from urllib.request import urlopen
> from deepagents import create_deep_agent
> from deepagents.backends.filesystem import FilesystemBackend
> from langgraph.checkpoint.memory import MemorySaver
>
> # Checkpointer is REQUIRED for human-in-the-loop
> checkpointer = MemorySaver()
>
> skill_url = "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/libs/code/examples/skills/langgraph-docs/SKILL.md"
> with urlopen(skill_url) as response:
>     skill_content = response.read().decode('utf-8')
>
> backend = FilesystemBackend(root_dir="/Users/user/{project}", virtual_mode=True)
> backend.upload_files(
>     [("/skills/langgraph-docs/SKILL.md", skill_content.encode("utf-8"))]
> )
>
> agent = create_deep_agent(
>     model="google_genai:gemini-3.6-flash",
>     backend=backend,
>     skills=["/skills/"],
>     interrupt_on={
>         "write_file": True,
>         "read_file": False,
>         "edit_file": True,
>     },
>     checkpointer=checkpointer,  # Required for filesystem operations!
> )
>
> result = agent.invoke(
>     {"messages": [{"role": "user", "content": "What is langgraph?"}]},
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```

:::

:::js

> [tab] StateBackend
>
> ```ts theme={null}
> import { createDeepAgent, StateBackend, type FileData } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> const checkpointer = new MemorySaver();
> const backend = new StateBackend();
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content: content.split("\n"),
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const skillsFiles: Record<string, FileData> = {};
> const skillUrl =
>   "https://raw.githubusercontent.com/langchain-ai/deepagentsjs/refs/heads/main/examples/skills/langgraph-docs/SKILL.md";
> const response = await fetch(skillUrl);
> const skillContent = await response.text();
>
> skillsFiles["/skills/langgraph-docs/SKILL.md"] = createFileData(skillContent);
>
> const agent = await createDeepAgent({
>   model: "anthropic:claude-sonnet-4-6",
>   backend,
>   checkpointer, // Required !
>   // IMPORTANT: deepagents skill source paths are virtual (POSIX) paths relative to the backend root.
>   skills: ["/skills/"],
> });
>
> const config = { configurable: { thread_id: `thread-${Date.now()}` } };
> const result = await agent.invoke(
>   {
>     messages: [{ role: "user", content: "what is langraph?" }],
>     files: skillsFiles,
>   },
>   config,
> );
> ```
>
> > [card] [View example trace](https://smith.langchain.com/public/5c684c86-25c2-471e-a9f3-c43767036b26/r)
> >
> > 为此示例打开一个公开的 LangSmith 运行。

> [tab] StoreBackend
>
> ```ts theme={null}
> import { createDeepAgent, StoreBackend } from "deepagents";
> import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
>
> const checkpointer = new MemorySaver();
> const store = new InMemoryStore();
> const backend = new StoreBackend({
>   namespace: () => ["filesystem"],
>   store,
> });
>
> const skillUrl =
>   "https://raw.githubusercontent.com/langchain-ai/deepagentsjs/refs/heads/main/examples/skills/langgraph-docs/SKILL.md";
>
> const response = await fetch(skillUrl);
> const skillContent = await response.text();
>
> await backend.uploadFiles([
>   ["/skills/langgraph-docs/SKILL.md", new TextEncoder().encode(skillContent)],
> ]);
>
> const agent = await createDeepAgent({
>   model: "anthropic:claude-sonnet-4-6",
>   backend,
>   store,
>   checkpointer,
>   // IMPORTANT: deepagents skill source paths are virtual (POSIX) paths relative to the backend root.
>   skills: ["/skills/"],
> });
>
> const config = {
>   recursionLimit: 50,
>   configurable: { thread_id: `thread-${Date.now()}` },
> };
> const result = await agent.invoke(
>   { messages: [{ role: "user", content: "what is langraph?" }] },
>   config,
> );
> ```
>
> > [card] [View example trace](https://smith.langchain.com/public/2b64039f-58ff-4bf9-930e-45e57f61c09b/r)
> >
> > 为此示例打开一个公开的 LangSmith 运行。

> [tab] FilesystemBackend
>
> ```ts theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> const checkpointer = new MemorySaver();
>
> const skillUrl =
>   "https://raw.githubusercontent.com/langchain-ai/deepagentsjs/refs/heads/main/examples/skills/langgraph-docs/SKILL.md";
> const response = await fetch(skillUrl);
> const skillContent = await response.text();
>
> let backend = new FilesystemBackend({
>   rootDir: process.cwd(),
>   virtualMode: true,
> });
> await backend.uploadFiles([
>   ["/skills/langgraph-docs/SKILL.md", new TextEncoder().encode(skillContent)],
> ]);
>
> const agent = await createDeepAgent({
>   model: "anthropic:claude-sonnet-4-6",
>   backend,
>   // IMPORTANT: deepagents skill source paths are virtual (POSIX) paths relative to the backend root.
>   skills: ["/skills/"],
>   interruptOn: {
>     read_file: true,
>     write_file: true,
>     delete_file: true,
>   },
>   checkpointer, // Required for filesystem operations!
> });
>
> const config = { configurable: { thread_id: `thread-${Date.now()}` } };
> const result = await agent.invoke(
>   { messages: [{ role: "user", content: "what is langraph?" }] },
>   config,
> );
> ```
>
> > [card] [View example trace](https://smith.langchain.com/public/f81b4363-f551-4eec-a7c2-16fa91834002/r)
> >
> > 为此示例打开一个公开的 LangSmith 运行。

:::

## 记忆

使用 [`AGENTS.md` 文件](https://agents.md/) 为您的深度智能体提供额外上下文。

> [!TIP]
>
> 要生成编码智能体通过 `AGENTS.md` 发现的仓库维基，请参阅 [OpenWiki](https://langchain-docs-zh.mintlify.site/langchain/oss/openwiki/overview.md)。

在创建您的深度智能体时，您可以将一个或多个文件路径传递给 `memory` 参数：

:::python

> [tab] StateBackend
>
> ```python Google theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="google_genai:gemini-3.6-flash",
>     memory=[
>         "/AGENTS.md"
>     ],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "123456"}},
> )
> ```
>
> ```python OpenAI theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="openai:gpt-5.5",
>     memory=[
>         "/AGENTS.md"
>     ],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "123456"}},
> )
> ```
>
> ```python Anthropic theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="anthropic:claude-sonnet-5",
>     memory=[
>         "/AGENTS.md"
>     ],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "123456"}},
> )
> ```
>
> ```python OpenRouter theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="openrouter:z-ai/glm-5.2",
>     memory=[
>         "/AGENTS.md"
>     ],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "123456"}},
> )
> ```
>
> ```python Fireworks theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="fireworks:accounts/fireworks/models/glm-5p2",
>     memory=[
>         "/AGENTS.md"
>     ],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "123456"}},
> )
> ```
>
> ```python Baseten theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="baseten:zai-org/GLM-5.2",
>     memory=[
>         "/AGENTS.md"
>     ],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "123456"}},
> )
> ```
>
> ```python Ollama theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends.utils import create_file_data
> from langgraph.checkpoint.memory import MemorySaver
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="ollama:north-mini-code-1.0",
>     memory=[
>         "/AGENTS.md"
>     ],
>     checkpointer=checkpointer,
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         # Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "123456"}},
> )
> ```

> [tab] StoreBackend
>
> ```python Google theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.store.memory import InMemoryStore
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
>
> # Create the store and add the file to it
> store = InMemoryStore()
> file_data = create_file_data(agents_md)
> store.put(
>     namespace=("filesystem",),
>     key="/AGENTS.md",
>     value=file_data,
> )
>
> agent = create_deep_agent(
>     model="google_genai:gemini-3.6-flash",
>     backend=StoreBackend(namespace=lambda _rt: ("filesystem",)),
>     store=store,
>     memory=["/AGENTS.md"],
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python OpenAI theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.store.memory import InMemoryStore
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
>
> # Create the store and add the file to it
> store = InMemoryStore()
> file_data = create_file_data(agents_md)
> store.put(
>     namespace=("filesystem",),
>     key="/AGENTS.md",
>     value=file_data,
> )
>
> agent = create_deep_agent(
>     model="openai:gpt-5.5",
>     backend=StoreBackend(namespace=lambda _rt: ("filesystem",)),
>     store=store,
>     memory=["/AGENTS.md"],
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python Anthropic theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.store.memory import InMemoryStore
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
>
> # Create the store and add the file to it
> store = InMemoryStore()
> file_data = create_file_data(agents_md)
> store.put(
>     namespace=("filesystem",),
>     key="/AGENTS.md",
>     value=file_data,
> )
>
> agent = create_deep_agent(
>     model="anthropic:claude-sonnet-5",
>     backend=StoreBackend(namespace=lambda _rt: ("filesystem",)),
>     store=store,
>     memory=["/AGENTS.md"],
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python OpenRouter theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.store.memory import InMemoryStore
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
>
> # Create the store and add the file to it
> store = InMemoryStore()
> file_data = create_file_data(agents_md)
> store.put(
>     namespace=("filesystem",),
>     key="/AGENTS.md",
>     value=file_data,
> )
>
> agent = create_deep_agent(
>     model="openrouter:z-ai/glm-5.2",
>     backend=StoreBackend(namespace=lambda _rt: ("filesystem",)),
>     store=store,
>     memory=["/AGENTS.md"],
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python Fireworks theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.store.memory import InMemoryStore
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
>
> # Create the store and add the file to it
> store = InMemoryStore()
> file_data = create_file_data(agents_md)
> store.put(
>     namespace=("filesystem",),
>     key="/AGENTS.md",
>     value=file_data,
> )
>
> agent = create_deep_agent(
>     model="fireworks:accounts/fireworks/models/glm-5p2",
>     backend=StoreBackend(namespace=lambda _rt: ("filesystem",)),
>     store=store,
>     memory=["/AGENTS.md"],
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python Baseten theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.store.memory import InMemoryStore
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
>
> # Create the store and add the file to it
> store = InMemoryStore()
> file_data = create_file_data(agents_md)
> store.put(
>     namespace=("filesystem",),
>     key="/AGENTS.md",
>     value=file_data,
> )
>
> agent = create_deep_agent(
>     model="baseten:zai-org/GLM-5.2",
>     backend=StoreBackend(namespace=lambda _rt: ("filesystem",)),
>     store=store,
>     memory=["/AGENTS.md"],
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python Ollama theme={null}
> from urllib.request import urlopen
>
> from deepagents import create_deep_agent
> from deepagents.backends import StoreBackend
> from deepagents.backends.utils import create_file_data
> from langgraph.store.memory import InMemoryStore
>
> with urlopen(
>     "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md"
> ) as response:
>     agents_md = response.read().decode("utf-8")
>
> # Create the store and add the file to it
> store = InMemoryStore()
> file_data = create_file_data(agents_md)
> store.put(
>     namespace=("filesystem",),
>     key="/AGENTS.md",
>     value=file_data,
> )
>
> agent = create_deep_agent(
>     model="ollama:north-mini-code-1.0",
>     backend=StoreBackend(namespace=lambda _rt: ("filesystem",)),
>     store=store,
>     memory=["/AGENTS.md"],
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>         "files": {"/AGENTS.md": create_file_data(agents_md)},
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```

> [tab] FilesystemBackend
>
> ```python Google theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
> from langgraph.checkpoint.memory import MemorySaver
>
> # Checkpointer is REQUIRED for human-in-the-loop
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="google_genai:gemini-3.6-flash",
>     backend=FilesystemBackend(root_dir="/Users/user/{project}"),
>     memory=[
>         "./AGENTS.md"
>     ],
>     interrupt_on={
>         "write_file": True,  # Default: approve, edit, reject
>         "read_file": False,  # No interrupts needed
>         "edit_file": True,   # Default: approve, edit, reject
>     },
>     checkpointer=checkpointer,  # Required!
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python OpenAI theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
> from langgraph.checkpoint.memory import MemorySaver
>
> # Checkpointer is REQUIRED for human-in-the-loop
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="openai:gpt-5.5",
>     backend=FilesystemBackend(root_dir="/Users/user/{project}"),
>     memory=[
>         "./AGENTS.md"
>     ],
>     interrupt_on={
>         "write_file": True,  # Default: approve, edit, reject
>         "read_file": False,  # No interrupts needed
>         "edit_file": True,   # Default: approve, edit, reject
>     },
>     checkpointer=checkpointer,  # Required!
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python Anthropic theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
> from langgraph.checkpoint.memory import MemorySaver
>
> # Checkpointer is REQUIRED for human-in-the-loop
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="anthropic:claude-sonnet-5",
>     backend=FilesystemBackend(root_dir="/Users/user/{project}"),
>     memory=[
>         "./AGENTS.md"
>     ],
>     interrupt_on={
>         "write_file": True,  # Default: approve, edit, reject
>         "read_file": False,  # No interrupts needed
>         "edit_file": True,   # Default: approve, edit, reject
>     },
>     checkpointer=checkpointer,  # Required!
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python OpenRouter theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
> from langgraph.checkpoint.memory import MemorySaver
>
> # Checkpointer is REQUIRED for human-in-the-loop
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="openrouter:z-ai/glm-5.2",
>     backend=FilesystemBackend(root_dir="/Users/user/{project}"),
>     memory=[
>         "./AGENTS.md"
>     ],
>     interrupt_on={
>         "write_file": True,  # Default: approve, edit, reject
>         "read_file": False,  # No interrupts needed
>         "edit_file": True,   # Default: approve, edit, reject
>     },
>     checkpointer=checkpointer,  # Required!
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python Fireworks theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
> from langgraph.checkpoint.memory import MemorySaver
>
> # Checkpointer is REQUIRED for human-in-the-loop
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="fireworks:accounts/fireworks/models/glm-5p2",
>     backend=FilesystemBackend(root_dir="/Users/user/{project}"),
>     memory=[
>         "./AGENTS.md"
>     ],
>     interrupt_on={
>         "write_file": True,  # Default: approve, edit, reject
>         "read_file": False,  # No interrupts needed
>         "edit_file": True,   # Default: approve, edit, reject
>     },
>     checkpointer=checkpointer,  # Required!
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python Baseten theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
> from langgraph.checkpoint.memory import MemorySaver
>
> # Checkpointer is REQUIRED for human-in-the-loop
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="baseten:zai-org/GLM-5.2",
>     backend=FilesystemBackend(root_dir="/Users/user/{project}"),
>     memory=[
>         "./AGENTS.md"
>     ],
>     interrupt_on={
>         "write_file": True,  # Default: approve, edit, reject
>         "read_file": False,  # No interrupts needed
>         "edit_file": True,   # Default: approve, edit, reject
>     },
>     checkpointer=checkpointer,  # Required!
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```
>
> ```python Ollama theme={null}
> from deepagents import create_deep_agent
> from deepagents.backends import FilesystemBackend
> from langgraph.checkpoint.memory import MemorySaver
>
> # Checkpointer is REQUIRED for human-in-the-loop
> checkpointer = MemorySaver()
>
> agent = create_deep_agent(
>     model="ollama:north-mini-code-1.0",
>     backend=FilesystemBackend(root_dir="/Users/user/{project}"),
>     memory=[
>         "./AGENTS.md"
>     ],
>     interrupt_on={
>         "write_file": True,  # Default: approve, edit, reject
>         "read_file": False,  # No interrupts needed
>         "edit_file": True,   # Default: approve, edit, reject
>     },
>     checkpointer=checkpointer,  # Required!
> )
>
> result = agent.invoke(
>     {
>         "messages": [
>             {
>                 "role": "user",
>                 "content": "Please tell me what's in your memory files.",
>             }
>         ],
>     },
>     config={"configurable": {"thread_id": "12345"}},
> )
> ```

:::

:::js

> [tab] StateBackend
>
> ```ts Google theme={null}
> import { createDeepAgent, type FileData } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
> const checkpointer = new MemorySaver();
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const agent = await createDeepAgent({
>   model: "google:gemini-3.6-flash",
>   memory: ["/AGENTS.md"],
>   checkpointer: checkpointer,
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>     // Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>     files: { "/AGENTS.md": createFileData(agentsMd) },
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> ```ts OpenAI theme={null}
> import { createDeepAgent, type FileData } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
> const checkpointer = new MemorySaver();
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const agent = await createDeepAgent({
>   model: "openai:gpt-5.5",
>   memory: ["/AGENTS.md"],
>   checkpointer: checkpointer,
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>     // Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>     files: { "/AGENTS.md": createFileData(agentsMd) },
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> ```ts Anthropic theme={null}
> import { createDeepAgent, type FileData } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
> const checkpointer = new MemorySaver();
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const agent = await createDeepAgent({
>   model: "anthropic:claude-sonnet-5",
>   memory: ["/AGENTS.md"],
>   checkpointer: checkpointer,
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>     // Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>     files: { "/AGENTS.md": createFileData(agentsMd) },
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> ```ts OpenRouter theme={null}
> import { createDeepAgent, type FileData } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
> const checkpointer = new MemorySaver();
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const agent = await createDeepAgent({
>   model: "openrouter:z-ai/glm-5.2",
>   memory: ["/AGENTS.md"],
>   checkpointer: checkpointer,
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>     // Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>     files: { "/AGENTS.md": createFileData(agentsMd) },
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> ```ts Fireworks theme={null}
> import { createDeepAgent, type FileData } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
> const checkpointer = new MemorySaver();
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const agent = await createDeepAgent({
>   model: "fireworks:accounts/fireworks/models/glm-5p2",
>   memory: ["/AGENTS.md"],
>   checkpointer: checkpointer,
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>     // Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>     files: { "/AGENTS.md": createFileData(agentsMd) },
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> ```ts Baseten theme={null}
> import { createDeepAgent, type FileData } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
> const checkpointer = new MemorySaver();
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const agent = await createDeepAgent({
>   model: "baseten:zai-org/GLM-5.2",
>   memory: ["/AGENTS.md"],
>   checkpointer: checkpointer,
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>     // Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>     files: { "/AGENTS.md": createFileData(agentsMd) },
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> ```ts Ollama theme={null}
> import { createDeepAgent, type FileData } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
> const checkpointer = new MemorySaver();
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const agent = await createDeepAgent({
>   model: "ollama:north-mini-code-1.0",
>   memory: ["/AGENTS.md"],
>   checkpointer: checkpointer,
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>     // Seed the default StateBackend's in-state filesystem (virtual paths must start with "/").
>     files: { "/AGENTS.md": createFileData(agentsMd) },
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> > [card] [View example trace](https://smith.langchain.com/public/052032cf-2e25-431a-a23a-ba4fc280db51/r)
> >
> > 为此示例打开一个公开的 LangSmith 运行。

> [tab] StoreBackend
>
> ```ts Google theme={null}
> import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
> import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const store = new InMemoryStore();
> const fileData = createFileData(agentsMd);
> await store.put(["filesystem"], "/AGENTS.md", fileData);
>
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "google:gemini-3.6-flash",
>   backend: new StoreBackend({
>     namespace: () => ["filesystem"],
>   }),
>   store: store,
>   checkpointer: checkpointer,
>   memory: ["/AGENTS.md"],
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> ```ts OpenAI theme={null}
> import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
> import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const store = new InMemoryStore();
> const fileData = createFileData(agentsMd);
> await store.put(["filesystem"], "/AGENTS.md", fileData);
>
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "openai:gpt-5.5",
>   backend: new StoreBackend({
>     namespace: () => ["filesystem"],
>   }),
>   store: store,
>   checkpointer: checkpointer,
>   memory: ["/AGENTS.md"],
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> ```ts Anthropic theme={null}
> import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
> import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const store = new InMemoryStore();
> const fileData = createFileData(agentsMd);
> await store.put(["filesystem"], "/AGENTS.md", fileData);
>
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "anthropic:claude-sonnet-5",
>   backend: new StoreBackend({
>     namespace: () => ["filesystem"],
>   }),
>   store: store,
>   checkpointer: checkpointer,
>   memory: ["/AGENTS.md"],
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> ```ts OpenRouter theme={null}
> import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
> import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const store = new InMemoryStore();
> const fileData = createFileData(agentsMd);
> await store.put(["filesystem"], "/AGENTS.md", fileData);
>
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "openrouter:z-ai/glm-5.2",
>   backend: new StoreBackend({
>     namespace: () => ["filesystem"],
>   }),
>   store: store,
>   checkpointer: checkpointer,
>   memory: ["/AGENTS.md"],
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> ```ts Fireworks theme={null}
> import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
> import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const store = new InMemoryStore();
> const fileData = createFileData(agentsMd);
> await store.put(["filesystem"], "/AGENTS.md", fileData);
>
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "fireworks:accounts/fireworks/models/glm-5p2",
>   backend: new StoreBackend({
>     namespace: () => ["filesystem"],
>   }),
>   store: store,
>   checkpointer: checkpointer,
>   memory: ["/AGENTS.md"],
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> ```ts Baseten theme={null}
> import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
> import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const store = new InMemoryStore();
> const fileData = createFileData(agentsMd);
> await store.put(["filesystem"], "/AGENTS.md", fileData);
>
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "baseten:zai-org/GLM-5.2",
>   backend: new StoreBackend({
>     namespace: () => ["filesystem"],
>   }),
>   store: store,
>   checkpointer: checkpointer,
>   memory: ["/AGENTS.md"],
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> ```ts Ollama theme={null}
> import { createDeepAgent, StoreBackend, type FileData } from "deepagents";
> import { InMemoryStore, MemorySaver } from "@langchain/langgraph";
>
> const AGENTS_MD_URL =
>   "https://raw.githubusercontent.com/langchain-ai/deepagents/refs/heads/main/examples/text-to-sql-agent/AGENTS.md";
>
> async function fetchText(url: string): Promise<string> {
>   const res = await fetch(url);
>   if (!res.ok) {
>     throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
>   }
>   return await res.text();
> }
>
> const agentsMd = await fetchText(AGENTS_MD_URL);
>
> function createFileData(content: string): FileData {
>   const now = new Date().toISOString();
>   return {
>     content,
>     mimeType: "text/plain",
>     created_at: now,
>     modified_at: now,
>   };
> }
>
> const store = new InMemoryStore();
> const fileData = createFileData(agentsMd);
> await store.put(["filesystem"], "/AGENTS.md", fileData);
>
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "ollama:north-mini-code-1.0",
>   backend: new StoreBackend({
>     namespace: () => ["filesystem"],
>   }),
>   store: store,
>   checkpointer: checkpointer,
>   memory: ["/AGENTS.md"],
> });
>
> const result = await agent.invoke(
>   {
>     messages: [
>       {
>         role: "user",
>         content: "Please tell me what's in your memory files.",
>       },
>     ],
>   },
>   { configurable: { thread_id: "12345" } },
> );
> ```
>
> > [card] [View example trace](https://smith.langchain.com/public/963e0d61-3d50-40cf-847a-474387d657b6/r)
> >
> > 为此示例打开一个公开的 LangSmith 运行。

> [tab] Filesystem
>
> ```ts Google theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> // Checkpointer is REQUIRED for human-in-the-loop
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "google:gemini-3.6-flash",
>   backend: new FilesystemBackend({ rootDir: "/Users/user/{project}" }),
>   memory: ["./AGENTS.md", "./.deepagents/AGENTS.md"],
>   interruptOn: {
>     read_file: true,
>     write_file: true,
>     delete_file: true,
>   },
>   checkpointer, // Required!
> });
> ```
>
> ```ts OpenAI theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> // Checkpointer is REQUIRED for human-in-the-loop
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "openai:gpt-5.5",
>   backend: new FilesystemBackend({ rootDir: "/Users/user/{project}" }),
>   memory: ["./AGENTS.md", "./.deepagents/AGENTS.md"],
>   interruptOn: {
>     read_file: true,
>     write_file: true,
>     delete_file: true,
>   },
>   checkpointer, // Required!
> });
> ```
>
> ```ts Anthropic theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> // Checkpointer is REQUIRED for human-in-the-loop
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "anthropic:claude-sonnet-5",
>   backend: new FilesystemBackend({ rootDir: "/Users/user/{project}" }),
>   memory: ["./AGENTS.md", "./.deepagents/AGENTS.md"],
>   interruptOn: {
>     read_file: true,
>     write_file: true,
>     delete_file: true,
>   },
>   checkpointer, // Required!
> });
> ```
>
> ```ts OpenRouter theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> // Checkpointer is REQUIRED for human-in-the-loop
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "openrouter:z-ai/glm-5.2",
>   backend: new FilesystemBackend({ rootDir: "/Users/user/{project}" }),
>   memory: ["./AGENTS.md", "./.deepagents/AGENTS.md"],
>   interruptOn: {
>     read_file: true,
>     write_file: true,
>     delete_file: true,
>   },
>   checkpointer, // Required!
> });
> ```
>
> ```ts Fireworks theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> // Checkpointer is REQUIRED for human-in-the-loop
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "fireworks:accounts/fireworks/models/glm-5p2",
>   backend: new FilesystemBackend({ rootDir: "/Users/user/{project}" }),
>   memory: ["./AGENTS.md", "./.deepagents/AGENTS.md"],
>   interruptOn: {
>     read_file: true,
>     write_file: true,
>     delete_file: true,
>   },
>   checkpointer, // Required!
> });
> ```
>
> ```ts Baseten theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> // Checkpointer is REQUIRED for human-in-the-loop
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "baseten:zai-org/GLM-5.2",
>   backend: new FilesystemBackend({ rootDir: "/Users/user/{project}" }),
>   memory: ["./AGENTS.md", "./.deepagents/AGENTS.md"],
>   interruptOn: {
>     read_file: true,
>     write_file: true,
>     delete_file: true,
>   },
>   checkpointer, // Required!
> });
> ```
>
> ```ts Ollama theme={null}
> import { createDeepAgent, FilesystemBackend } from "deepagents";
> import { MemorySaver } from "@langchain/langgraph";
>
> // Checkpointer is REQUIRED for human-in-the-loop
> const checkpointer = new MemorySaver();
>
> const agent = await createDeepAgent({
>   model: "ollama:north-mini-code-1.0",
>   backend: new FilesystemBackend({ rootDir: "/Users/user/{project}" }),
>   memory: ["./AGENTS.md", "./.deepagents/AGENTS.md"],
>   interruptOn: {
>     read_file: true,
>     write_file: true,
>     delete_file: true,
>   },
>   checkpointer, // Required!
> });
> ```

:::

:::python

## 配置文件

一个 [harness profile](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/profiles.md#链配置) 是一个可重用的每个模型配置的包，`create_deep_agent` 在选择匹配的模型时自动应用。当您希望行为遵循模型而不是调用位置时，配置文件是正确的工具，例如为 Claude 的指令风格调整的系统提示词后缀、为 GPT 重写的工具描述或仅在特定提供者中才有意义的额外中间件。

单个配置文件可以包含：自定义基础系统提示词 (`base_system_prompt`)、附加的后缀 (`system_prompt_suffix`)、工具描述覆盖、要排除的工具或中间件、要注入的额外中间件以及自动添加的通用子智能体的编辑。

```python theme={null}
from deepagents import HarnessProfile, register_harness_profile

# Append a system-prompt suffix whenever gpt-5.5 is selected.
register_harness_profile(
    "openai:gpt-5.5",
    HarnessProfile(system_prompt_suffix="Respond in under 100 words."),
)
```

有关注册密钥、合并语义和插件打包，请参阅 [Profiles](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/profiles.md)。一个更窄的配套 API，[provider profiles](https://langchain-docs-zh.mintlify.site/langchain/oss/deepagents/profiles.md#提供者配置文件)，为提供者打包模型构造参数（API 密钥、超时设置、重试设置）。

:::

## 结构化输出

深度智能体支持[结构化输出](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/structured-output.md)。
:::python
您可以通过将期望的结构化输出模式作为`response_format`参数传递给`create_deep_agent()`的调用来设置。
当模型生成结构化数据时，它会被捕获、验证，并返回在深度智能体状态的'structured\_response'键中。

```python theme={null}
import os
from typing import Literal

from pydantic import BaseModel, Field
from tavily import TavilyClient

from deepagents import create_deep_agent

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


def internet_search(
    query: str,
    max_results: int = 5,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = False,
):
    """Run a web search"""
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )


class WeatherReport(BaseModel):
    """A structured weather report with current conditions and forecast."""
    location: str = Field(description="The location for this weather report")
    temperature: float = Field(description="Current temperature in Celsius")
    condition: str = Field(
        description="Current weather condition (e.g., sunny, cloudy, rainy)"
    )
    humidity: int = Field(description="Humidity percentage")
    wind_speed: float = Field(description="Wind speed in km/h")
    forecast: str = Field(description="Brief forecast for the next 24 hours")


agent = create_deep_agent(
    model=model,
    response_format=WeatherReport,
    tools=[internet_search],
)

result = agent.invoke(
    {
        "messages": [
            {
                "role": "user",
                "content": "What's the weather like in San Francisco?",
            }
        ]
    }
)

print(result["structured_response"])
# location='San Francisco, California' temperature=18.3 condition='Sunny' humidity=48 wind_speed=7.6 forecast='Pleasant sunny conditions expected to continue with temperatures around 64°F (18°C) during the day, dropping to around 52°F (11°C) at night. Clear skies with minimal precipitation expected.'
```

> [card] [View example trace](https://smith.langchain.com/public/3b46bf48-9673-4de4-93a4-9621e7aa4fc7/r)
>
> 为此示例打开一个公开的 LangSmith 运行。

:::
:::js
您可以通过将期望的结构化输出模式作为`responseFormat`参数传递给`createDeepAgent()`的调用来设置。
将模式包装在`toolStrategy()`或`providerStrategy()`等策略中，这些策略来自`langchain`。
当模型生成结构化数据时，它会被捕获、验证，并返回在智能体状态的'structuredResponse'键中。

```ts theme={null}
import { tool, toolStrategy } 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: "Run a web search",
    schema: z.object({
      query: z.string().describe("The search query"),
      maxResults: z.number().optional().default(5),
      topic: z
        .enum(["general", "news", "finance"])
        .optional()
        .default("general"),
      includeRawContent: z.boolean().optional().default(false),
    }),
  },
);

const weatherReportSchema = z.object({
  location: z.string().describe("The location for this weather report"),
  temperature: z.number().describe("Current temperature in Celsius"),
  condition: z
    .string()
    .describe("Current weather condition (e.g., sunny, cloudy, rainy)"),
  humidity: z.number().describe("Humidity percentage"),
  windSpeed: z.number().describe("Wind speed in km/h"),
  forecast: z.string().describe("Brief forecast for the next 24 hours"),
});

const agent = await createDeepAgent({
  responseFormat: toolStrategy(weatherReportSchema),
  tools: [internetSearch],
});

const result = await agent.invoke({
  messages: [
    {
      role: "user",
      content: "What's the weather like in San Francisco?",
    },
  ],
});

console.log(result.structuredResponse);
// {
//   location: 'San Francisco, California',
//   temperature: 18.3,
//   condition: 'Sunny',
//   humidity: 48,
//   windSpeed: 7.6,
//   forecast: 'Clear skies with temperatures remaining mild. High of 18°C (64°F) during the day, dropping to around 11°C (52°F) at night.'
// }
```

> [card] [View example trace](https://smith.langchain.com/public/2f19229d-7862-4819-b022-a56e041b7220/r)
>
> 为此示例打开一个公开的 LangSmith 运行。

:::

有关更多信息及示例，请参阅[响应格式](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/structured-output.md#响应格式)。

## 高级

:::python

`create_deep_agent`在@\[`create_agent`]之上预组装了一个中间件栈。要构建一个完全自定义的智能体——选择要包含的确切功能——请参阅[配置 harness](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/agents.md#配置执行框架)。

:::

:::js

`createDeepAgent`在`createAgent`之上预组装了一个中间件栈。要构建一个完全自定义的智能体——选择要包含的确切功能——请参阅[配置 harness](https://langchain-docs-zh.mintlify.site/langchain/oss/langchain/agents.md#配置执行框架)。

:::

***

> 官方原文：[src/oss/deepagents/customization.mdx](https://github.com/langchain-ai/docs/blob/main/src/oss/deepagents/customization.mdx) · 非官方翻译，译文由 AI 生成，以英文原文为准。


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.