Deep Agents 中的上下文工程 | LangChain 中文文档

上下文工程是以正确的格式提供正确的信息和工具，让你的深度智能体能够可靠地完成任务。

深度智能体可以访问几种上下文。有些来源在启动时提供给智能体；另一些在运行时才可用，例如用户输入。深度智能体包含用于在长时间运行的会话中管理上下文的内置机制。

本页概述了你的深度智能体可以访问和管理的不同类型的上下文。

TIP

上下文工程是新手？请参阅概念概述了解不同类型的上下文以及何时使用它们。

上下文类型

上下文类型	你可以控制的内容	作用范围
输入上下文	启动时进入智能体提示词的内容（系统提示词、记忆、技能）	静态，每次运行都应用
运行时上下文	调用时传入的静态配置（用户元数据、API 密钥、连接）	每次运行，传播到子智能体
上下文压缩	内置卸载和摘要，使上下文保持在窗口限制内	自动，接近限制时
上下文隔离	使用子智能体隔离繁重工作，只将结果返回给主智能体	每个子智能体，委派时
长期记忆	使用虚拟文件系统跨线程持久化存储	跨对话持久化

输入上下文

输入上下文是在启动时提供给深度智能体的信息，它会成为系统提示词的一部分。最终提示词由几个来源组成：

系统提示词 — 你提供的自定义指令加上内置的智能体指导。
记忆 — 配置后始终加载的持久化 AGENTS.md 文件。
技能 — 相关时按需加载的能力（渐进式披露）。
工具提示词 — 使用内置工具或自定义工具的说明。

系统提示词

你的自定义系统提示词会被前置到内置系统提示词之前，内置系统提示词包含文件系统工具和子智能体的指导。使用它来定义智能体的角色、行为和知识：

python

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    system_prompt=(
        "You are a research assistant specializing in scientific literature. "
        "Always cite sources. Use subagents for parallel research on different topics."
    ),
)

python

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="openai:gpt-5.5",
    system_prompt=(
        "You are a research assistant specializing in scientific literature. "
        "Always cite sources. Use subagents for parallel research on different topics."
    ),
)

python

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    system_prompt=(
        "You are a research assistant specializing in scientific literature. "
        "Always cite sources. Use subagents for parallel research on different topics."
    ),
)

python

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    system_prompt=(
        "You are a research assistant specializing in scientific literature. "
        "Always cite sources. Use subagents for parallel research on different topics."
    ),
)

python

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    system_prompt=(
        "You are a research assistant specializing in scientific literature. "
        "Always cite sources. Use subagents for parallel research on different topics."
    ),
)

python

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    system_prompt=(
        "You are a research assistant specializing in scientific literature. "
        "Always cite sources. Use subagents for parallel research on different topics."
    ),
)

python

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    system_prompt=(
        "You are a research assistant specializing in scientific literature. "
        "Always cite sources. Use subagents for parallel research on different topics."
    ),
)

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  systemPrompt: `You are a research assistant specializing in scientific literature.
  Always cite sources. Use subagents for parallel research on different topics.`,
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "openai:gpt-5.5",
  systemPrompt: `You are a research assistant specializing in scientific literature.
  Always cite sources. Use subagents for parallel research on different topics.`,
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  systemPrompt: `You are a research assistant specializing in scientific literature.
  Always cite sources. Use subagents for parallel research on different topics.`,
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  systemPrompt: `You are a research assistant specializing in scientific literature.
  Always cite sources. Use subagents for parallel research on different topics.`,
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  systemPrompt: `You are a research assistant specializing in scientific literature.
  Always cite sources. Use subagents for parallel research on different topics.`,
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  systemPrompt: `You are a research assistant specializing in scientific literature.
  Always cite sources. Use subagents for parallel research on different topics.`,
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  systemPrompt: `You are a research assistant specializing in scientific literature.
  Always cite sources. Use subagents for parallel research on different topics.`,
});

system_prompt 参数是静态的，这意味着它不会随每次调用而变化。对于某些用例，你可能需要动态提示词：例如，告诉模型“你有管理员权限”与“你只有只读权限”，或者从长期记忆注入用户偏好，如“用户更喜欢简洁的回复”。如果你的提示词依赖上下文或 runtime.store，请使用 @dynamic_prompt 构建上下文感知的指令。你的中间件可以读取 request.runtime.context 和 request.runtime.store。参见定制了解默认中间件栈以及添加自定义中间件。示例请参阅 LangChain 上下文工程指南。

当只有工具使用上下文或 runtime.store 时，你不需要中间件；工具直接接收 ToolRuntime 对象（包括 runtime.context 和 runtime.store）。只有在工具应与系统提示词的更新打包在一起时，才添加中间件。

systemPrompt 参数是静态的，这意味着它不会随每次调用而变化。对于某些用例，你可能需要动态提示词：例如，告诉模型“你有管理员权限”与“你只有只读权限”，或者从长期记忆注入用户偏好，如“用户更喜欢简洁的回复”。如果你的提示词依赖上下文或 runtime.store，请使用 dynamicSystemPromptMiddleware 构建上下文感知的指令。你的中间件可以读取 request.runtime.context 和 request.runtime.store。参见定制了解默认中间件栈以及添加自定义中间件。示例请参阅 LangChain 上下文工程指南。

当只有工具使用上下文或 runtime.store 时，你不需要中间件；工具直接接收 runtime 对象（包括 runtime.context 和 runtime.store）。只有当系统提示词本身必须随每个请求变化时，才添加中间件。

TIP

要为特定提供商或模型调整汇编后的系统提示词，请使用 harness 配置档案：base_system_prompt 直接替换基础提示词，system_prompt_suffix 附加在其后。

记忆

记忆文件（AGENTS.md）提供始终加载到系统提示词中的持久化上下文。使用记忆来存放应适用于每个对话的项目约定、用户偏好和关键指南：

python

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    memory=["/project/AGENTS.md", "~/.deepagents/preferences.md"],
)

python

agent = create_deep_agent(
    model="openai:gpt-5.5",
    memory=["/project/AGENTS.md", "~/.deepagents/preferences.md"],
)

python

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    memory=["/project/AGENTS.md", "~/.deepagents/preferences.md"],
)

python

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    memory=["/project/AGENTS.md", "~/.deepagents/preferences.md"],
)

python

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    memory=["/project/AGENTS.md", "~/.deepagents/preferences.md"],
)

python

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    memory=["/project/AGENTS.md", "~/.deepagents/preferences.md"],
)

python

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    memory=["/project/AGENTS.md", "~/.deepagents/preferences.md"],
)

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  memory: ["/project/AGENTS.md", "~/.deepagents/preferences.md"],
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "openai:gpt-5.5",
  memory: ["/project/AGENTS.md", "~/.deepagents/preferences.md"],
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  memory: ["/project/AGENTS.md", "~/.deepagents/preferences.md"],
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  memory: ["/project/AGENTS.md", "~/.deepagents/preferences.md"],
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  memory: ["/project/AGENTS.md", "~/.deepagents/preferences.md"],
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  memory: ["/project/AGENTS.md", "~/.deepagents/preferences.md"],
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  memory: ["/project/AGENTS.md", "~/.deepagents/preferences.md"],
});

与技能不同，记忆总是被注入——没有渐进式披露。保持记忆最小化以避免上下文过载；使用技能存放详细的工作流和领域特定内容。参见记忆了解配置详情。

技能

技能提供按需能力。智能体在启动时读取每个 SKILL.md 的 frontmatter，然后仅在确定技能相关时加载完整的技能内容。这降低了 token 使用量，同时仍然提供专业化工作流：

python

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    skills=["/skills/research/", "/skills/web-search/"],
)

python

agent = create_deep_agent(
    model="openai:gpt-5.5",
    skills=["/skills/research/", "/skills/web-search/"],
)

python

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    skills=["/skills/research/", "/skills/web-search/"],
)

python

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    skills=["/skills/research/", "/skills/web-search/"],
)

python

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    skills=["/skills/research/", "/skills/web-search/"],
)

python

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    skills=["/skills/research/", "/skills/web-search/"],
)

python

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    skills=["/skills/research/", "/skills/web-search/"],
)

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  skills: ["/skills/research/", "/skills/web-search/"],
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "openai:gpt-5.5",
  skills: ["/skills/research/", "/skills/web-search/"],
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  skills: ["/skills/research/", "/skills/web-search/"],
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  skills: ["/skills/research/", "/skills/web-search/"],
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  skills: ["/skills/research/", "/skills/web-search/"],
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  skills: ["/skills/research/", "/skills/web-search/"],
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  skills: ["/skills/research/", "/skills/web-search/"],
});

保持每个技能专注于单一工作流或领域；宽泛或重叠的技能会稀释相关性，并在加载时膨胀上下文。在技能内部，保持主要内容简洁，并将详细参考材料移到技能文件中引用的单独文件。将始终相关的约定放在记忆中。参见技能了解编写和配置。

工具提示词

工具提示词是塑造模型如何使用工具的说明。所有工具都暴露模型在提示词中看到的元数据——通常是模式和描述。你通过 tools 参数传入的工具会将该工具元数据（模式和描述）呈现给模型。深度智能体的内置工具打包在默认中间件栈中，通常还会用这些工具的更多指导更新系统提示词。

内置工具：添加 harness 能力（文件系统、子智能体和可选的规划）的中间件会自动将工具特定指令附加到系统提示词，创建解释如何有效使用这些工具的工具提示词。参见定制获取完整列表：

文件系统提示词——ls、read_file、write_file、edit_file、delete、glob、grep 的文档（以及使用沙箱后端时的 execute）
文件系统提示词——ls、read_file、write_file、edit_file、glob、grep 的文档（以及使用沙箱后端时的 execute）
子智能体提示词——使用 task 工具委派工作的指导
人在回路提示词——在指定工具调用处暂停的用法（当设置了 interrupt_on 时）
本地上下文提示词——当前目录和项目信息（仅 CLI）

你提供的工具：通过 tools 参数传入的工具会将其描述（来自工具模式）发送给模型。你还可以添加自定义中间件来添加工具并附加自己的系统提示词说明。

对于你提供的工具，请确保提供清晰的名称、描述和参数描述。这些指导模型推理何时以及如何使用该工具。在描述中包含_何时_使用该工具，并描述每个参数的作用。

python

from langchain.tools import tool

@tool(parse_docstring=True)
def search_orders(
    user_id: str,
    status: str,
    limit: int = 10,
) -> str:
    """Search for user orders by status.

    Use this when the user asks about order history or wants to check
    order status. Always filter by the provided status.

    Args:
        user_id: Unique identifier for the user
        status: Order status: 'pending', 'shipped', or 'delivered'
        limit: Maximum number of results to return
    """
    # Implementation here
    return f"orders for {user_id} with status {status} (limit {limit})"

import { tool } from "langchain";
import * as z from "zod";

const searchOrders = tool(
  async ({ userId, status, limit }) =>
    `orders for ${userId} with status ${status} (limit ${limit})`,
  {
    name: "search_orders",
    description: `Search for user orders by status.

Use this when the user asks about order history or wants to check
order status. Always filter by the provided status.`,
    schema: z.object({
      userId: z.string().describe("Unique identifier for the user"),
      status: z
        .enum(["pending", "shipped", "delivered"])
        .describe("Order status to filter by"),
      limit: z
        .number()
        .default(10)
        .describe("Maximum number of results to return"),
    }),
  },
);

TIP

要为特定提供商或模型覆盖内置或用户提供的工具描述，请使用 harness 配置档案的 tool_description_overrides，按工具名称键控。

未使用的内置工具仍会在每一轮发送其完整模式。使用 excluded_tools 移除智能体绝不应调用的工具（例如只读智能体上的 write_file 或 execute）。这会缩小整个运行的基础提示词大小。这是配置，不是上下文压缩中的自动卸载或摘要。

参见 Harness 配置档案和不使用默认文件系统工具运行。

参见概述了解内置能力，定制了解直接传入工具。

完整系统提示词

深度智能体的系统消息——模型在运行开始时收到的汇编系统提示词——由以下部分组成：

自定义 system_prompt（如果提供）
基础智能体提示词
记忆提示词：AGENTS.md + 记忆使用指南（仅在提供 memory 时）
技能提示词：技能位置 + 带 frontmatter 信息的技能列表 + 用法（仅在提供技能时）
虚拟文件系统提示词（适用时文件系统 + execute 工具文档）
子智能体提示词：任务工具用法
用户提供的中间件提示词（如果提供了自定义中间件）
人在回路提示词（设置了 interrupt_on 时）

运行时上下文

运行时上下文是你调用智能体时传入的每次运行配置。它不会自动包含在模型提示词中；模型只会在工具、中间件或其他逻辑读取它并将其添加到消息或系统提示词时看到它。将运行时上下文用于用户元数据（ID、偏好、角色）、API 密钥、数据库连接、功能开关，或你的工具和 harness 需要的其他值。

使用 context_schema 定义该数据的形状：使用 dataclasses.dataclass 或 typing.TypedDict 类。使用传给 invoke / ainvoke 的 context 参数传入值。完整详情请参阅运行时和LangGraph 运行时上下文。

在工具内部，从注入的 ToolRuntime 中读取上下文：

python

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.tools import ToolRuntime, tool

@dataclass
class Context:
    user_id: str
    api_key: str

@tool
def fetch_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """Fetch data for the current user."""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    tools=[fetch_user_data],
    context_schema=Context,
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Get my recent activity"}]},
    context=Context(user_id="user-123", api_key="sk-..."),
)

python

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.tools import ToolRuntime, tool

@dataclass
class Context:
    user_id: str
    api_key: str

@tool
def fetch_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """Fetch data for the current user."""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"

agent = create_deep_agent(
    model="openai:gpt-5.5",
    tools=[fetch_user_data],
    context_schema=Context,
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Get my recent activity"}]},
    context=Context(user_id="user-123", api_key="sk-..."),
)

python

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.tools import ToolRuntime, tool

@dataclass
class Context:
    user_id: str
    api_key: str

@tool
def fetch_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """Fetch data for the current user."""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    tools=[fetch_user_data],
    context_schema=Context,
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Get my recent activity"}]},
    context=Context(user_id="user-123", api_key="sk-..."),
)

python

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.tools import ToolRuntime, tool

@dataclass
class Context:
    user_id: str
    api_key: str

@tool
def fetch_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """Fetch data for the current user."""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    tools=[fetch_user_data],
    context_schema=Context,
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Get my recent activity"}]},
    context=Context(user_id="user-123", api_key="sk-..."),
)

python

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.tools import ToolRuntime, tool

@dataclass
class Context:
    user_id: str
    api_key: str

@tool
def fetch_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """Fetch data for the current user."""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"

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

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Get my recent activity"}]},
    context=Context(user_id="user-123", api_key="sk-..."),
)

python

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.tools import ToolRuntime, tool

@dataclass
class Context:
    user_id: str
    api_key: str

@tool
def fetch_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """Fetch data for the current user."""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    tools=[fetch_user_data],
    context_schema=Context,
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Get my recent activity"}]},
    context=Context(user_id="user-123", api_key="sk-..."),
)

python

from dataclasses import dataclass

from deepagents import create_deep_agent
from langchain.tools import ToolRuntime, tool

@dataclass
class Context:
    user_id: str
    api_key: str

@tool
def fetch_user_data(query: str, runtime: ToolRuntime[Context]) -> str:
    """Fetch data for the current user."""
    user_id = runtime.context.user_id
    return f"Data for user {user_id}: {query}"

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    tools=[fetch_user_data],
    context_schema=Context,
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Get my recent activity"}]},
    context=Context(user_id="user-123", api_key="sk-..."),
)

使用 contextSchema 定义该数据的形状，通常是一个 Zod 对象模式（例如 z.object({ ... })）。在传给 invoke / ainvoke 的选项对象的 context 字段中传入运行时值。完整详情请参阅运行时和LangGraph 运行时上下文。

在工具内部，从作为工具处理程序的 runtime 参数提供的 ToolRuntime 实例中读取 runtime.context：

import { createDeepAgent } from "deepagents";
import { tool } from "langchain";
import type { ToolRuntime } from "@langchain/core/tools";
import * as z from "zod";

const contextSchema = z.object({
  userId: z.string(),
  apiKey: z.string(),
});

const fetchUserData = tool(
  async (input, runtime: ToolRuntime<unknown, typeof contextSchema>) => {
    const userId = runtime.context?.userId;
    return `Data for user ${userId}: ${input.query}`;
  },
  {
    name: "fetch_user_data",
    description: "Fetch data for the current user",
    schema: z.object({ query: z.string() }),
  },
);

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

const result = await agent.invoke(
  { messages: [{ role: "user", content: "Get my recent activity" }] },
  { context: { userId: "user-123", apiKey: "sk-..." } },
);

import { createDeepAgent } from "deepagents";
import { tool } from "langchain";
import type { ToolRuntime } from "@langchain/core/tools";
import * as z from "zod";

const contextSchema = z.object({
  userId: z.string(),
  apiKey: z.string(),
});

const fetchUserData = tool(
  async (input, runtime: ToolRuntime<unknown, typeof contextSchema>) => {
    const userId = runtime.context?.userId;
    return `Data for user ${userId}: ${input.query}`;
  },
  {
    name: "fetch_user_data",
    description: "Fetch data for the current user",
    schema: z.object({ query: z.string() }),
  },
);

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

const result = await agent.invoke(
  { messages: [{ role: "user", content: "Get my recent activity" }] },
  { context: { userId: "user-123", apiKey: "sk-..." } },
);

import { createDeepAgent } from "deepagents";
import { tool } from "langchain";
import type { ToolRuntime } from "@langchain/core/tools";
import * as z from "zod";

const contextSchema = z.object({
  userId: z.string(),
  apiKey: z.string(),
});

const fetchUserData = tool(
  async (input, runtime: ToolRuntime<unknown, typeof contextSchema>) => {
    const userId = runtime.context?.userId;
    return `Data for user ${userId}: ${input.query}`;
  },
  {
    name: "fetch_user_data",
    description: "Fetch data for the current user",
    schema: z.object({ query: z.string() }),
  },
);

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  tools: [fetchUserData],
  contextSchema,
});

const result = await agent.invoke(
  { messages: [{ role: "user", content: "Get my recent activity" }] },
  { context: { userId: "user-123", apiKey: "sk-..." } },
);

import { createDeepAgent } from "deepagents";
import { tool } from "langchain";
import type { ToolRuntime } from "@langchain/core/tools";
import * as z from "zod";

const contextSchema = z.object({
  userId: z.string(),
  apiKey: z.string(),
});

const fetchUserData = tool(
  async (input, runtime: ToolRuntime<unknown, typeof contextSchema>) => {
    const userId = runtime.context?.userId;
    return `Data for user ${userId}: ${input.query}`;
  },
  {
    name: "fetch_user_data",
    description: "Fetch data for the current user",
    schema: z.object({ query: z.string() }),
  },
);

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

const result = await agent.invoke(
  { messages: [{ role: "user", content: "Get my recent activity" }] },
  { context: { userId: "user-123", apiKey: "sk-..." } },
);

import { createDeepAgent } from "deepagents";
import { tool } from "langchain";
import type { ToolRuntime } from "@langchain/core/tools";
import * as z from "zod";

const contextSchema = z.object({
  userId: z.string(),
  apiKey: z.string(),
});

const fetchUserData = tool(
  async (input, runtime: ToolRuntime<unknown, typeof contextSchema>) => {
    const userId = runtime.context?.userId;
    return `Data for user ${userId}: ${input.query}`;
  },
  {
    name: "fetch_user_data",
    description: "Fetch data for the current user",
    schema: z.object({ query: z.string() }),
  },
);

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

const result = await agent.invoke(
  { messages: [{ role: "user", content: "Get my recent activity" }] },
  { context: { userId: "user-123", apiKey: "sk-..." } },
);

import { createDeepAgent } from "deepagents";
import { tool } from "langchain";
import type { ToolRuntime } from "@langchain/core/tools";
import * as z from "zod";

const contextSchema = z.object({
  userId: z.string(),
  apiKey: z.string(),
});

const fetchUserData = tool(
  async (input, runtime: ToolRuntime<unknown, typeof contextSchema>) => {
    const userId = runtime.context?.userId;
    return `Data for user ${userId}: ${input.query}`;
  },
  {
    name: "fetch_user_data",
    description: "Fetch data for the current user",
    schema: z.object({ query: z.string() }),
  },
);

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

const result = await agent.invoke(
  { messages: [{ role: "user", content: "Get my recent activity" }] },
  { context: { userId: "user-123", apiKey: "sk-..." } },
);

import { createDeepAgent } from "deepagents";
import { tool } from "langchain";
import type { ToolRuntime } from "@langchain/core/tools";
import * as z from "zod";

const contextSchema = z.object({
  userId: z.string(),
  apiKey: z.string(),
});

const fetchUserData = tool(
  async (input, runtime: ToolRuntime<unknown, typeof contextSchema>) => {
    const userId = runtime.context?.userId;
    return `Data for user ${userId}: ${input.query}`;
  },
  {
    name: "fetch_user_data",
    description: "Fetch data for the current user",
    schema: z.object({ query: z.string() }),
  },
);

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

const result = await agent.invoke(
  { messages: [{ role: "user", content: "Get my recent activity" }] },
  { context: { userId: "user-123", apiKey: "sk-..." } },
);

运行时上下文会传播到所有子智能体。当子智能体运行时，它接收与父智能体相同的运行时上下文。有关每个子智能体的上下文（命名空间键），请参阅子智能体。

自定义状态模式

INFO

自定义状态模式需要 deepagents>=0.6.6。

当你的智能体或中间件需要跟踪必须在完整智能体生命周期内持久化并在检查点中存活的的数据时，请使用自定义状态模式。自定义状态让你可以：

跨完整运行跟踪状态：维护在模型调用和工具调用之间存活的计数器、标志或累加值
在工具和中间件之间共享数据：工具可以将值写入状态，中间件钩子可以读取它，反之亦然
实现横切关注点：添加速率限制、用量跟踪或审计日志等功能，无需修改核心智能体逻辑
在调用时传入初始值：在每次运行开始时播种状态字段，然后让智能体在执行期间更新它们

当数据必须是智能体可变图状态的一部分、随线程进行检查点持久化或通过 runtime.state 可用时，请使用 state_schema。对于用户 ID、凭据或功能开关等不可变的每次运行输入，请优先使用运行时上下文。

自定义状态模式必须继承 DeepAgentState。这会保留 messages 上的内置 DeltaChannel 缩减器，随着对话变长使检查点增长保持线性。

python

from deepagents import DeepAgentState, create_deep_agent
from langchain.tools import ToolRuntime, tool

class ResearchState(DeepAgentState):
    page_url: str
    file_urls: list[str]

@tool
def cite_page(runtime: ToolRuntime) -> str:
    """Return the current page URL."""
    return runtime.state["page_url"]

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    tools=[cite_page],
    state_schema=ResearchState,
)

result = agent.invoke(
    {
        "messages": [{"role": "user", "content": "Cite the current page"}],
        "page_url": "https://example.com/report",
        "file_urls": [],
    },
)

python

from deepagents import DeepAgentState, create_deep_agent
from langchain.tools import ToolRuntime, tool

class ResearchState(DeepAgentState):
    page_url: str
    file_urls: list[str]

@tool
def cite_page(runtime: ToolRuntime) -> str:
    """Return the current page URL."""
    return runtime.state["page_url"]

agent = create_deep_agent(
    model="openai:gpt-5.5",
    tools=[cite_page],
    state_schema=ResearchState,
)

result = agent.invoke(
    {
        "messages": [{"role": "user", "content": "Cite the current page"}],
        "page_url": "https://example.com/report",
        "file_urls": [],
    },
)

python

from deepagents import DeepAgentState, create_deep_agent
from langchain.tools import ToolRuntime, tool

class ResearchState(DeepAgentState):
    page_url: str
    file_urls: list[str]

@tool
def cite_page(runtime: ToolRuntime) -> str:
    """Return the current page URL."""
    return runtime.state["page_url"]

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    tools=[cite_page],
    state_schema=ResearchState,
)

result = agent.invoke(
    {
        "messages": [{"role": "user", "content": "Cite the current page"}],
        "page_url": "https://example.com/report",
        "file_urls": [],
    },
)

python

from deepagents import DeepAgentState, create_deep_agent
from langchain.tools import ToolRuntime, tool

class ResearchState(DeepAgentState):
    page_url: str
    file_urls: list[str]

@tool
def cite_page(runtime: ToolRuntime) -> str:
    """Return the current page URL."""
    return runtime.state["page_url"]

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    tools=[cite_page],
    state_schema=ResearchState,
)

result = agent.invoke(
    {
        "messages": [{"role": "user", "content": "Cite the current page"}],
        "page_url": "https://example.com/report",
        "file_urls": [],
    },
)

python

from deepagents import DeepAgentState, create_deep_agent
from langchain.tools import ToolRuntime, tool

class ResearchState(DeepAgentState):
    page_url: str
    file_urls: list[str]

@tool
def cite_page(runtime: ToolRuntime) -> str:
    """Return the current page URL."""
    return runtime.state["page_url"]

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

result = agent.invoke(
    {
        "messages": [{"role": "user", "content": "Cite the current page"}],
        "page_url": "https://example.com/report",
        "file_urls": [],
    },
)

python

from deepagents import DeepAgentState, create_deep_agent
from langchain.tools import ToolRuntime, tool

class ResearchState(DeepAgentState):
    page_url: str
    file_urls: list[str]

@tool
def cite_page(runtime: ToolRuntime) -> str:
    """Return the current page URL."""
    return runtime.state["page_url"]

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    tools=[cite_page],
    state_schema=ResearchState,
)

result = agent.invoke(
    {
        "messages": [{"role": "user", "content": "Cite the current page"}],
        "page_url": "https://example.com/report",
        "file_urls": [],
    },
)

python

from deepagents import DeepAgentState, create_deep_agent
from langchain.tools import ToolRuntime, tool

class ResearchState(DeepAgentState):
    page_url: str
    file_urls: list[str]

@tool
def cite_page(runtime: ToolRuntime) -> str:
    """Return the current page URL."""
    return runtime.state["page_url"]

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    tools=[cite_page],
    state_schema=ResearchState,
)

result = agent.invoke(
    {
        "messages": [{"role": "user", "content": "Cite the current page"}],
        "page_url": "https://example.com/report",
        "file_urls": [],
    },
)

该模式会与中间件贡献的状态模式合并。当 Deep Agents 为 task 工具编译声明式 SubAgent 规范时，传给 subagents= 的规范会继承父级的 state_schema。CompiledSubAgent runnable 和远程 AsyncSubAgent 规范不会继承它，因为它们的图已经编译或单独托管。如果它们需要相同的状态字段，请使用兼容模式编译这些图。

上下文压缩

每次 create_deep_agent 调用都包含内置的上下文压缩。你不需要为卸载或摘要工作添加中间件。

长时间运行的任务会产生大型工具输出和很长的对话历史。上下文压缩会缩小智能体工作记忆中信息的大小，同时保留与任务相关的细节。以下技术是确保传给 LLM 的上下文保持在其上下文窗口限制内的内置机制：

卸载 — 大型工具输入和结果存储在文件系统中，并用引用替换。
摘要 — 接近限制时，旧消息被压缩成 LLM 生成的摘要。

要在压缩运行之前缩小每一轮发送的工具模式，请通过 harness 配置档案（excluded_tools）排除未使用的内置工具。参见工具提示词。

卸载

Deep Agents 使用内置文件系统工具自动卸载内容，并按需搜索和检索已卸载的内容。当工具调用输入或结果超过 token 阈值（默认 20,000）时会发生内容卸载：

工具调用输入超过 20,000 tokens：文件写入和编辑操作会在智能体的对话历史中留下包含完整文件内容的工具调用。由于此内容已经持久化到文件系统，它通常是多余的。当会话上下文越过模型可用窗口的 85% 时，深度智能体会截断较旧的工具调用，用指向磁盘上文件的指针替换它们，并缩小活动上下文的大小。
工具调用结果超过 20,000 tokens：发生这种情况时，深度智能体会将响应卸载到配置的后端，并用文件路径引用和结果前 10 行的预览替换它。然后智能体可以根据需要重新读取或搜索内容。

INFO

内置上下文压缩不会调整图像大小、降低图像分辨率或生成视觉嵌入。有关多模态输入、工具输出以及压缩如何与媒体交互，请参阅多模态。

摘要

INFO

当前摘要行为（通过 wrapModelCall 进行模型内摘要、精确 token 计数以及自动 ContextOverflowError 回退）需要 deepagents>=1.6.0。

每次 create_deep_agent 调用都在默认中间件栈中包含 SummarizationMiddleware。当上下文大小越过模型的上下文窗口限制（例如 max_input_tokens 的 85%）且没有更多符合卸载条件的上下文时，深度智能体会自动摘要消息历史。

此过程有两个组成部分：

上下文内摘要：LLM 生成对话的结构化摘要，包括会话意图、创建的产品和下一步——它替换智能体工作记忆中的完整对话历史。
文件系统保存：原始对话消息的文本渲染被写入文件系统作为权威记录。

这种双重方法确保智能体保持对其目标和进展的认识（通过摘要），同时在需要时保留恢复文本细节的能力（通过文件系统搜索）。

An example of summarization showing an agent's conversation history, where several steps get compacted

配置：

在其模型配置档案的模型 max_input_tokens 的 85% 处触发
保留 10% 的 token 作为近期上下文
如果模型配置档案不可用，回退到 170,000-token 触发点 / 保留 6 条消息
如果任何模型调用引发标准 ContextOverflowError，深度智能体会立即回退到摘要，并使用摘要 + 保留的近期消息重试
较旧的消息由模型进行摘要

TIP

来自智能体的流式 token通常包含摘要步骤生成的 token。你可以使用它们关联的元数据过滤掉这些 token：

python

for chunk in agent.stream(
    {"messages": [...]},
    stream_mode="messages",
    version="v2",
):
    token, metadata = chunk["data"]
    if metadata.get("lc_source") == "summarization":  
        continue
    else:
        ...

TIP

来自智能体的流式 token通常包含摘要步骤生成的 token。你可以使用它们关联的元数据过滤掉这些 token：

typescript

for await (const [namespace, chunk] of await agent.stream(
  { messages: [...] },
  { streamMode: "messages" },
)) {
  const [message, metadata] = chunk;
  if (metadata?.lcSource === "summarization") {  
    continue;
  } else {
    ...
  }
}

按需压缩工具

默认情况下，自动摘要会在达到上下文阈值时运行。此外，你可以给智能体一个 compact_conversation 工具，以便它可以按需触发压缩，例如在任务之间，而不是等待 85% 阈值。

通过在 create_deep_agent 上使用 middleware 参数传入 create_summarization_tool_middleware 来启用该工具。自定义中间件会在 PatchToolCallsMiddleware 之后插入到默认栈中：

python

from deepagents import create_deep_agent
from deepagents.backends import StateBackend
from deepagents.middleware.summarization import create_summarization_tool_middleware

backend = StateBackend  # if using default backend

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

python

from deepagents import create_deep_agent
from deepagents.backends import StateBackend
from deepagents.middleware.summarization import create_summarization_tool_middleware

backend = StateBackend  # if using default backend

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

python

from deepagents import create_deep_agent
from deepagents.backends import StateBackend
from deepagents.middleware.summarization import create_summarization_tool_middleware

backend = StateBackend  # if using default backend

model="anthropic:claude-sonnet-4-6"
agent = create_deep_agent(
    model=model,
    middleware=[  
        create_summarization_tool_middleware(model, backend),  
    ],  
)

python

from deepagents import create_deep_agent
from deepagents.backends import StateBackend
from deepagents.middleware.summarization import create_summarization_tool_middleware

backend = StateBackend  # if using default backend

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

python

from deepagents import create_deep_agent
from deepagents.backends import StateBackend
from deepagents.middleware.summarization import create_summarization_tool_middleware

backend = StateBackend  # if using default backend

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

python

from deepagents import create_deep_agent
from deepagents.backends import StateBackend
from deepagents.middleware.summarization import create_summarization_tool_middleware

backend = StateBackend  # if using default backend

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

python

from deepagents import create_deep_agent
from deepagents.backends import StateBackend
from deepagents.middleware.summarization import create_summarization_tool_middleware

backend = StateBackend  # if using default backend

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

添加压缩工具不会禁用模型上下文限制 85% 处的自动摘要。两者共享相同的摘要引擎和状态。

详情请参阅 API 参考中的 SummarizationToolMiddleware 和 create_summarization_tool_middleware。

使用子智能体进行上下文隔离

子智能体解决上下文膨胀问题。当主智能体使用输出量很大的工具（网络搜索、文件读取、数据库查询）时，上下文窗口会很快填满。子智能体隔离了这项工作——主智能体只接收最终结果，而不是产生该结果的数十次工具调用。你还可以独立于主智能体配置每个子智能体（例如，模型、工具、系统提示词和技能）。

工作原理：

主智能体有一个 task 工具来委派工作
子智能体使用自己全新的上下文运行
子智能体自主执行直到完成
子智能体向主智能体返回一份最终报告
主智能体的上下文保持干净

最佳实践：

委派复杂任务：对会弄乱主智能体上下文的多步骤工作使用子智能体。
保持子智能体响应简洁：指示子智能体返回摘要而不是原始数据：

python

research_subagent = {
"name": "researcher",
"description": "Conducts research on a topic",
"system_prompt": """You are a research assistant.
IMPORTANT: Return only the essential summary (under 500 words).
Do NOT include raw search results or detailed tool outputs.""",
"tools": [web_search],
}

const researchSubagent = {
name: "researcher",
description: "Conducts research on a topic",
systemPrompt: `You are a research assistant.
IMPORTANT: Return only the essential summary (under 500 words).
Do NOT include raw search results or detailed tool outputs.`,
tools: [webSearch],
};

对大文件数据使用文件系统：子智能体可以将结果写入文件；主智能体读取它需要的内容。

参见子智能体了解配置，上下文管理了解运行时上下文传播和每个子智能体的命名空间。

长期记忆

使用默认文件系统时，你的深度智能体将其工作记忆文件存储在智能体状态中，这些文件只会在单个线程内持久化。长期记忆使你的深度智能体能够跨不同线程和对话持久化信息。深度智能体可以使用长期记忆存储用户偏好、累积的知识、研究进展或任何应在单次会话之外持久化的信息。

要使用长期记忆，你必须使用 CompositeBackend，它将特定路径（通常是 /memories/）路由到 LangGraph Store，后者提供持久的跨线程持久化。 CompositeBackend 是一种混合存储系统，其中一些文件无限期保留，而另一些则限制在单个线程内。

python

from deepagents import create_deep_agent
from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
from langgraph.store.memory import InMemoryStore

store = InMemoryStore()

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    store=store,
    backend=CompositeBackend(
        default=StateBackend(),
        routes={
            "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
        },
    ),
    system_prompt="""When users tell you their preferences, save them to
    /memories/user_preferences.txt so you remember them in future conversations.""",
)

python

from deepagents import create_deep_agent
from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
from langgraph.store.memory import InMemoryStore

store = InMemoryStore()

agent = create_deep_agent(
    model="openai:gpt-5.5",
    store=store,
    backend=CompositeBackend(
        default=StateBackend(),
        routes={
            "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
        },
    ),
    system_prompt="""When users tell you their preferences, save them to
    /memories/user_preferences.txt so you remember them in future conversations.""",
)

python

from deepagents import create_deep_agent
from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
from langgraph.store.memory import InMemoryStore

store = InMemoryStore()

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    store=store,
    backend=CompositeBackend(
        default=StateBackend(),
        routes={
            "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
        },
    ),
    system_prompt="""When users tell you their preferences, save them to
    /memories/user_preferences.txt so you remember them in future conversations.""",
)

python

from deepagents import create_deep_agent
from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
from langgraph.store.memory import InMemoryStore

store = InMemoryStore()

agent = create_deep_agent(
    model="openrouter:z-ai/glm-5.2",
    store=store,
    backend=CompositeBackend(
        default=StateBackend(),
        routes={
            "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
        },
    ),
    system_prompt="""When users tell you their preferences, save them to
    /memories/user_preferences.txt so you remember them in future conversations.""",
)

python

from deepagents import create_deep_agent
from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
from langgraph.store.memory import InMemoryStore

store = InMemoryStore()

agent = create_deep_agent(
    model="fireworks:accounts/fireworks/models/glm-5p2",
    store=store,
    backend=CompositeBackend(
        default=StateBackend(),
        routes={
            "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
        },
    ),
    system_prompt="""When users tell you their preferences, save them to
    /memories/user_preferences.txt so you remember them in future conversations.""",
)

python

from deepagents import create_deep_agent
from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
from langgraph.store.memory import InMemoryStore

store = InMemoryStore()

agent = create_deep_agent(
    model="baseten:zai-org/GLM-5.2",
    store=store,
    backend=CompositeBackend(
        default=StateBackend(),
        routes={
            "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
        },
    ),
    system_prompt="""When users tell you their preferences, save them to
    /memories/user_preferences.txt so you remember them in future conversations.""",
)

python

from deepagents import create_deep_agent
from deepagents.backends import CompositeBackend, StateBackend, StoreBackend
from langgraph.store.memory import InMemoryStore

store = InMemoryStore()

agent = create_deep_agent(
    model="ollama:north-mini-code-1.0",
    store=store,
    backend=CompositeBackend(
        default=StateBackend(),
        routes={
            "/memories/": StoreBackend(namespace=lambda _rt: ("memories",)),
        },
    ),
    system_prompt="""When users tell you their preferences, save them to
    /memories/user_preferences.txt so you remember them in future conversations.""",
)

import {
  CompositeBackend,
  createDeepAgent,
  StateBackend,
  StoreBackend,
} from "deepagents";
import { InMemoryStore } from "@langchain/langgraph";

const agent = await createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  store: new InMemoryStore(),
  backend: new CompositeBackend(new StateBackend(), {
    "/memories/": new StoreBackend({
      namespace: () => ["memories"],
    }),
  }),
  systemPrompt: `When users tell you their preferences, save them to /memories/user_preferences.txt so you remember them in future conversations.`,
});

import {
  CompositeBackend,
  createDeepAgent,
  StateBackend,
  StoreBackend,
} from "deepagents";
import { InMemoryStore } from "@langchain/langgraph";

const agent = await createDeepAgent({
  model: "openai:gpt-5.5",
  store: new InMemoryStore(),
  backend: new CompositeBackend(new StateBackend(), {
    "/memories/": new StoreBackend({
      namespace: () => ["memories"],
    }),
  }),
  systemPrompt: `When users tell you their preferences, save them to /memories/user_preferences.txt so you remember them in future conversations.`,
});

import {
  CompositeBackend,
  createDeepAgent,
  StateBackend,
  StoreBackend,
} from "deepagents";
import { InMemoryStore } from "@langchain/langgraph";

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  store: new InMemoryStore(),
  backend: new CompositeBackend(new StateBackend(), {
    "/memories/": new StoreBackend({
      namespace: () => ["memories"],
    }),
  }),
  systemPrompt: `When users tell you their preferences, save them to /memories/user_preferences.txt so you remember them in future conversations.`,
});

import {
  CompositeBackend,
  createDeepAgent,
  StateBackend,
  StoreBackend,
} from "deepagents";
import { InMemoryStore } from "@langchain/langgraph";

const agent = await createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  store: new InMemoryStore(),
  backend: new CompositeBackend(new StateBackend(), {
    "/memories/": new StoreBackend({
      namespace: () => ["memories"],
    }),
  }),
  systemPrompt: `When users tell you their preferences, save them to /memories/user_preferences.txt so you remember them in future conversations.`,
});

import {
  CompositeBackend,
  createDeepAgent,
  StateBackend,
  StoreBackend,
} from "deepagents";
import { InMemoryStore } from "@langchain/langgraph";

const agent = await createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  store: new InMemoryStore(),
  backend: new CompositeBackend(new StateBackend(), {
    "/memories/": new StoreBackend({
      namespace: () => ["memories"],
    }),
  }),
  systemPrompt: `When users tell you their preferences, save them to /memories/user_preferences.txt so you remember them in future conversations.`,
});

import {
  CompositeBackend,
  createDeepAgent,
  StateBackend,
  StoreBackend,
} from "deepagents";
import { InMemoryStore } from "@langchain/langgraph";

const agent = await createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  store: new InMemoryStore(),
  backend: new CompositeBackend(new StateBackend(), {
    "/memories/": new StoreBackend({
      namespace: () => ["memories"],
    }),
  }),
  systemPrompt: `When users tell you their preferences, save them to /memories/user_preferences.txt so you remember them in future conversations.`,
});

import {
  CompositeBackend,
  createDeepAgent,
  StateBackend,
  StoreBackend,
} from "deepagents";
import { InMemoryStore } from "@langchain/langgraph";

const agent = await createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  store: new InMemoryStore(),
  backend: new CompositeBackend(new StateBackend(), {
    "/memories/": new StoreBackend({
      namespace: () => ["memories"],
    }),
  }),
  systemPrompt: `When users tell you their preferences, save them to /memories/user_preferences.txt so you remember them in future conversations.`,
});

你不需要预先用文件填充 /memories/。你提供后端配置、store 和系统提示词指令，告诉智能体要保存什么以及保存在哪里。例如，你可以提示智能体将偏好存储在 /memories/preferences.txt 中。该路径初始为空，当用户分享值得记住的信息时，智能体会使用其文件系统工具（write_file、edit_file）按需创建文件。

要预先播种记忆，请在 LangSmith 上部署时使用 Store API。参见长期记忆了解设置和用例。

最佳实践

从正确的输入上下文开始 – 将记忆保持最小化以存放始终相关的约定；使用聚焦的技能存放任务特定能力。
利用子智能体处理繁重工作 – 委派多步骤、输出密集的任务以保持主智能体的上下文干净。
在配置中调整子智能体输出 – 如果在调试时发现子智能体生成很长的输出，可以在子智能体的 system_prompt 中添加指导，以生成摘要和综合发现。
使用文件系统 – 将大型输出持久化到文件（例如子智能体写入或自动卸载），使活动上下文保持较小；模型在需要细节时可以使用 read_file 和 grep 拉入片段。
记录长期记忆结构 – 告诉智能体 /memories/ 中存放什么以及如何使用它。
为工具传入运行时上下文 – 使用 context 存放工具需要的用户元数据、API 密钥和其他静态配置。

Going to production

Interpreters

Patterns

Configuration

上下文类型

输入上下文

系统提示词

记忆

技能

工具提示词

完整系统提示词

运行时上下文

自定义状态模式

上下文压缩

卸载

摘要

按需压缩工具

使用子智能体进行上下文隔离

长期记忆

最佳实践

相关资源

上下文类型 ​

输入上下文 ​

系统提示词 ​

记忆 ​

技能 ​

工具提示词 ​

完整系统提示词 ​

运行时上下文 ​

自定义状态模式 ​

上下文压缩 ​

卸载 ​

摘要 ​

按需压缩工具 ​

使用子智能体进行上下文隔离 ​

长期记忆 ​

最佳实践 ​

相关资源 ​

上下文类型

输入上下文

系统提示词

记忆

技能

工具提示词

完整系统提示词

运行时上下文

自定义状态模式

上下文压缩

卸载

摘要

按需压缩工具

使用子智能体进行上下文隔离

长期记忆

最佳实践

相关资源