Deep Agents 中的上下文工程

上下文工程旨在以正确的格式提供正确的信息和工具，以便您的深度代理能够可靠地完成任务。深度代理可以访问多种类型的上下文。一些来源在启动时提供给代理；其他来源则在运行时变得可用，例如用户输入。深度代理包含内置机制，用于在长期运行的会话中管理上下文。本页面概述了您的深度代理可以访问和管理的不同类型的上下文。

刚接触上下文工程？请参阅概念概述，了解不同类型的上下文及其使用时机。

上下文类型

上下文类型	您控制的内容	作用域
输入上下文	代理启动时提示词中包含的内容（系统提示、记忆、技能）	静态的，每次运行时应用
运行时上下文	在调用时传递的静态配置（用户元数据、API 密钥、连接信息）	每次运行，传播到子代理
上下文压缩	内置的卸载和摘要机制，以保持上下文在窗口限制内	自动的，当接近限制时触发
上下文隔离（使用子代理）	使用子代理隔离繁重的工作，仅将结果返回给主代理	每个子代理，在委托时
长期记忆	使用虚拟文件系统实现跨线程的持久化存储	跨对话持久存在

输入上下文

输入上下文是在启动时提供给您的深度代理并成为其系统提示一部分的信息。最终提示由以下几个来源组成：

系统提示

您提供的自定义指令加上内置的代理指导。

记忆

持久化的 AGENTS.md 文件，配置后总是被加载。

技能

按需加载的能力，在相关时加载（渐进式披露）。

工具提示

用于使用内置工具或自定义工具的说明。

系统提示

您的自定义系统提示会被添加到内置系统提示之前，内置提示包含对文件系统工具和子代理的指导。用它来定义代理的角色、行为和知识：

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "google-genai:gemini-3.6-flash",
  systemPrompt: `你是一位专攻科学文献的研究助理。
  务必引用来源。使用子代理对不同主题进行并行研究。`,
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "openai:gpt-5.5",
  systemPrompt: `你是一位专攻科学文献的研究助理。
  务必引用来源。使用子代理对不同主题进行并行研究。`,
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "anthropic:claude-sonnet-4-6",
  systemPrompt: `你是一位专攻科学文献的研究助理。
  务必引用来源。使用子代理对不同主题进行并行研究。`,
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "openrouter:openrouter:z-ai/glm-5.2",
  systemPrompt: `你是一位专攻科学文献的研究助理。
  务必引用来源。使用子代理对不同主题进行并行研究。`,
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "fireworks:accounts/fireworks/models/glm-5p2",
  systemPrompt: `你是一位专攻科学文献的研究助理。
  务必引用来源。使用子代理对不同主题进行并行研究。`,
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "baseten:zai-org/GLM-5.2",
  systemPrompt: `你是一位专攻科学文献的研究助理。
  务必引用来源。使用子代理对不同主题进行并行研究。`,
});

import { createDeepAgent } from "deepagents";

const agent = await createDeepAgent({
  model: "ollama:north-mini-code-1.0",
  systemPrompt: `你是一位专攻科学文献的研究助理。
  务必引用来源。使用子代理对不同主题进行并行研究。`,
});

systemPrompt 参数是静态的，这意味着它不会随每次调用而改变。对于某些用例，您可能希望使用动态提示：例如，告诉模型“您拥有管理员访问权限”与“您拥有只读访问权限”，或者从长期记忆中注入用户偏好，如“用户偏好简洁的回复”。如果您的提示依赖于上下文或 runtime.store，请使用 dynamicSystemPromptMiddleware 来构建上下文感知的指令。您的中间件可以读取 request.runtime.context 和 request.runtime.store。有关默认中间件栈和添加自定义中间件的信息，请参阅自定义。有关示例，请参阅 LangChain 上下文工程指南。当只有工具使用上下文或 runtime.store 时，您不需要中间件；工具直接接收 runtime 对象（包括 runtime.context 和 runtime.store）。仅当系统提示本身必须随每个请求而变化时，才添加中间件。

要为特定提供商或模型调整组装后的系统提示，请使用工具链配置文件：base_system_prompt 会完全替换基础提示，system_prompt_suffix 则会附加其后。

记忆

记忆文件（AGENTS.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 的前置元数据，然后仅在确定技能相关时才加载完整的技能内容。这减少了令牌使用量，同时仍提供专业的工作流：

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 参数传递的工具会将该工具元数据（模式和描述）呈现给模型。深度代理的内置工具被打包在默认中间件栈中，通常还会用更多指导更新系统提示。 内置工具：添加工具链能力（文件系统、子代理和可选规划）的中间件会自动将特定于工具的指令附加到系统提示，创建解释如何有效使用这些工具的工具提示。完整列表请参阅自定义：

文件系统提示 – ls、read_file、write_file、edit_file、glob、grep（以及使用沙箱后端时的 execute）的文档
子代理提示 – 使用 task 工具委托工作的指导
人机协作提示 – 在指定工具调用处暂停的用法（当设置了 interrupt_on 时）
本地上下文提示 – 当前目录和项目信息（仅限 CLI）

您提供的工具：通过 tools 参数传递的工具会将其描述（来自工具模式）发送给模型。您还可以添加自定义中间件来添加工具并附加其自己的系统提示指令。对于您提供的工具，请确保提供清晰的名称、描述和参数描述。这些信息指导模型推理何时以及如何使用该工具。在描述中包含何时使用该工具，并描述每个参数的作用。

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

const searchOrders = tool(
  async ({ userId, status, limit }) =>
    `用户 ${userId} 的订单，状态为 ${status} (限制 ${limit} 条)`,
  {
    name: "search_orders",
    description: `根据状态搜索用户订单。

当用户询问订单历史或想要检查订单状态时使用此工具。
始终使用提供的状态进行过滤。`,
    schema: z.object({
      userId: z.string().describe("用户的唯一标识符"),
      status: z
        .enum(["pending", "shipped", "delivered"])
        .describe("用于过滤的订单状态"),
      limit: z
        .number()
        .default(10)
        .describe("要返回的最大结果数量"),
    }),
  },
);

要为特定提供商或模型覆盖内置或用户提供的工具描述，请使用工具链配置文件中的 tool_description_overrides，按工具名称键控。未使用的内置工具仍然会在每一轮发送其完整的模式。使用 excluded_tools 来移除代理永远不应调用的工具（例如，只读代理上的 write_file 或 execute）。这缩小了整个运行的基线提示大小。这是配置，而不是上下文压缩中的自动卸载或摘要。请参阅工具链配置文件和在不使用默认文件系统工具的情况下运行。

有关内置能力，请参阅概述；有关直接传递工具，请参阅自定义。

完整的系统提示

深度代理的系统消息——模型在运行开始时接收的组装好的系统提示——由以下部分组成：

自定义 system_prompt（如果提供）
基础代理提示
记忆提示：AGENTS.md + 记忆使用指南（仅当提供 memory 时）
技能提示：技能位置 + 具有前置元数据信息的技能列表 + 用法（仅当提供技能时）
虚拟文件系统提示（文件系统 + 可执行工具文档，如适用）
子代理提示：任务工具用法
用户提供的中间件提示（如果提供自定义中间件）
人机协作提示（当设置了 interrupt_on 时）

运行时上下文

运行时上下文是您在调用代理时传递的每次运行的配置。它不会自动包含在模型提示中；只有当工具、中间件或其他逻辑读取它并将其添加到消息或系统提示中时，模型才能看到它。将运行时上下文用于用户元数据（ID、偏好、角色）、API 密钥、数据库连接、功能标志或您的工具和工具链所需的其他值。使用 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}`; // 返回用户 ${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}`; // 返回用户 ${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}`; // 返回用户 ${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}`; // 返回用户 ${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}`; // 返回用户 ${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}`; // 返回用户 ${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}`; // 返回用户 ${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-..." } },
);

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

上下文压缩

每次 create_deep_agent 调用都包含内置的上下文压缩。您不需要为卸载或摘要添加中间件。长期运行的任务会产生大量的工具输出和冗长的对话历史。上下文压缩在保持与任务相关细节的同时，减少了代理工作内存中信息的大小。以下技术是确保传递给 LLM 的上下文保持在其上下文窗口限制内的内置机制：

卸载

大型工具输入和结果存储在文件系统中，并用引用替代。

摘要

当接近限制时，旧消息被压缩成 LLM 生成的摘要。

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

卸载

深度代理使用内置文件系统工具来自动卸载内容，并根据需要搜索和检索该卸载的内容。当工具调用输入或结果超过令牌阈值（默认为 20,000）时，会发生内容卸载：

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

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

摘要

当前的摘要行为（通过 wrapModelCall 进行的模型内摘要、准确的令牌计数和自动的 ContextOverflowError 回退）需要 deepagents>=1.6.0。

每次 create_deep_agent 调用都在默认中间件栈中包含 SummarizationMiddleware。当上下文大小超过模型的上下文窗口限制（例如 max_input_tokens 的 85%）且没有更多符合卸载条件的上下文时，深度代理会自动摘要消息历史。此过程有两个组成部分：

上下文内摘要：LLM 生成对话的结构化摘要，包括会话意图、创建的工件和后续步骤——这将替换代理工作内存中的完整对话历史。
文件系统保留：原始对话消息的文本渲染被写入文件系统作为规范记录。

这种双重方法确保代理保持对其目标和进展的意识（通过摘要），同时保留需要时恢复文本细节的能力（通过文件系统搜索）。摘要示例：显示代理的对话历史，其中几个步骤被压缩

配置：

在模型的模型配置文件中 max_input_tokens 的 85% 时触发
保留 10% 的令牌作为近期上下文
如果模型配置文件不可用，则回退到 170,000 令牌触发 / 保留 6 条消息
如果任何模型调用引发标准的 ContextOverflowError，深度代理会立即回退到摘要，并使用摘要 + 近期保留的消息重试
较旧的消息由模型进行摘要

来自代理的流式令牌通常会包含由摘要步骤生成的令牌。您可以使用关联的元数据过滤掉这些令牌：

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

使用子代理实现上下文隔离

子代理解决了上下文膨胀问题。当主代理使用具有大型输出的工具（网页搜索、文件读取、数据库查询）时，上下文窗口会迅速填满。子代理隔离了这项工作——主代理只接收最终结果，而不是产生该结果的数十个工具调用。您还可以单独配置每个子代理，与主代理分开（例如，模型、工具、系统提示和技能）。 工作原理：

主代理有一个 task 工具来委托工作
子代理使用自己全新的上下文运行
子代理自主执行直到完成
子代理向主代理返回一份最终报告
主代理的上下文保持整洁

最佳实践：

委托复杂任务：对会扰乱主代理上下文的多步骤工作使用子代理。

保持子代理响应简洁：指示子代理返回摘要，而不是原始数据：

const researchSubagent = {
  name: "researcher",
  description: "对主题进行研究",
  systemPrompt: `你是一名研究助手。
    重要提示：仅返回核心摘要（不超过500字）。
    请勿包含原始搜索结果或详细的工具输出内容。`,
  tools: [webSearch],
};

使用文件系统存储大数据：子代理可以将结果写入文件；主代理读取其需要的内容。

有关配置，请参阅子代理；有关运行时上下文传播和每个子代理的命名空间，请参阅上下文管理。

长期记忆

当使用默认文件系统时，您的深度代理将其工作内存文件存储在代理状态中，该状态仅在单个线程内持续存在。长期记忆使您的深度代理能够在不同线程和对话之间持久化信息。深度代理可以使用长期记忆来存储用户偏好、积累的知识、研究进度或任何应超出单个会话持续存在的信息。要使用长期记忆，您必须使用 CompositeBackend，它将特定路径（通常是 /memories/）路由到 LangGraph Store，后者提供持久的跨线程持久性。 CompositeBackend 是一个混合存储系统，其中一些文件无限期持久，而其他文件则限于单个线程。

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: `当用户告诉你他们的偏好时，请将它们保存到 /memories/user_preferences.txt，以便你在未来的对话中记住它们。`,
});

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: `当用户告诉你他们的偏好时，请将它们保存到 /memories/user_preferences.txt，以便你在未来的对话中记住它们。`,
});

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: `当用户告诉你他们的偏好时，请将它们保存到 /memories/user_preferences.txt，以便你在未来的对话中记住它们。`,
});

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: `当用户告诉你他们的偏好时，请将它们保存到 /memories/user_preferences.txt，以便你在未来的对话中记住它们。`,
});

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: `当用户告诉你他们的偏好时，请将它们保存到 /memories/user_preferences.txt，以便你在未来的对话中记住它们。`,
});

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: `当用户告诉你他们的偏好时，请将它们保存到 /memories/user_preferences.txt，以便你在未来的对话中记住它们。`,
});

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: `当用户告诉你他们的偏好时，请将它们保存到 /memories/user_preferences.txt，以便你在未来的对话中记住它们。`,
});

您不需要预先在 /memories/ 中填充文件。您提供后端配置、存储和系统提示指令，告诉代理保存什么以及保存在哪里。例如，您可以提示代理将偏好保存在 /memories/preferences.txt。路径最初是空的，当用户分享值得记忆的信息时，代理使用其文件系统工具（write_file、edit_file）按需创建文件。要预先植入记忆，在 LangSmith 上部署时请使用 Store API。有关设置和用例，请参阅长期记忆。

最佳实践

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

Get started

Deployment

Execution environment

Context management

Delegation

Steering

Frontend

Protocols

上下文类型

输入上下文

系统提示

记忆

技能

工具提示

系统提示

记忆

技能

工具提示

完整的系统提示

运行时上下文

上下文压缩

卸载

摘要

卸载

摘要

使用子代理实现上下文隔离

长期记忆

最佳实践

相关资源

​上下文类型

​输入上下文

系统提示

记忆

技能

工具提示

​系统提示

​记忆

​技能

​工具提示

​完整的系统提示

​运行时上下文

​上下文压缩

卸载

摘要

​卸载

​摘要

​使用子代理实现上下文隔离

​长期记忆

​最佳实践

​相关资源

上下文类型

输入上下文

系统提示

记忆

技能

工具提示

完整的系统提示

运行时上下文

上下文压缩

卸载

摘要

使用子代理实现上下文隔离

长期记忆

最佳实践

相关资源