LangChain 中文文档

外观

记忆让你的智能体能够跨对话学习和改进。Deep Agents 通过基于文件系统的记忆将记忆作为一等公民：智能体以文件的形式读写记忆，而你使用 后端 控制这些文件的存储位置。

INFO

本页介绍的是长期记忆：跨对话持续存在的记忆。关于短期记忆（单次会话内的对话历史和临时文件），请参阅 上下文工程 指南。短期记忆作为智能体 状态 的一部分自动管理。

短期记忆通过检查点限定在单个线程内；长期记忆通过 store 跨线程持久化

记忆的工作原理 ​

  1. 将智能体指向记忆文件。 创建智能体时通过 memory= 传入文件路径。你还可以通过 skills= 传入 技能 作为程序性记忆（告诉智能体如何执行任务的可复用指令）。后端 控制文件的存储位置以及谁能访问它们。
  2. 智能体读取记忆。 智能体可以在启动时将记忆文件加载到系统提示词中，也可以在对话过程中按需读取。例如，技能 使用按需加载：智能体启动时只读取技能描述，仅当技能与任务匹配时才读取完整的技能文件。这样在需要某项能力之前可以保持上下文精简。
  3. 智能体更新记忆（可选）。 当智能体学到新信息时，它可以使用内置的 edit_file 工具更新记忆文件。更新可以发生在对话期间（默认行为），也可以通过 后台整合 在两次对话之间于后台进行。更改会被持久化，并在下一次对话中可用。并非所有记忆都可写：开发者定义的 技能 和 组织级策略 通常是只读的。详情请参阅 只读与可写记忆。

最常见的两种模式是 智能体级记忆（所有用户共享）和 用户级记忆（按用户隔离）。

作用域记忆 ​

智能体记忆可以进行作用域划分，使相同的记忆文件对使用该智能体的所有人都可访问，也可以让记忆文件按每个用户单独划分。

智能体级记忆 ​

为智能体赋予其自身随时间演变的持久身份。智能体级记忆在所有用户之间共享，因此智能体通过每一次对话建立起自己的人格、累积的知识和学习到的偏好。在与用户交互的过程中，它会积累专业能力、改进自身方法，并记住哪些做法有效。当它拥有写权限时，还可以学习和更新 技能。

关键在于后端命名空间：将其设置为 (assistant_id,) 意味着该智能体的每一次对话都读写同一个记忆文件。

INFO

访问 rt.server_info 要求 deepagents>=0.5.0。在旧版本上，请改为从 get_config()["metadata"]["assistant_id"] 读取 assistant ID。

INFO

访问 rt.serverInfo 要求 deepagents>=1.9.0。在旧版本上，请改为从 getConfig().metadata.assistantId 读取 assistant ID。

python
from deepagents import create_deep_agent
from deepagents.backends import CompositeBackend, StateBackend, StoreBackend

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    memory=["/memories/AGENTS.md"],
    skills=["/skills/"],
    backend=CompositeBackend(
        default=StateBackend(),
        routes={
            "/memories/": StoreBackend(
                namespace=lambda rt: (
                    rt.server_info.assistant_id,  
                ),
            ),
            "/skills/": StoreBackend(
                namespace=lambda rt: (
                    rt.server_info.assistant_id,  
                ),
            ),
        },
    ),
)
typescript
import { createDeepAgent, CompositeBackend, StateBackend, StoreBackend } from "deepagents";

const agent = createDeepAgent({
  memory: ["/memories/AGENTS.md"],
  skills: ["/skills/"],
  backend: new CompositeBackend(
    new StateBackend(),
    {
      "/memories/": new StoreBackend({
        namespace: (rt) => [rt.serverInfo.assistantId],  
      }),
      "/skills/": new StoreBackend({
        namespace: (rt) => [rt.serverInfo.assistantId],  
      }),
    },
  ),
});

完整示例：初始化记忆并调用 ​

向 store 中填充初始记忆，然后在两个线程上调用智能体，观察它记住并更新所学到的内容。

python
from langchain_core.utils.uuid import uuid7

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

store = InMemoryStore()  # 部署到 LangSmith 时使用平台 store

# 初始化记忆文件
store.put(
    ("my-agent",),
    "/memories/AGENTS.md",
    create_file_data("""## Response style
- Keep responses concise
- Use code examples where possible
"""),
)

# 初始化一个技能
store.put(
    ("my-agent",),
    "/skills/langgraph-docs/SKILL.md",
    create_file_data("""---
name: langgraph-docs
description: Fetch relevant LangGraph documentation to provide accurate guidance.
---

# langgraph-docs

Use the fetch_url tool to read https://docs.langchain.com/llms.txt, then fetch relevant pages.
"""),
)

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    memory=["/memories/AGENTS.md"],
    skills=["/skills/"],
    backend=lambda rt: CompositeBackend(
        default=StateBackend(rt),
        routes={
            "/memories/": StoreBackend(
                rt, namespace=lambda rt: ("my-agent",)
            ),
            "/skills/": StoreBackend(
                rt, namespace=lambda rt: ("my-agent",)
            ),
        },
    ),
    store=store,
)

# 线程 1：智能体学到新的偏好并保存到记忆
config1 = {"configurable": {"thread_id": str(uuid7())}}
agent.invoke(
    {"messages": [{"role": "user", "content": "I prefer detailed explanations. Remember that."}]},
    config=config1,
)

# 线程 2：智能体读取记忆并应用偏好
config2 = {"configurable": {"thread_id": str(uuid7())}}
agent.invoke(
    {"messages": [{"role": "user", "content": "Explain how transformers work."}]},
    config=config2,
)
typescript
import { createDeepAgent, CompositeBackend, StateBackend, StoreBackend, createFileData } from "deepagents";
import { InMemoryStore } from "@langchain/langgraph";

const store = new InMemoryStore();  // 部署到 LangSmith 时使用平台 store

// 初始化记忆文件
await store.put(
  ["my-agent"],
  "/memories/AGENTS.md",
  createFileData(`## Response style
- Keep responses concise
- Use code examples where possible
`),
);

// 初始化一个技能
await store.put(
  ["my-agent"],
  "/skills/langgraph-docs/SKILL.md",
  createFileData(`---
name: langgraph-docs
description: Fetch relevant LangGraph documentation to provide accurate guidance.
---

# langgraph-docs

Use the fetch_url tool to read https://docs.langchain.com/llms.txt, then fetch relevant pages.
`),
);

const agent = createDeepAgent({
  memory: ["/memories/AGENTS.md"],
  skills: ["/skills/"],
  backend: (rt) => new CompositeBackend(
    new StateBackend(rt),
    {
      "/memories/": new StoreBackend(rt, {
        namespace: (rt) => ["my-agent"],
      }),
      "/skills/": new StoreBackend(rt, {
        namespace: (rt) => ["my-agent"],
      }),
    },
  ),
  store,
});

// 线程 1：智能体学到新的偏好并保存到记忆
const config1 = { configurable: { thread_id: crypto.randomUUID() } };
await agent.invoke({
  messages: [{ role: "user", content: "I prefer detailed explanations. Remember that." }],
}, config1);

// 线程 2：智能体读取记忆并应用偏好
const config2 = { configurable: { thread_id: crypto.randomUUID() } };
await agent.invoke({
  messages: [{ role: "user", content: "Explain how transformers work." }],
}, config2);

用户级记忆 ​

为每个用户提供他们自己的记忆文件。智能体按用户记住偏好、上下文和历史，而核心智能体指令保持不变。如果 技能 存储在用户作用域的后端中，用户也可以拥有各自的技能。

命名空间使用 (user_id,)，这样每个用户都会获得一份相互隔离的记忆文件副本。用户 A 的偏好永远不会泄漏到用户 B 的对话中。

python
from deepagents import create_deep_agent
from deepagents.backends import CompositeBackend, StateBackend, StoreBackend

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    memory=["/memories/preferences.md"],
    skills=["/skills/"],
    backend=CompositeBackend(
        default=StateBackend(),
        routes={
            "/memories/": StoreBackend(
                namespace=lambda rt: (rt.server_info.user.identity,),
            ),
            "/skills/": StoreBackend(
                namespace=lambda rt: (rt.server_info.user.identity,),
            ),
        },
    ),
)
typescript
import { createDeepAgent, CompositeBackend, StateBackend, StoreBackend } from "deepagents";

const agent = createDeepAgent({
  memory: ["/memories/preferences.md"],
  skills: ["/skills/"],
  backend: new CompositeBackend(
    new StateBackend(),
    {
      "/memories/": new StoreBackend({
        namespace: (rt) => [rt.serverInfo.user.identity],
      }),
      "/skills/": new StoreBackend({
        namespace: (rt) => [rt.serverInfo.user.identity],
      }),
    },
  ),
});

完整示例：跨用户隔离记忆 ​

初始化每个用户的记忆，并以两个不同用户的身份调用智能体。每个用户只能看到自己的偏好。

python
from langchain_core.utils.uuid import uuid7

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

store = InMemoryStore()  # 部署到 LangSmith 时使用平台 store

# 为两个用户初始化偏好
store.put(
    ("user-alice",),
    "/memories/preferences.md",
    create_file_data("""## Preferences
- Likes concise bullet points
- Prefers Python examples
"""),
)
store.put(
    ("user-bob",),
    "/memories/preferences.md",
    create_file_data("""## Preferences
- Likes detailed explanations
- Prefers TypeScript examples
"""),
)

# 为 Alice 初始化一个技能
store.put(
    ("user-alice",),
    "/skills/langgraph-docs/SKILL.md",
    create_file_data("""---
name: langgraph-docs
description: Fetch relevant LangGraph documentation to provide accurate guidance.
---

# langgraph-docs

Use the fetch_url tool to read https://docs.langchain.com/llms.txt, then fetch relevant pages.
"""),
)

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    memory=["/memories/preferences.md"],
    skills=["/skills/"],
    backend=lambda rt: CompositeBackend(
        default=StateBackend(rt),
        routes={
            "/memories/": StoreBackend(
                rt,
                namespace=lambda rt: (rt.server_info.user.identity,),
            ),
            "/skills/": StoreBackend(
                rt,
                namespace=lambda rt: (rt.server_info.user.identity,),
            ),
        },
    ),
    store=store,
)

# 部署后，每个经过身份验证的请求都会将
# `rt.server_info.user.identity` 解析为调用用户，因此 Alice 和 Bob
# 会自动看到各自的偏好。
agent.invoke(
    {"messages": [{"role": "user", "content": "How do I read a CSV file?"}]},
    config={"configurable": {"thread_id": str(uuid7())}},
)
typescript
import { createDeepAgent, CompositeBackend, StateBackend, StoreBackend, createFileData } from "deepagents";
import { InMemoryStore } from "@langchain/langgraph";

const store = new InMemoryStore();  // 部署到 LangSmith 时使用平台 store

// 为两个用户初始化偏好
await store.put(
  ["user-alice"],
  "/memories/preferences.md",
  createFileData(`## Preferences
- Likes concise bullet points
- Prefers Python examples
`),
);
await store.put(
  ["user-bob"],
  "/memories/preferences.md",
  createFileData(`## Preferences
- Likes detailed explanations
- Prefers TypeScript examples
`),
);

// 为 Alice 初始化一个技能
await store.put(
  ["user-alice"],
  "/skills/langgraph-docs/SKILL.md",
  createFileData(`---
name: langgraph-docs
description: Fetch relevant LangGraph documentation to provide accurate guidance.
---

# langgraph-docs

Use the fetch_url tool to read https://docs.langchain.com/llms.txt, then fetch relevant pages.
`),
);

const agent = createDeepAgent({
  memory: ["/memories/preferences.md"],
  skills: ["/skills/"],
  backend: (rt) => new CompositeBackend(
    new StateBackend(rt),
    {
      "/memories/": new StoreBackend(rt, {
        namespace: (rt) => [rt.serverInfo.user.identity],
      }),
      "/skills/": new StoreBackend(rt, {
        namespace: (rt) => [rt.serverInfo.user.identity],
      }),
    },
  ),
  store,
});

// 部署后，每个经过身份验证的请求都会将
// `rt.serverInfo.user.identity` 解析为调用用户，因此 Alice 和 Bob
// 会自动看到各自的偏好。
await agent.invoke(
  { messages: [{ role: "user", content: "How do I read a CSV file?" }] },
  { configurable: { thread_id: crypto.randomUUID() } },
);

高级用法 ​

除了记忆路径和作用域的基本配置选项外，你还可以为记忆配置更多高级参数：

维度它回答的问题选项
持续时间它持续多久？短期（单次对话）或 长期（跨对话）
信息类型它是哪种信息？情景式（过去的经验）、程序性（指令和技能）或 语义式（事实）
作用域谁能查看和修改它？用户、智能体 或 组织
更新策略记忆何时写入？对话期间（默认）或 对话之间
检索记忆如何被读取？加载到提示词中（默认）或按需加载（例如 技能）
智能体权限智能体能否写入记忆？读写（默认）或 只读（用于共享策略）

情景式记忆 ​

情景式记忆存储过去经验的记录：发生了什么、发生的顺序以及结果如何。与语义式记忆（存储在 AGENTS.md 等文件中的事实和偏好）不同，情景式记忆保留完整的对话上下文，因此智能体能够回忆起问题是如何解决的，而不只是从中学到了什么。

Deep Agents 已经使用 检查点器，这正是支持情景式记忆的机制：每一次对话都会被持久化为一个带检查点的线程。

要让过去的对话可搜索，可将线程搜索封装在一个工具中。user_id 从运行时上下文获取，而不是作为参数传入：

python
from langgraph_sdk import get_client
from langchain.tools import tool, ToolRuntime

client = get_client(url="<DEPLOYMENT_URL>")

@tool
async def search_past_conversations(query: str, runtime: ToolRuntime) -> str:
    """Search past conversations for relevant context."""
    user_id = runtime.server_info.user.identity  
    threads = await client.threads.search(
        metadata={"user_id": user_id},
        limit=5,
    )
    results = []
    for thread in threads:
        history = await client.threads.get_history(thread_id=thread["thread_id"])
        results.append(history)
    return str(results)
typescript
import { Client } from "@langchain/langgraph-sdk";
import { tool } from "@langchain/core/tools";

const client = new Client({ apiUrl: "<DEPLOYMENT_URL>" });

const searchPastConversations = tool(
  async ({ query }, runtime) => {
    const userId = runtime.serverInfo.user.identity;  
    const threads = await client.threads.search({
      metadata: { userId },
      limit: 5,
    });
    const results = [];
    for (const thread of threads) {
      const history = await client.threads.getHistory(thread.threadId);
      results.push(history);
    }
    return JSON.stringify(results);
  },
  {
    name: "search_past_conversations",
    description: "Search past conversations for relevant context.",
  }
);

你可以通过调整元数据过滤器，将线程搜索限定到某个用户或组织：

python
# 搜索特定用户的对话
threads = await client.threads.search(
    metadata={"user_id": user_id},
    limit=5,
)

# 搜索整个组织的对话
threads = await client.threads.search(
    metadata={"org_id": org_id},
    limit=5,
)
typescript
// 搜索特定用户的对话
const userThreads = await client.threads.search({
  metadata: { userId },
  limit: 5,
});

// 搜索整个组织的对话
const orgThreads = await client.threads.search({
  metadata: { orgId },
  limit: 5,
});

这对于执行复杂多步骤任务的智能体非常有用。例如，编码智能体可以回顾过去的调试会话，并直接跳到可能的根本原因。

组织级记忆 ​

组织级记忆与用户级记忆遵循相同的模式，但使用组织范围的命名空间而不是按用户的命名空间。将其用于应适用于组织中所有用户和智能体的策略或知识。

组织记忆通常是只读的，以防止通过共享状态进行提示词注入。详情请参阅 只读与可写记忆。

python
from deepagents import create_deep_agent
from deepagents.backends import CompositeBackend, StateBackend, StoreBackend

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    memory=[
        "/memories/preferences.md",
        "/policies/compliance.md",
    ],
    backend=CompositeBackend(
        default=StateBackend(),
        routes={
            "/memories/": StoreBackend(
                namespace=lambda rt: (rt.server_info.user.identity,),
            ),
            "/policies/": StoreBackend(
                namespace=lambda rt: (rt.context.org_id,),
            ),
        },
    ),
)
typescript
import { createDeepAgent, CompositeBackend, StateBackend, StoreBackend } from "deepagents";

const agent = createDeepAgent({
  memory: [
    "/memories/preferences.md",
    "/policies/compliance.md",
  ],
  backend: new CompositeBackend(
    new StateBackend(),
    {
      "/memories/": new StoreBackend({
        namespace: (rt) => [rt.serverInfo.user.identity],
      }),
      "/policies/": new StoreBackend({
        namespace: (rt) => [rt.context.orgId],
      }),
    },
  ),
});

从你的应用代码中填充组织记忆：

python
from langgraph_sdk import get_client
from deepagents.backends.utils import create_file_data

client = get_client(url="<DEPLOYMENT_URL>")

await client.store.put_item(
    (org_id,),
    "/compliance.md",
    create_file_data("""## Compliance policies
- Never disclose internal pricing
- Always include disclaimers on financial advice
"""),
)
typescript
import { Client } from "@langchain/langgraph-sdk";
import { createFileData } from "deepagents";

const client = new Client({ apiUrl: "<DEPLOYMENT_URL>" });

await client.store.putItem(
  [orgId],
  "/compliance.md",
  createFileData(`## Compliance policies
- Never disclose internal pricing
- Always include disclaimers on financial advice
`),
);

使用 权限 强制执行组织级记忆为只读，或使用 策略钩子 实现自定义验证逻辑。

后台整合 ​

默认情况下，智能体在对话期间（热路径）写入记忆。另一种方式是在对话之间以后台任务的形式处理记忆，有时被称为休眠时间计算。一个单独的深度智能体会审阅最近的对话，提取关键事实，并将它们与现有记忆合并。

方式优点缺点
热路径（对话期间）记忆立即可用，对用户透明增加延迟，智能体必须多任务处理
后台（对话之间）无用户可见的延迟，可以在多个对话之间综合信息记忆直到下一次对话才可用，需要第二个智能体

对于大多数应用，热路径已经足够。当你需要降低延迟或提升跨多个对话的记忆质量时，再添加后台整合。

推荐的模式是在你的主智能体旁部署一个整合智能体——一个读取最近对话历史、提取关键事实并将其合并到记忆 store 中的深度智能体——并通过 cron 计划 触发它。选择一个能反映用户实际与智能体交互频率的节奏：日流量稳定的聊天产品可能每几个小时整合一次，而每周只用几次的工具则只需每晚或每周运行一次。整合频率远高于用户对话频率，只会在无操作运行上浪费 token。

整合智能体 ​

整合智能体读取最近的对话历史，并将关键事实合并到记忆 store 中。在 langgraph.json 中将其与你的主智能体一起注册：

python
from datetime import datetime, timedelta, timezone

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

sdk_client = get_client(url="<DEPLOYMENT_URL>")

@tool
async def search_recent_conversations(query: str, runtime: ToolRuntime) -> str:
    """Search this user's conversations updated in the last 6 hours."""
    user_id = runtime.server_info.user.identity  

    since = datetime.now(timezone.utc) - timedelta(hours=6)
    threads = await sdk_client.threads.search(
        metadata={"user_id": user_id},
        updated_after=since.isoformat(),
        limit=20,
    )
    conversations = []
    for thread in threads:
        history = await sdk_client.threads.get_history(
            thread_id=thread["thread_id"]
        )
        conversations.append(history["values"]["messages"])
    return str(conversations)

agent = create_deep_agent(
    model="google_genai:gemini-3.6-flash",
    system_prompt="""Review recent conversations and update the user's memory file.
Merge new facts, remove outdated information, and keep it concise.""",
    tools=[search_recent_conversations],
)
typescript
import { createDeepAgent } from "deepagents";
import { Client } from "@langchain/langgraph-sdk";
import { tool } from "@langchain/core/tools";

const sdkClient = new Client({ apiUrl: "<DEPLOYMENT_URL>" });

const searchRecentConversations = tool(
  async ({ query }, runtime) => {
    const userId = runtime.serverInfo.user.identity;  

    const since = new Date(Date.now() - 6 * 60 * 60 * 1000).toISOString();
    const threads = await sdkClient.threads.search({
      metadata: { userId },
      updatedAfter: since,
      limit: 20,
    });
    const conversations = [];
    for (const thread of threads) {
      const history = await sdkClient.threads.getHistory(thread.threadId);
      conversations.push(history.values.messages);
    }
    return JSON.stringify(conversations);
  },
  {
    name: "search_recent_conversations",
    description: "Search this user's conversations updated in the last 6 hours.",
  }
);

const agent = createDeepAgent({
  model: "google_genai:gemini-3.6-flash",
  systemPrompt: `Review recent conversations and update the user's memory file.
Merge new facts, remove outdated information, and keep it concise.`,
  tools: [searchRecentConversations],
});

export { agent };
json
{
  "dependencies": ["."],
  "graphs": {
    "agent": "./agent.py:agent",
    "consolidation_agent": "./consolidation_agent.py:agent"
  },
  "env": ".env"
}
json
{
  "dependencies": ["."],
  "graphs": {
    "agent": "./src/agent.ts:agent",
    "consolidation_agent": "./src/consolidation-agent.ts:agent"
  },
  "env": ".env"
}

Cron ​

cron 作业 按固定计划运行整合智能体。该智能体搜索最近的对话并将其综合进记忆。让计划与你的使用模式匹配，使整合运行的频率大致跟随真实活动。

使用 cron 作业调度整合智能体：

python
from langgraph_sdk import get_client

client = get_client(url="<DEPLOYMENT_URL>")

cron_job = await client.crons.create(
    assistant_id="consolidation_agent",
    schedule="0 */6 * * *",
    input={"messages": [{"role": "user", "content": "Consolidate recent memories."}]},
)
typescript
import { Client } from "@langchain/langgraph-sdk";

const client = new Client({ apiUrl: "<DEPLOYMENT_URL>" });

const cronJob = await client.crons.create(
  "consolidation_agent",
  {
    schedule: "0 */6 * * *",
    input: { messages: [{ role: "user", content: "Consolidate recent memories." }] },
  },
);

INFO

所有 cron 计划均按 UTC 时间解释。有关管理和删除 cron 作业的详细信息，请参阅 cron 作业。

WARNING

cron 间隔必须与整合智能体内部的回看窗口一致。上面的示例每 6 小时运行一次（0 */6 * * *），而智能体的 search_recent_conversations 工具回看 timedelta(hours=6)——请保持两者同步。如果 cron 运行频率高于回看窗口，你会重复处理相同的对话；如果运行频率较低，你会丢失落在窗口之外的记忆。

有关使用后台进程部署智能体的更多内容，请参阅 进入生产环境。

只读与可写记忆 ​

默认情况下，智能体既可以读取也可以写入记忆文件。对于组织策略或合规规则等共享状态，你可能希望将记忆设为只读，以便智能体能够引用它但不能修改它。这可以防止通过共享记忆进行提示词注入，并确保只有你的应用代码控制文件中的内容。

权限用例工作原理
读写（默认）用户偏好、智能体自我改进、学到的 技能智能体通过 edit_file 工具更新文件
只读组织策略、合规规则、共享知识库、开发者定义的 技能通过应用代码或 Store API 填充。使用 权限 拒绝写入特定路径，或使用 策略钩子 实现自定义验证逻辑。

安全注意事项： 如果一个用户可以写入另一个用户读取的记忆，恶意用户就可能在共享状态中注入指令。为缓解此风险：

  • 默认使用用户作用域 (user_id)，除非你有共享的特定理由
  • 为共享策略使用只读记忆（通过应用代码填充，而不是智能体）
  • 在智能体写入共享记忆之前添加人在回路验证。使用 中断 要求在向敏感路径写入时获得人工批准。

要强制执行只读记忆，请使用 权限 以声明式方式拒绝写入特定路径。对于自定义验证逻辑（限流、审计日志、内容检查），请使用 后端策略钩子。

并发写入 ​

多个线程可以并行写入记忆，但对同一文件的并发写入可能导致后写覆盖先写的冲突。对于用户级记忆，这种情况很少见，因为用户通常同时只有一个活跃对话。对于智能体级或组织级记忆，请考虑使用 后台整合 来序列化写入，或将记忆按主题组织为单独的文件以减少争用。

实际上，如果写入因冲突而失败，LLM 通常足够聪明，能够重试或优雅恢复，因此单次写入丢失并不是灾难性的。

同一部署中的多个智能体 ​

要在共享部署中为每个智能体提供自己的记忆，请将 assistant_id 添加到命名空间：

python
StoreBackend(
    namespace=lambda rt: (
        rt.server_info.assistant_id,  
        rt.server_info.user.identity,
    ),
)
typescript
new StoreBackend({
  namespace: (rt) => [
    rt.serverInfo.assistantId,  
    rt.serverInfo.user.identity,
  ],
})

如果你只需要按智能体隔离而无需按用户划分作用域，则单独使用 assistant_id。

TIP

使用 LangSmith 追踪 审计你的智能体向记忆写入的内容。每次文件写入都会在追踪中显示为一次工具调用。