English ← MyDocs

使用智能体记忆

使用记忆存储为您的智能体提供跨会话的持久记忆。

默认情况下，每个托管智能体会话都从全新的上下文开始。当会话结束时，智能体建立的任何状态都会消失。记忆存储让智能体可以跨会话携带信息：用户偏好、项目约定、先前的错误和领域上下文。

Note

所有托管智能体 API 请求都需要 managed-agents-2026-04-01 beta 头。SDK 会自动设置 beta 头。

概述

记忆存储是工作区范围的文本文档集合，针对 Claude 进行了优化。当您将存储附加到会话时，它会作为目录挂载在会话的容器内。智能体使用与文件系统其余部分相同的文件工具读取和写入它，并且描述每个挂载的说明会自动添加到系统提示中，告诉智能体在哪里查找。智能体工具集是这些交互所必需的；请确保在智能体创建期间启用它。

存储中的每个记忆通过路径寻址，可以直接通过 API 或控制台读取和编辑，允许进行调整、导入和导出。

对记忆的每次更改都会创建一个不可变的记忆版本，为您提供审计跟踪和智能体写入的所有内容的时间点恢复。

创建记忆存储

为存储提供 name 和 description。描述会传递给智能体，告诉它存储包含什么内容。

store=$(curl -s https://api.anthropic.com/v1/memory_stores \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{"name": "User Preferences", "description": "Per-user preferences and project context."}')
store_id=$(jq -r '.id' <<< "$store")
echo "$store_id"  # memstore_01Hx...

store_id=$(ant beta:memory-stores create \
  --name "User Preferences" \
  --description "Per-user preferences and project context." \
  --transform id --raw-output)

store = client.beta.memory_stores.create(
    name="User Preferences",
    description="Per-user preferences and project context.",
)
print(store.id)  # memstore_01Hx...

const store = await client.beta.memoryStores.create({
  name: "User Preferences",
  description: "Per-user preferences and project context."
});
console.log(store.id); // memstore_01Hx...

var store = await client.Beta.MemoryStores.Create(new()
{
    Name = "User Preferences",
    Description = "Per-user preferences and project context.",
});
Console.WriteLine(store.ID);  // memstore_01Hx...

store, err := client.Beta.MemoryStores.New(ctx, anthropic.BetaMemoryStoreNewParams{
	Name:        "User Preferences",
	Description: anthropic.String("Per-user preferences and project context."),
})
if err != nil {
	panic(err)
}
fmt.Println(store.ID) // memstore_01Hx...

var store = client.beta().memoryStores().create(
    MemoryStoreCreateParams.builder()
        .name("User Preferences")
        .description("Per-user preferences and project context.")
        .build()
);
IO.println(store.id());  // memstore_01Hx...

use Anthropic\Client;

$client = new Client();

$store = $client->beta->memoryStores->create(
    name: 'User Preferences',
    description: 'Per-user preferences and project context.',
);
echo "{$store->id}\n"; // memstore_01Hx...

require "anthropic"

client = Anthropic::Client.new

store = client.beta.memory_stores.create(
  name: "User Preferences",
  description: "Per-user preferences and project context."
)
puts store.id # memstore_01Hx...

记忆存储 id（memstore_...）是您在将存储附加到会话时传递的值。

使用内容播种（可选）

在任何智能体运行之前，使用参考材料预加载存储：

curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memories" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{"path": "/formatting_standards.md", "content": "All reports use GAAP formatting. Dates are ISO-8601..."}' > /dev/null

ant beta:memory-stores:memories create \
  --memory-store-id "$store_id" \
  --path "/formatting_standards.md" \
  --content "All reports use GAAP formatting. Dates are ISO-8601..." \
  > /dev/null

client.beta.memory_stores.memories.create(
    store.id,
    path="/formatting_standards.md",
    content="All reports use GAAP formatting. Dates are ISO-8601...",
)

await client.beta.memoryStores.memories.create(store.id, {
  path: "/formatting_standards.md",
  content: "All reports use GAAP formatting. Dates are ISO-8601..."
});

await client.Beta.MemoryStores.Memories.Create(store.ID, new()
{
    Path = "/formatting_standards.md",
    Content = "All reports use GAAP formatting. Dates are ISO-8601...",
});

_, err = client.Beta.MemoryStores.Memories.New(ctx, store.ID, anthropic.BetaMemoryStoreMemoryNewParams{
	Path:    "/formatting_standards.md",
	Content: anthropic.String("All reports use GAAP formatting. Dates are ISO-8601..."),
})
if err != nil {
	panic(err)
}

client.beta().memoryStores().memories().create(
    store.id(),
    MemoryCreateParams.builder()
        .path("/formatting_standards.md")
        .content("All reports use GAAP formatting. Dates are ISO-8601...")
        .build()
);

$client->beta->memoryStores->memories->create(
    $store->id,
    path: '/formatting_standards.md',
    content: 'All reports use GAAP formatting. Dates are ISO-8601...',
);

client.beta.memory_stores.memories.create(
  store.id,
  path: "/formatting_standards.md",
  content: "All reports use GAAP formatting. Dates are ISO-8601..."
)
Tip

存储中的单个记忆上限为 100 kB（约 25k tokens）。将记忆结构化为许多小的专注文件，而不是几个大文件。

将记忆存储附加到会话

记忆存储在创建会话时在会话的 resources[] 数组中附加。与文件和仓库资源不同，记忆存储只能在会话创建时附加；不支持从运行中的会话添加或删除。

可选地包含 instructions 以提供会话特定的指导，告诉智能体应如何使用此存储。它与存储的 name 和 description 一起显示给智能体，上限为 4,096 个字符。

您也可以配置 access。它默认为 read_write（在以下示例中明确显示），但也支持 read_only。

curl -s https://api.anthropic.com/v1/sessions \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  --data @- <<EOF
{
  "agent": "$agent_id",
  "environment_id": "$environment_id",
  "resources": [
    {
      "type": "memory_store",
      "memory_store_id": "$store_id",
      "access": "read_write",
      "instructions": "User preferences and project context. Check before starting any task."
    }
  ]
}
EOF

ant beta:sessions create <<YAML
agent: $agent_id
environment_id: $environment_id
resources:
  - type: memory_store
    memory_store_id: $store_id
    access: read_write
    instructions: User preferences and project context. Check before starting any task.
YAML

session = client.beta.sessions.create(
    agent=agent.id,
    environment_id=environment.id,
    resources=[
        {
            "type": "memory_store",
            "memory_store_id": store.id,
            "access": "read_write",
            "instructions": "User preferences and project context. Check before starting any task.",
        }
    ],
)

const session = await client.beta.sessions.create({
  agent: agent.id,
  environment_id: environment.id,
  resources: [
    {
      type: "memory_store",
      memory_store_id: store.id,
      access: "read_write",
      instructions: "User preferences and project context. Check before starting any task."
    }
  ]
});

var session = await client.Beta.Sessions.Create(new()
{
    Agent = agent.ID,
    EnvironmentID = environment.ID,
    Resources =
    [
        new BetaManagedAgentsMemoryStoreResourceParam
        {
            Type = "memory_store",
            MemoryStoreID = store.ID,
            Access = "read_write",
            Instructions = "User preferences and project context. Check before starting any task.",
        },
    ],
});

session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
	Agent: anthropic.BetaSessionNewParamsAgentUnion{
		OfString: anthropic.String(agent.ID),
	},
	EnvironmentID: environment.ID,
	Resources: []anthropic.BetaSessionNewParamsResourceUnion{{
		OfMemoryStore: &anthropic.BetaManagedAgentsMemoryStoreResourceParam{
			Type:          anthropic.BetaManagedAgentsMemoryStoreResourceParamTypeMemoryStore,
			MemoryStoreID: store.ID,
			Access:        anthropic.BetaManagedAgentsMemoryStoreResourceParamAccessReadWrite,
			Instructions:  anthropic.String("User preferences and project context. Check before starting any task."),
		},
	}},
})
if err != nil {
	panic(err)
}

var session = client.beta().sessions().create(
    SessionCreateParams.builder()
        .agent(agent.id())
        .environmentId(environment.id())
        .addResource(
            BetaManagedAgentsMemoryStoreResourceParam.builder()
                .type(BetaManagedAgentsMemoryStoreResourceParam.Type.MEMORY_STORE)
                .memoryStoreId(store.id())
                .access(BetaManagedAgentsMemoryStoreResourceParam.Access.READ_WRITE)
                .instructions("User preferences and project context. Check before starting any task.")
                .build()
        )
        .build()
);

$session = $client->beta->sessions->create(
    agent: $agent->id,
    environmentID: $environment->id,
    resources: [
        [
            'type' => 'memory_store',
            'memory_store_id' => $store->id,
            'access' => 'read_write',
            'instructions' => 'User preferences and project context. Check before starting any task.',
        ],
    ],
);

session = client.beta.sessions.create(
  agent: agent.id,
  environment_id: environment.id,
  resources: [
    {
      type: "memory_store",
      memory_store_id: store.id,
      access: "read_write",
      instructions: "User preferences and project context. Check before starting any task."
    }
  ]
)
Warning

记忆存储默认以 read_write 访问附加。如果智能体处理不受信任的输入（用户提供的提示、获取的网络内容或第三方工具输出），成功的提示注入可能会将恶意内容写入存储。然后后续会话将该内容读取为受信任的记忆。对于参考资料、共享查找和智能体不需要修改的任何存储，请使用 read_only。

每个会话最多支持 8 个记忆存储。当记忆的不同部分有不同的所有者或访问规则时，附加多个存储。常见原因：

  • 共享参考资料： 一个只读存储附加到多个会话（标准、约定、领域知识），与每个会话自己的读写存储分开。
  • 映射到您产品的结构： 每个最终用户、每个团队或每个项目一个存储，同时共享单个智能体配置。
  • 不同的生命周期： 一个比任何单个会话都长寿的存储，或者您想按自己的时间表归档的存储。

智能体如何访问记忆

每个附加的存储作为目录挂载在会话容器内的 /mnt/memory/ 下，智能体使用标准智能体工具集读取和写入它。写入会持久化回存储，并在共享它的会话之间保持同步。每个挂载的简短描述（路径、访问模式、存储 description 和任何 instructions）会自动添加到系统提示中。

access 在文件系统级别强制执行：read_only 挂载拒绝写入，而对 read_write 挂载的写入会生成归属于会话的记忆版本。

智能体的读取和写入在事件流中显示为普通的 agent.tool_use 和 agent.tool_result 事件，对应于访问挂载的工具。

查看和编辑记忆

记忆存储可以直接通过 API 管理。用于构建审查工作流、纠正错误记忆或在任何会话运行之前播种存储。

列出记忆

列出存储中的记忆，可选地按 path_prefix 过滤以像浏览目录一样浏览路径：

curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memories?path_prefix=/&order_by=path&depth=2" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" | jq -r '.data[] | "\(.type)  \(.path)"'

ant beta:memory-stores:memories list \
  --memory-store-id "$store_id" \
  --path-prefix "/" --order-by path --depth 2

page = client.beta.memory_stores.memories.list(
    store.id,
    path_prefix="/",
    order_by="path",
    depth=2,
)
for item in page.data:
    print(item.type, item.path)

const page = await client.beta.memoryStores.memories.list(store.id, {
  path_prefix: "/",
  order_by: "path",
  depth: 2
});
for (const item of page.data) {
  console.log(item.type, item.path);
}

var page = await client.Beta.MemoryStores.Memories.List(store.ID, new()
{
    PathPrefix = "/",
    OrderBy = "path",
    Depth = 2,
});
await foreach (var item in page.Paginate())
{
    var line = item.Match(m => {{CONTENT}}quot;memory  {m.Path}", p => {{CONTENT}}quot;memory_prefix  {p.Path}");
    Console.WriteLine(line);
}

page, err := client.Beta.MemoryStores.Memories.List(ctx, store.ID, anthropic.BetaMemoryStoreMemoryListParams{
	PathPrefix: anthropic.String("/"),
	OrderBy:    anthropic.String("path"),
	Depth:      anthropic.Int(2),
})
if err != nil {
	panic(err)
}
for _, item := range page.Data {
	fmt.Println(item.Type, item.Path)
}

var page = client.beta().memoryStores().memories().list(
    store.id(),
    MemoryListParams.builder()
        .pathPrefix("/")
        .orderBy("path")
        .depth(2)
        .build()
);
for (var item : page.data()) {
    item.memory().ifPresent(m -> IO.println("memory  " + m.path()));
    item.memoryPrefix().ifPresent(p -> IO.println("memory_prefix  " + p.path()));
}

$page = $client->beta->memoryStores->memories->list(
    $store->id,
    pathPrefix: '/',
    orderBy: 'path',
    depth: 2,
);
foreach ($page->data as $item) {
    echo "{$item->type}  {$item->path}\n";
}

page = client.beta.memory_stores.memories.list(
  store.id,
  path_prefix: "/",
  order_by: "path",
  depth: 2
)
page.data.each do |entry|
  puts "#{entry.type}  #{entry.path}"
end

有关完整参数和响应架构，请参阅列出记忆参考。

读取记忆

获取单个记忆会返回完整内容。

curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memories/$mem_id" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" | jq -r '.content'

ant beta:memory-stores:memories retrieve \
  --memory-store-id "$store_id" \
  --memory-id "$mem_id"

retrieved = client.beta.memory_stores.memories.retrieve(
    mem.id,
    memory_store_id=store.id,
)
print(retrieved.content)

const retrieved = await client.beta.memoryStores.memories.retrieve(mem.id, {
  memory_store_id: store.id
});
console.log(retrieved.content);

var retrieved = await client.Beta.MemoryStores.Memories.Retrieve(mem.ID, new()
{
    MemoryStoreID = store.ID,
});
Console.WriteLine(retrieved.Content);

retrieved, err := client.Beta.MemoryStores.Memories.Get(ctx, mem.ID, anthropic.BetaMemoryStoreMemoryGetParams{
	MemoryStoreID: store.ID,
})
if err != nil {
	panic(err)
}
fmt.Println(retrieved.Content)

var retrieved = client.beta().memoryStores().memories().retrieve(
    mem.id(),
    MemoryRetrieveParams.builder().memoryStoreId(store.id()).build()
);
IO.println(retrieved.content());

$retrieved = $client->beta->memoryStores->memories->retrieve($mem->id, memoryStoreID: $store->id);
echo "{$retrieved->content}\n";

retrieved = client.beta.memory_stores.memories.retrieve(
  mem.id,
  memory_store_id: store.id
)
puts retrieved.content

有关完整参数和响应架构，请参阅检索记忆参考。

创建记忆

memories.create 在给定 path 创建记忆。创建不会覆盖；要更改现有记忆，请使用 memories.update。

mem=$(curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memories" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{"path": "/preferences/formatting.md", "content": "Always use tabs, not spaces."}')
mem_id=$(jq -r '.id' <<< "$mem")
mem_sha=$(jq -r '.content_sha256' <<< "$mem")

mem=$(ant beta:memory-stores:memories create \
  --memory-store-id "$store_id" \
  --path "/preferences/formatting.md" \
  --content "Always use tabs, not spaces." \
  --format json)
mem_id=$(jq -r '.id' <<< "$mem")
mem_sha=$(jq -r '.content_sha256' <<< "$mem")

mem = client.beta.memory_stores.memories.create(
    store.id,
    path="/preferences/formatting.md",
    content="Always use tabs, not spaces.",
)

const mem = await client.beta.memoryStores.memories.create(store.id, {
  path: "/preferences/formatting.md",
  content: "Always use tabs, not spaces."
});

var mem = await client.Beta.MemoryStores.Memories.Create(store.ID, new()
{
    Path = "/preferences/formatting.md",
    Content = "Always use tabs, not spaces.",
});

mem, err := client.Beta.MemoryStores.Memories.New(ctx, store.ID, anthropic.BetaMemoryStoreMemoryNewParams{
	Path:    "/preferences/formatting.md",
	Content: anthropic.String("Always use tabs, not spaces."),
})
if err != nil {
	panic(err)
}

var mem = client.beta().memoryStores().memories().create(
    store.id(),
    MemoryCreateParams.builder()
        .path("/preferences/formatting.md")
        .content("Always use tabs, not spaces.")
        .build()
);

$mem = $client->beta->memoryStores->memories->create(
    $store->id,
    path: '/preferences/formatting.md',
    content: 'Always use tabs, not spaces.',
);

mem = client.beta.memory_stores.memories.create(
  store.id,
  path: "/preferences/formatting.md",
  content: "Always use tabs, not spaces."
)

有关完整参数和响应架构，请参阅创建记忆参考。

更新记忆

memories.update 通过 ID 修改现有记忆。您可以更改 content、path（重命名）或两者。以下示例将记忆重命名为归档路径：

curl -s -X POST "https://api.anthropic.com/v1/memory_stores/$store_id/memories/$mem_id" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{"path": "/archive/2026_q1_formatting.md"}' > /dev/null

ant beta:memory-stores:memories update \
  --memory-store-id "$store_id" \
  --memory-id "$mem_id" \
  --path "/archive/2026_q1_formatting.md" \
  > /dev/null

client.beta.memory_stores.memories.update(
    mem.id,
    memory_store_id=store.id,
    path="/archive/2026_q1_formatting.md",
)

await client.beta.memoryStores.memories.update(mem.id, {
  memory_store_id: store.id,
  path: "/archive/2026_q1_formatting.md"
});

await client.Beta.MemoryStores.Memories.Update(mem.ID, new()
{
    MemoryStoreID = store.ID,
    Path = "/archive/2026_q1_formatting.md",
});

_, err = client.Beta.MemoryStores.Memories.Update(ctx, mem.ID, anthropic.BetaMemoryStoreMemoryUpdateParams{
	MemoryStoreID: store.ID,
	Path:          anthropic.String("/archive/2026_q1_formatting.md"),
})
if err != nil {
	panic(err)
}

client.beta().memoryStores().memories().update(
    mem.id(),
    MemoryUpdateParams.builder()
        .memoryStoreId(store.id())
        .path("/archive/2026_q1_formatting.md")
        .build()
);

$client->beta->memoryStores->memories->update(
    $mem->id,
    memoryStoreID: $store->id,
    path: '/archive/2026_q1_formatting.md',
);

client.beta.memory_stores.memories.update(
  mem.id,
  memory_store_id: store.id,
  path: "/archive/2026_q1_formatting.md"
)

有关完整参数和响应架构，请参阅更新记忆参考。

安全内容编辑（乐观并发）

为避免覆盖并发写入，请传递 content_sha256 前置条件。仅当存储的内容哈希与您读取的仍然匹配时，更新才会应用；不匹配时，重新读取记忆并对新状态重试。

curl -s -X POST "https://api.anthropic.com/v1/memory_stores/$store_id/memories/$mem_id" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  --data @- > /dev/null <<EOF
{
  "content": "CORRECTED: Always use 2-space indentation.",
  "precondition": {"type": "content_sha256", "content_sha256": "$mem_sha"}
}
EOF

ant beta:memory-stores:memories update \
  --memory-store-id "$store_id" \
  --memory-id "$mem_id" \
  --content "CORRECTED: Always use 2-space indentation." \
  --precondition "{type: content_sha256, content_sha256: $mem_sha}" \
  > /dev/null

client.beta.memory_stores.memories.update(
    memory_id=mem.id,
    memory_store_id=store.id,
    content="CORRECTED: Always use 2-space indentation.",
    precondition={"type": "content_sha256", "content_sha256": mem.content_sha256},
)

await client.beta.memoryStores.memories.update(mem.id, {
  memory_store_id: store.id,
  content: "CORRECTED: Always use 2-space indentation.",
  precondition: { type: "content_sha256", content_sha256: mem.content_sha256 }
});

await client.Beta.MemoryStores.Memories.Update(mem.ID, new()
{
    MemoryStoreID = store.ID,
    Content = "CORRECTED: Always use 2-space indentation.",
    Precondition = new BetaManagedAgentsPrecondition
    {
        Type = "content_sha256",
        ContentSha256 = mem.ContentSha256,
    },
});

_, err = client.Beta.MemoryStores.Memories.Update(ctx, mem.ID, anthropic.BetaMemoryStoreMemoryUpdateParams{
	MemoryStoreID: store.ID,
	Content:       anthropic.String("CORRECTED: Always use 2-space indentation."),
	Precondition: anthropic.BetaManagedAgentsPreconditionParam{
		Type:          anthropic.BetaManagedAgentsPreconditionTypeContentSha256,
		ContentSha256: anthropic.String(mem.ContentSha256),
	},
})
if err != nil {
	panic(err)
}

client.beta().memoryStores().memories().update(
    mem.id(),
    MemoryUpdateParams.builder()
        .memoryStoreId(store.id())
        .content("CORRECTED: Always use 2-space indentation.")
        .precondition(
            BetaManagedAgentsPrecondition.builder()
                .type(BetaManagedAgentsPrecondition.Type.CONTENT_SHA256)
                .contentSha256(mem.contentSha256())
                .build()
        )
        .build()
);

$client->beta->memoryStores->memories->update(
    $mem->id,
    memoryStoreID: $store->id,
    content: 'CORRECTED: Always use 2-space indentation.',
    precondition: ['type' => 'content_sha256', 'content_sha256' => $mem->contentSha256],
);

client.beta.memory_stores.memories.update(
  mem.id,
  memory_store_id: store.id,
  content: "CORRECTED: Always use 2-space indentation.",
  precondition: {type: "content_sha256", content_sha256: mem.content_sha256}
)

删除记忆

curl -s -X DELETE "https://api.anthropic.com/v1/memory_stores/$store_id/memories/$mem_id" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" > /dev/null

ant beta:memory-stores:memories delete \
  --memory-store-id "$store_id" \
  --memory-id "$mem_id" \
  > /dev/null

client.beta.memory_stores.memories.delete(
    mem.id,
    memory_store_id=store.id,
)

await client.beta.memoryStores.memories.delete(mem.id, {
  memory_store_id: store.id
});

await client.Beta.MemoryStores.Memories.Delete(mem.ID, new()
{
    MemoryStoreID = store.ID,
});

_, err = client.Beta.MemoryStores.Memories.Delete(ctx, mem.ID, anthropic.BetaMemoryStoreMemoryDeleteParams{
	MemoryStoreID: store.ID,
})
if err != nil {
	panic(err)
}

client.beta().memoryStores().memories().delete(
    mem.id(),
    MemoryDeleteParams.builder().memoryStoreId(store.id()).build()
);

$client->beta->memoryStores->memories->delete($mem->id, memoryStoreID: $store->id);

client.beta.memory_stores.memories.delete(
  mem.id,
  memory_store_id: store.id
)

有关完整参数和响应架构，请参阅删除记忆参考。

审计记忆更改

对记忆的每次变更都会创建一个不可变的记忆版本（memver_...）。使用版本端点审计谁在何时更改了什么，检查或恢复先前的快照，以及使用编辑从历史记录中清除敏感内容。

版本属于存储（不是单个记忆），即使在记忆本身被删除后也会保留，因此审计跟踪保持完整。版本保留 30 天；但是，最近的版本始终保留，无论时间长短，因此很少更改的记忆可能会保留超过 30 天的历史记录。实时 memories.retrieve 调用始终返回最新版本；版本端点为您提供保留的历史记录。

没有专用的恢复端点；要回滚，检索您想要的版本并使用 memories.update 将其 content 写回（如果父记忆已被删除则使用 memories.create，因为版本比其父记忆存活更久）。

过去的记忆版本可能会在 30 天后删除。要更长时间保留记忆历史记录，请通过 API 导出版本。

列出版本

列出存储的版本历史记录，最新的在前。以下示例过滤到单个记忆的历史记录：

versions=$(curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memory_versions?memory_id=$mem_id" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01")
jq -r '.data[] | "\(.id): \(.operation)"' <<< "$versions"
version_id=$(jq -r '.data[1].id' <<< "$versions")

versions=$(ant beta:memory-stores:memory-versions list \
  --memory-store-id "$store_id" \
  --memory-id "$mem_id" \
  --format json)
jq -r '.data[] | "\(.id): \(.operation)"' <<< "$versions"
version_id=$(jq -r '.data[1].id' <<< "$versions")

versions = client.beta.memory_stores.memory_versions.list(
    store.id,
    memory_id=mem.id,
)
for v in versions:
    print(f"{v.id}: {v.operation}")

version_id = versions.data[1].id

const versions = await client.beta.memoryStores.memoryVersions.list(store.id, {
  memory_id: mem.id
});
for await (const v of versions) {
  console.log(`${v.id}: ${v.operation}`);
}

const versionId = versions.data[1].id;

var versions = await client.Beta.MemoryStores.MemoryVersions.List(store.ID, new()
{
    MemoryID = mem.ID,
});
var versionIds = new List<string>();
await foreach (var v in versions.Paginate())
{
    Console.WriteLine({{CONTENT}}quot;{v.ID}: {v.Operation.Raw()}");
    versionIds.Add(v.ID);
}

var versionId = versionIds[1];

versions := client.Beta.MemoryStores.MemoryVersions.ListAutoPaging(ctx, store.ID, anthropic.BetaMemoryStoreMemoryVersionListParams{
	MemoryID: anthropic.String(mem.ID),
})
for versions.Next() {
	v := versions.Current()
	fmt.Printf("%s: %s\n", v.ID, v.Operation)
}
if err := versions.Err(); err != nil {
	panic(err)
}

vpage, err := client.Beta.MemoryStores.MemoryVersions.List(ctx, store.ID, anthropic.BetaMemoryStoreMemoryVersionListParams{
	MemoryID: anthropic.String(mem.ID),
})
if err != nil {
	panic(err)
}
versionID := vpage.Data[1].ID

var versions = client.beta().memoryStores().memoryVersions().list(
    store.id(),
    MemoryVersionListParams.builder().memoryId(mem.id()).build()
);
for (var v : versions.autoPager()) {
    IO.println(v.id() + ": " + v.operation());
}

var versionId = versions.data().get(1).id();

$versions = $client->beta->memoryStores->memoryVersions->list(
    $store->id,
    memoryID: $mem->id,
);
foreach ($versions->pagingEachItem() as $v) {
    echo "{$v->id}: {$v->operation}\n";
}

$versionId = $versions->data[1]->id;

versions = client.beta.memory_stores.memory_versions.list(
  store.id,
  memory_id: mem.id
)
versions.auto_paging_each do |v|
  puts "#{v.id}: #{v.operation}"
end

version_id = versions.data[1].id

有关完整参数和响应架构，请参阅列出记忆版本参考。

检索版本

获取单个版本会返回与列表响应相同的字段以及完整的 content 主体。

curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memory_versions/$version_id" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01"

ant beta:memory-stores:memory-versions retrieve \
  --memory-store-id "$store_id" \
  --memory-version-id "$version_id"

version = client.beta.memory_stores.memory_versions.retrieve(
    version_id,
    memory_store_id=store.id,
)
print(version.content)

const version = await client.beta.memoryStores.memoryVersions.retrieve(versionId, {
  memory_store_id: store.id
});
console.log(version.content);

var version = await client.Beta.MemoryStores.MemoryVersions.Retrieve(versionId, new()
{
    MemoryStoreID = store.ID,
});
Console.WriteLine(version.Content);

version, err := client.Beta.MemoryStores.MemoryVersions.Get(ctx, versionID, anthropic.BetaMemoryStoreMemoryVersionGetParams{
	MemoryStoreID: store.ID,
})
if err != nil {
	panic(err)
}
fmt.Println(version.Content)

var version = client.beta().memoryStores().memoryVersions().retrieve(
    versionId,
    MemoryVersionRetrieveParams.builder().memoryStoreId(store.id()).build()
);
IO.println(version.content());

$version = $client->beta->memoryStores->memoryVersions->retrieve(
    $versionId,
    memoryStoreID: $store->id,
);
echo "{$version->content}\n";

version = client.beta.memory_stores.memory_versions.retrieve(
  version_id,
  memory_store_id: store.id
)
puts version.content

有关完整参数和响应架构，请参阅检索记忆版本参考。

编辑版本

编辑会清除历史版本中的内容，同时保留审计跟踪（谁做了什么，何时）。用于合规工作流，例如删除泄露的密钥、PII 或用户删除请求。

作为实时记忆当前头的版本不能被编辑。首先写入新版本（或删除记忆），然后编辑旧版本。

curl -s -X POST "https://api.anthropic.com/v1/memory_stores/$store_id/memory_versions/$version_id/redact" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  -d '{}'

ant beta:memory-stores:memory-versions redact \
  --memory-store-id "$store_id" \
  --memory-version-id "$version_id"

client.beta.memory_stores.memory_versions.redact(
    version_id,
    memory_store_id=store.id,
)

await client.beta.memoryStores.memoryVersions.redact(versionId, {
  memory_store_id: store.id
});

await client.Beta.MemoryStores.MemoryVersions.Redact(versionId, new()
{
    MemoryStoreID = store.ID,
});

_, err = client.Beta.MemoryStores.MemoryVersions.Redact(ctx, versionID, anthropic.BetaMemoryStoreMemoryVersionRedactParams{
	MemoryStoreID: store.ID,
})
if err != nil {
	panic(err)
}

client.beta().memoryStores().memoryVersions().redact(
    versionId,
    MemoryVersionRedactParams.builder().memoryStoreId(store.id()).build()
);

$client->beta->memoryStores->memoryVersions->redact(
    $versionId,
    memoryStoreID: $store->id,
);

client.beta.memory_stores.memory_versions.redact(
  version_id,
  memory_store_id: store.id
)

有关完整参数和响应架构，请参阅编辑记忆版本参考。

管理记忆存储

除了 create，记忆存储还支持 retrieve、update、list、archive 和 delete。

列出存储

列出工作区中的存储。默认排除已归档的存储；传递 include_archived: true 以包含它们。

curl -s "https://api.anthropic.com/v1/memory_stores?include_archived=true" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" | jq '.data[] | {id, name, archived_at}'

ant beta:memory-stores list --include-archived

for s in client.beta.memory_stores.list(include_archived=True):
    print(s.id, s.name, s.archived_at)

for await (const s of client.beta.memoryStores.list({ include_archived: true })) {
  console.log(s.id, s.name, s.archived_at);
}

var stores = await client.Beta.MemoryStores.List(new() { IncludeArchived = true });
await foreach (var s in stores.Paginate())
{
    Console.WriteLine({{CONTENT}}quot;{s.ID} {s.Name} {s.ArchivedAt}");
}

stores := client.Beta.MemoryStores.ListAutoPaging(ctx, anthropic.BetaMemoryStoreListParams{
	IncludeArchived: anthropic.Bool(true),
})
for stores.Next() {
	s := stores.Current()
	fmt.Println(s.ID, s.Name, s.ArchivedAt)
}
if err := stores.Err(); err != nil {
	panic(err)
}

for (var s : client.beta().memoryStores().list(
    MemoryStoreListParams.builder().includeArchived(true).build()
).autoPager()) {
    IO.println(s.id() + " " + s.name() + " " + s.archivedAt());
}

foreach ($client->beta->memoryStores->list(includeArchived: true)->pagingEachItem() as $s) {
    echo "{$s->id} {$s->name} {$s->archivedAt}\n";
}

client.beta.memory_stores.list(include_archived: true).auto_paging_each do |s|
  puts "#{s.id} #{s.name} #{s.archived_at}"
end

有关完整参数和响应架构，请参阅列出记忆存储参考。

归档存储

归档使存储变为只读并防止其附加到新会话。归档是单向的；没有取消归档。

curl -s -X POST "https://api.anthropic.com/v1/memory_stores/$store_id/archive" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" > /dev/null

ant beta:memory-stores archive --memory-store-id "$store_id"

client.beta.memory_stores.archive(store.id)

await client.beta.memoryStores.archive(store.id);

await client.Beta.MemoryStores.Archive(store.ID);

_, err = client.Beta.MemoryStores.Archive(ctx, store.ID, anthropic.BetaMemoryStoreArchiveParams{})
if err != nil {
	panic(err)
}

client.beta().memoryStores().archive(store.id());

$client->beta->memoryStores->archive($store->id);

client.beta.memory_stores.archive(store.id)

有关完整参数和响应架构，请参阅归档记忆存储参考。

要永久删除存储及其所有记忆和版本，请使用 memory_stores.delete。

限制

当此功能处于 beta 阶段时，默认容量和速率限制适用于记忆存储。如果您需要更高的限制，请联系支持。