---
title: 使用代理記憶
url: https://platform.claude.com/docs/zh-TW/managed-agents/memory
description: 使用記憶儲存庫為您的代理提供可跨工作階段持續存在的持久記憶。
featureMetadata:
  status: beta
  betaHeader: agent-memory-2026-07-22
  zdr:
    eligibility: not-eligible
    note: 不具 ZDR 適用資格，自行託管的 Managed Agents 除外。工作階段是具狀態的資源；對話記錄會保留至您將其刪除為止。
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API:
      availability: beta
      note: 在記憶儲存區呼叫中同時傳送 `managed-agents-2026-04-01` 與 `agent-memory-2026-07-22` 會傳回 400 錯誤。
    Claude Platform on AWS:
      availability: beta
      note: 在 Claude Platform on AWS 上，自行託管環境中的工作階段無法附加記憶儲存區。在記憶儲存區呼叫中同時傳送 `managed-agents-2026-04-01` 與 `agent-memory-2026-07-22` 會傳回 400 錯誤。
    Claude Models on Google Cloud (Anthropic managed):
      availability: beta
      note: 在 Claude Models on Google Cloud (Anthropic managed) 上，自行託管環境中的工作階段不支援記憶儲存區。在記憶儲存區呼叫中同時傳送 `managed-agents-2026-04-01` 與 `agent-memory-2026-07-22` 會傳回 400 錯誤。
---

每個 Managed Agents 工作階段預設都以全新的上下文開始。當工作階段結束時，代理所建立的任何狀態都會消失。「Memory store」（記憶儲存庫）讓代理能夠跨工作階段攜帶資訊：使用者偏好、專案慣例、先前的錯誤以及領域上下文。

<Note>
  請勿在記憶儲存庫請求中將 `agent-memory-2026-07-22` 與 `managed-agents-2026-04-01` 合併使用：同時傳送兩者會回傳 `400` 錯誤。如果您的程式碼明確設定了 beta 標頭，請在記憶儲存庫呼叫中將 `managed-agents-2026-04-01` 替換為 `agent-memory-2026-07-22`，而不是新增第二個值。工作階段端點（包括將記憶儲存庫附加到工作階段）仍使用 `managed-agents-2026-04-01`。

  `GET /v1/memory_stores/{memory_store_id}/memories` 在任一標頭下的行為相同：結果以穩定的、由伺服器定義的順序回傳，且 `path_prefix` 和 `depth` 的套用方式相同。
</Note>

## 概覽

**記憶儲存庫**（memory store）是一個以工作區為範圍、針對 Claude 最佳化的文字文件集合。當您將儲存庫附加到工作階段時，它會以目錄的形式掛載在工作階段的沙箱中。代理使用與檔案系統其他部分相同的檔案工具來讀取和寫入它，並且描述每個掛載點的說明會自動新增到系統提示中，告訴代理該去哪裡查找。這些互動需要使用[代理工具集](https://platform.claude.com/docs/zh-TW/managed-agents/tools)；請務必在[建立代理](https://platform.claude.com/docs/zh-TW/managed-agents/agent-setup)時啟用它。在[自行託管的沙箱](https://platform.claude.com/docs/zh-TW/managed-agents/self-hosted-sandboxes-memory)上，該目錄並非即時掛載。取而代之的是，您的環境 worker 會在代理的工具執行之前，將每個附加的儲存庫下載到您的沙箱中，並讓該副本與儲存庫保持同步。

儲存庫中的每個**記憶**都以路徑定址，並可透過 API 或 Claude Console 直接讀取和編輯，以便進行調整、匯入和匯出。

對記憶的每次變更都會建立一個不可變的**記憶版本**，為代理寫入的所有內容提供稽核軌跡和時間點復原。

## 建立記憶儲存庫

為儲存庫提供 `name` (csharp, go: `Name`) 和 `description` (csharp, go: `Description`)。描述會傳遞給代理，告訴它儲存庫包含哪些內容。

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -s https://api.anthropic.com/v1/memory_stores \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{
      "name": "User Preferences",
      "description": "Per-user preferences and project context."
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply memory_store.yaml
    ```

    <File filename="memory_store.yaml">
      ```yaml
      # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/memory_store.json
      name: User Preferences
      description: Per-user preferences and project context.
      ```
    </File>
  </CodeGroupItem>

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

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

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

  ```go Go
  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...
  ```

  ```java Java
  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...
  ```

  ```php PHP
  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...
  ```

  ```ruby Ruby
  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...
  ```
</CodeGroup>

記憶儲存庫的 `id` (csharp, go: `ID`)（`memstore_...`）就是您將儲存庫附加到工作階段時所傳遞的值。

### 預先填入內容（選用）

在任何代理執行之前，預先將參考資料載入儲存庫：

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memories" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{
      "path": "/formatting_standards.md",
      "content": "All reports use GAAP formatting. Dates are ISO-8601..."
    }'
  ```

  ```bash CLI
  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..."
  ```

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

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

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

  ```go Go
  _, 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)
  }
  ```

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

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

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

<Tip>
  儲存區中的個別記憶上限為 100 kB（約 25k 個 token）。一個儲存區最多可容納 10,000 個記憶。請將記憶組織成許多小而專注的檔案，而不是少數幾個大型檔案。
</Tip>

## 將記憶儲存庫附加到工作階段

記憶儲存庫是在[建立工作階段](https://platform.claude.com/docs/zh-TW/managed-agents/sessions#creating-a-session)時，附加在工作階段的 `resources` (csharp, go: `Resources`) 陣列中。與檔案資源不同，記憶儲存庫只能在建立工作階段時附加；不支援在執行中的工作階段新增或移除記憶儲存庫。無論是雲端環境還是[自行託管環境](https://platform.claude.com/docs/zh-TW/managed-agents/self-hosted-sandboxes-memory)上的工作階段，附加記憶儲存庫的方式都相同；自行託管環境僅接受 `memory_store` 資源。

您可以選擇性地加入 `instructions` (csharp, go: `Instructions`)，為代理應如何使用此儲存庫提供特定於工作階段的指引。它會與儲存庫的 `name` (csharp, go: `Name`) 和 `description` (csharp, go: `Description`) 一起顯示給代理，上限為 4,096 個字元。

您也可以設定 `access` (csharp, go: `Access`)。其預設值為 `read_write`（在以下範例中明確顯示），但也支援 `read_only`。

<CodeGroup>
  ```bash cURL
  curl -s https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "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."
        }
      ]
    }'
  ```

  ```bash CLI
  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
  ```

  ```python Python
  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.",
          }
      ],
  )
  ```

  ```typescript TypeScript
  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."
      }
    ]
  });
  ```

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

  ```go Go
  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{
  			MemoryStoreID: store.ID,
  			Access:        anthropic.BetaManagedAgentsMemoryStoreResourceParamAccessReadWrite,
  			Instructions:  anthropic.String("User preferences and project context. Check before starting any task."),
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  ```

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

  ```php PHP
  $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.',
          ],
      ],
  );
  ```

  ```ruby Ruby
  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."
      }
    ]
  )
  ```
</CodeGroup>

<Warning>
  記憶儲存庫預設以 `read_write` 存取權限附加。如果代理處理不受信任的輸入（使用者提供的提示、擷取的網頁內容或第三方工具輸出），成功的提示注入可能會將惡意內容寫入儲存庫。之後的工作階段便會將該內容當作受信任的記憶讀取。對於參考資料、共用查詢資料以及代理不需要修改的任何儲存庫，請使用 `read_only`。
</Warning>

每個工作階段最多支援 **8 個記憶儲存區**。當記憶的不同部分有不同的擁有者或存取規則時，請附加多個儲存區。常見的原因包括：

* **共用參考資料：**&#x5C07;一個唯讀儲存區附加到多個工作階段（標準、慣例、領域知識），並與每個工作階段自己的讀寫儲存區分開
* **對應您產品的結構：**&#x70BA;每個終端使用者、團隊或專案各建立一個儲存區，同時共用單一代理設定
* **不同的生命週期：**&#x4E00;個比任何單一工作階段存續更久的儲存區，或是您想依照其自身排程封存的儲存區

### 代理如何存取記憶

每個附加的儲存區都會以目錄的形式掛載在工作階段沙箱中的 `/mnt/memory/` 之下。目錄名稱是將儲存區的顯示名稱轉換為檔案系統安全的 slug（轉為小寫，並將每一段連續的非英數字元替換為單一連字號），因此名為「Demo Memory」的儲存區會掛載在 `/mnt/memory/demo-memory/`。確切路徑會在工作階段記憶儲存區資源的 `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) 欄位中傳回；請從該處讀取，而不要自行建構。代理會使用標準的[代理工具集](https://platform.claude.com/docs/zh-TW/managed-agents/tools)讀取和寫入儲存區。在掛載路徑下的寫入會持久化回儲存區，並在共用該儲存區的工作階段之間保持同步；寫入 `/mnt/memory/` 下任何其他路徑則會失敗，因為沙箱以唯讀方式掛載該父目錄。每個掛載的簡短描述（顯示名稱、掛載路徑、存取模式、儲存區的 `description` (csharp, go: `Description`)，以及任何 `instructions` (csharp, go: `Instructions`)）會自動加入系統提示中。

`access` (csharp, go: `Access`) 在檔案系統層級強制執行：`read_only` 掛載會拒絕寫入，而對 `read_write` 掛載的寫入則會產生歸屬於該工作階段的[記憶版本](https://platform.claude.com/docs/zh-TW/managed-agents/memory#audit-memory-changes)。

<Note>
  在自行託管的沙箱上，每個儲存庫的目錄是由 worker 與儲存庫同步的本機副本，而非即時掛載。變更只有在同步時才會送達儲存庫以及其他工作階段。請參閱[worker 如何處理記憶](https://platform.claude.com/docs/zh-TW/managed-agents/self-hosted-sandboxes-memory#how-the-worker-handles-memory)和[唯讀儲存區與衝突](https://platform.claude.com/docs/zh-TW/managed-agents/self-hosted-sandboxes-memory#read-only-stores-and-conflicts)。
</Note>

代理的讀取和寫入會以一般的 `agent.tool_use` 和 `agent.tool_result` 事件出現在[事件串流](https://platform.claude.com/docs/zh-TW/managed-agents/events-and-streaming)中，對應於觸及該掛載的任何工具。

## 檢視和編輯記憶

記憶儲存庫可直接透過 API 管理。可用於建立審查工作流程、修正錯誤的記憶，或在任何工作階段執行之前預先填入儲存庫。

### 列出記憶

列出儲存庫中的記憶。結果以穩定的、由伺服器定義的順序回傳。

* `path_prefix` 將清單範圍限定於一個目錄。它必須以 `/` 結尾，並比對完整的路徑區段，因此 `path_prefix=/notes/` 會回傳 `/notes/todo.md`，但不會回傳 `/notes-archive/todo.md`。
* `depth` 控制列表在 `path_prefix` 之下深入的程度：省略它（或傳入 `0`）以列出整個子樹，或傳入 `1` 以僅列出直接子項目。其他值會傳回 `400` 錯誤。

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memories?path_prefix=/" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

  ```bash CLI
  ant beta:memory-stores:memories list \
    --memory-store-id "$store_id" \
    --path-prefix "/"
  ```

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

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

  ```csharp C#
  var page = await client.Beta.MemoryStores.Memories.List(store.ID, new()
  {
      PathPrefix = "/",
  });
  await foreach (var item in page.Paginate())
  {
      var line = item.Match(
          memoryItem => $"memory  {memoryItem.Path}",
          prefixItem => $"memory_prefix  {prefixItem.Path}");
      Console.WriteLine(line);
  }
  ```

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

  ```java Java
  var page = client.beta().memoryStores().memories().list(
      store.id(),
      MemoryListParams.builder()
          .pathPrefix("/")
          .build()
  );
  for (var item : page.data()) {
      item.memory().ifPresent(memoryItem -> IO.println("memory  " + memoryItem.path()));
      item.memoryPrefix().ifPresent(prefixItem -> IO.println("memory_prefix  " + prefixItem.path()));
  }
  ```

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

  ```ruby Ruby
  page = client.beta.memory_stores.memories.list(
    store.id,
    path_prefix: "/"
  )
  page.data.each do |entry|
    puts "#{entry.type}  #{entry.path}"
  end
  ```
</CodeGroup>

如需完整的參數和回應結構描述，請參閱[列出記憶](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/memories/list)參考文件。

### 讀取記憶

擷取個別記憶會回傳完整內容。

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memories/$mem_id" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

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

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

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

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

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

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

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

  ```ruby Ruby
  retrieved = client.beta.memory_stores.memories.retrieve(
    mem.id,
    memory_store_id: store.id
  )
  puts retrieved.content
  ```
</CodeGroup>

如需完整的參數和回應結構描述，請參閱[擷取記憶](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/memories/retrieve)參考文件。

### 建立記憶

`POST /v1/memory_stores/{memory_store_id}/memories` (python, ruby: `client.beta.memory_stores.memories.create()`; typescript: `client.beta.memoryStores.memories.create()`; go: `client.Beta.MemoryStores.Memories.New()`; java: `client.beta().memoryStores().memories().create()`; csharp: `client.Beta.MemoryStores.Memories.Create()`; php: `$client->beta->memoryStores->memories->create()`; cli: `ant beta:memory-stores:memories create`) 會在指定的 `path` (csharp, go: `Path`) 建立記憶。建立操作不會覆寫；若要[更新現有記憶](https://platform.claude.com/docs/zh-TW/managed-agents/memory#update-a-memory)，請使用 `POST /v1/memory_stores/{memory_store_id}/memories/{memory_id}` (python, ruby: `client.beta.memory_stores.memories.update()`; typescript: `client.beta.memoryStores.memories.update()`; go, csharp: `client.Beta.MemoryStores.Memories.Update()`; java: `client.beta().memoryStores().memories().update()`; php: `$client->beta->memoryStores->memories->update()`; cli: `ant beta:memory-stores:memories update`)。

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memories" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{
      "path": "/preferences/formatting.md",
      "content": "Always use tabs, not spaces."
    }'
  ```

  ```bash CLI
  ant beta:memory-stores:memories create \
    --memory-store-id "$store_id" \
    --path "/preferences/formatting.md" \
    --content "Always use tabs, not spaces."
  ```

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

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

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

  ```go Go
  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)
  }
  ```

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

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

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

如需完整的參數和回應結構描述，請參閱[建立記憶](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/memories/create)參考文件。

### 更新記憶

`POST /v1/memory_stores/{memory_store_id}/memories/{memory_id}` (python, ruby: `client.beta.memory_stores.memories.update()`; typescript: `client.beta.memoryStores.memories.update()`; go, csharp: `client.Beta.MemoryStores.Memories.Update()`; java: `client.beta().memoryStores().memories().update()`; php: `$client->beta->memoryStores->memories->update()`; cli: `ant beta:memory-stores:memories update`) 會依 ID 修改現有記憶。您可以變更 `content` (csharp, go: `Content`)、`path` (csharp, go: `Path`)（重新命名），或兩者皆變更。以下範例將記憶重新命名為封存路徑：

<CodeGroup>
  ```bash cURL
  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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{"path": "/archive/2026_q1_formatting.md"}'
  ```

  ```bash CLI
  ant beta:memory-stores:memories update \
    --memory-store-id "$store_id" \
    --memory-id "$mem_id" \
    --path "/archive/2026_q1_formatting.md"
  ```

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

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

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

  ```go Go
  _, 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)
  }
  ```

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

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

  ```ruby Ruby
  client.beta.memory_stores.memories.update(
    mem.id,
    memory_store_id: store.id,
    path: "/archive/2026_q1_formatting.md"
  )
  ```
</CodeGroup>

如需完整的參數和回應結構描述，請參閱[更新記憶](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/memories/update)參考文件。

#### 安全的內容編輯（樂觀並行控制）

為避免覆寫同時進行的寫入，請傳入 `content_sha256` 前置條件。只有在儲存內容的雜湊值仍與您讀取時的雜湊值相符時，更新才會套用；若不相符，請重新讀取記憶，並根據最新狀態重試。

<CodeGroup>
  ```bash cURL
  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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{
      "content": "CORRECTED: Always use 2-space indentation.",
      "precondition": {"type": "content_sha256", "content_sha256": "'"$mem_sha"'"}
    }'
  ```

  ```bash CLI
  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}"
  ```

  ```python Python
  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},
  )
  ```

  ```typescript TypeScript
  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 }
  });
  ```

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

  ```go Go
  _, 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{
  		ContentSha256: anthropic.String(mem.ContentSha256),
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

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

  ```php PHP
  $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],
  );
  ```

  ```ruby Ruby
  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}
  )
  ```
</CodeGroup>

### 刪除記憶

<CodeGroup>
  ```bash cURL
  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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

  ```bash CLI
  ant beta:memory-stores:memories delete \
    --memory-store-id "$store_id" \
    --memory-id "$mem_id"
  ```

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

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

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

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

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

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

  ```ruby Ruby
  client.beta.memory_stores.memories.delete(
    mem.id,
    memory_store_id: store.id
  )
  ```
</CodeGroup>

如需完整的參數和回應結構描述，請參閱[刪除記憶](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/memories/delete)參考文件。

## 稽核記憶變更

對記憶的每次變動都會建立一個不可變的**記憶版本**（`memver_...`）。使用版本端點來稽核誰在何時變更了什麼、檢查或還原先前的快照，以及透過遮蔽（redact）將敏感內容從歷史記錄中清除。

版本隸屬於儲存區（而非個別記憶），且不會在記憶本身被刪除時一併刪除，因此稽核軌跡也涵蓋已刪除的記憶，但須遵守稍後描述的保留期限。版本在寫入後會保留 30 天；不過，現存記憶的近期版本無論存在多久都一律保留，因此不常變更的記憶可能會保留超過 30 天的歷史記錄。現存記憶的 `GET /v1/memory_stores/{memory_store_id}/memories/{memory_id}` (python, ruby: `client.beta.memory_stores.memories.retrieve()`; typescript: `client.beta.memoryStores.memories.retrieve()`; go: `client.Beta.MemoryStores.Memories.Get()`; java: `client.beta().memoryStores().memories().retrieve()`; csharp: `client.Beta.MemoryStores.Memories.Retrieve()`; php: `$client->beta->memoryStores->memories->retrieve()`; cli: `ant beta:memory-stores:memories retrieve`) 呼叫一律傳回最新版本；版本端點則提供已保留的歷史記錄。

沒有專用的還原端點；若要回復，請擷取您想要的版本，並使用 `POST /v1/memory_stores/{memory_store_id}/memories/{memory_id}` (python, ruby: `client.beta.memory_stores.memories.update()`; typescript: `client.beta.memoryStores.memories.update()`; go, csharp: `client.Beta.MemoryStores.Memories.Update()`; java: `client.beta().memoryStores().memories().update()`; php: `$client->beta->memoryStores->memories->update()`; cli: `ant beta:memory-stores:memories update`) 將其 `content` (csharp, go: `Content`) 寫回（如果父記憶已被刪除，則使用 `POST /v1/memory_stores/{memory_store_id}/memories` (python, ruby: `client.beta.memory_stores.memories.create()`; typescript: `client.beta.memoryStores.memories.create()`; go: `client.Beta.MemoryStores.Memories.New()`; java: `client.beta().memoryStores().memories().create()`; csharp: `client.Beta.MemoryStores.Memories.Create()`; php: `$client->beta->memoryStores->memories->create()`; cli: `ant beta:memory-stores:memories create`)，前提是您想要的版本仍被保留）。

過去的記憶版本可能會在 30 天後被刪除。若要將記憶歷史記錄保留更久，請透過 API 匯出版本。

### 列出版本

列出儲存庫的版本歷史記錄，最新的在前。此範例篩選為單一記憶的歷史記錄：

<CodeGroup>
  ```bash cURL
  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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

  ```bash CLI
  ant beta:memory-stores:memory-versions list \
    --memory-store-id "$store_id" \
    --memory-id "$mem_id" \
    --format json
  ```

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

  version_id = versions.data[1].id
  ```

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

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

  ```csharp C#
  var versions = await client.Beta.MemoryStores.MemoryVersions.List(store.ID, new()
  {
      MemoryID = mem.ID,
  });
  var versionIds = new List<string>();
  await foreach (var memoryVersion in versions.Paginate())
  {
      Console.WriteLine($"{memoryVersion.ID}: {memoryVersion.Operation.Raw()}");
      versionIds.Add(memoryVersion.ID);
  }

  var versionId = versionIds[1];
  ```

  ```go Go
  versions := client.Beta.MemoryStores.MemoryVersions.ListAutoPaging(ctx, store.ID, anthropic.BetaMemoryStoreMemoryVersionListParams{
  	MemoryID: anthropic.String(mem.ID),
  })
  for versions.Next() {
  	memoryVersion := versions.Current()
  	fmt.Printf("%s: %s\n", memoryVersion.ID, memoryVersion.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
  ```

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

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

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

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

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

  version_id = versions.data[1].id
  ```
</CodeGroup>

如需完整的參數和回應結構描述，請參閱[列出記憶版本](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/memory_versions/list)參考文件。

### 擷取版本

擷取個別版本會回傳與清單回應相同的欄位，外加完整的 `content` (csharp, go: `Content`) 內文。

<CodeGroup>
  ```bash cURL
  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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

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

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

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

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

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

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

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

  ```ruby Ruby
  version = client.beta.memory_stores.memory_versions.retrieve(
    version_id,
    memory_store_id: store.id
  )
  puts version.content
  ```
</CodeGroup>

如需完整的參數和回應結構描述，請參閱[擷取記憶版本](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/memory_versions/retrieve)參考文件。

### 遮蔽版本

遮蔽（redact）會從歷史版本中清除內容，同時保留稽核軌跡（誰在何時做了什麼）。可將其用於合規工作流程，例如移除外洩的機密或「personally identifiable information」（個人識別資訊），即 PII，或履行使用者的刪除請求。

作為現存記憶目前最新版本（head）的版本無法被遮蔽。請先寫入新版本（或刪除該記憶），然後再遮蔽舊版本。

<CodeGroup>
  ```bash cURL
  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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{}'
  ```

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

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

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

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

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

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

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

  ```ruby Ruby
  client.beta.memory_stores.memory_versions.redact(
    version_id,
    memory_store_id: store.id
  )
  ```
</CodeGroup>

如需完整的參數和回應結構描述，請參閱[編修記憶版本](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/memory_versions/redact)參考文件。

## 管理記憶儲存庫

除了 [`create`](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/create) 之外，記憶儲存庫還支援 [`retrieve`](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/retrieve)、[`update`](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/update)、[`list`](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/list)、[`archive`](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/archive) 和 [`delete`](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/delete)。

### 列出儲存庫

列出工作區中的儲存庫。預設會排除已封存的儲存庫；將 `include_archived` (java, php: `includeArchived`; csharp, go: `IncludeArchived`) 設為 `true` 即可將其包含在內。

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/memory_stores?include_archived=true" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

  ```bash CLI
  ant beta:memory-stores list --include-archived
  ```

  ```python Python
  for memory_store in client.beta.memory_stores.list(include_archived=True):
      print(memory_store.id, memory_store.name, memory_store.archived_at)
  ```

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

  ```csharp C#
  var stores = await client.Beta.MemoryStores.List(new() { IncludeArchived = true });
  await foreach (var memoryStore in stores.Paginate())
  {
      Console.WriteLine($"{memoryStore.ID} {memoryStore.Name} {memoryStore.ArchivedAt}");
  }
  ```

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

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

  ```php PHP
  foreach ($client->beta->memoryStores->list(includeArchived: true)->pagingEachItem() as $memoryStore) {
      // archivedAt 僅在已封存的 store 上設定。
      $archivedAt = isset($memoryStore->archivedAt) ? $memoryStore->archivedAt->format(DATE_ATOM) : '';
      echo "{$memoryStore->id} {$memoryStore->name} {$archivedAt}\n";
  }
  ```

  ```ruby Ruby
  client.beta.memory_stores.list(include_archived: true).auto_paging_each do |memory_store|
    puts "#{memory_store.id} #{memory_store.name} #{memory_store.archived_at}"
  end
  ```
</CodeGroup>

如需完整的參數和回應結構描述，請參閱[列出記憶儲存區](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/list)參考文件。

### 封存儲存庫

封存會使儲存庫變為唯讀，並防止其被附加到新的工作階段。封存是單向的；沒有取消封存的功能。

<CodeGroup>
  ```bash cURL
  curl -s -X POST "https://api.anthropic.com/v1/memory_stores/$store_id/archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

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

  ```python Python
  client.beta.memory_stores.archive(store.id)
  ```

  ```typescript TypeScript
  await client.beta.memoryStores.archive(store.id);
  ```

  ```csharp C#
  await client.Beta.MemoryStores.Archive(store.ID);
  ```

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

  ```java Java
  client.beta().memoryStores().archive(store.id());
  ```

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

  ```ruby Ruby
  client.beta.memory_stores.archive(store.id)
  ```
</CodeGroup>

如需完整的參數和回應結構描述，請參閱[封存記憶儲存區](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/archive)參考文件。

若要[永久刪除儲存區](https://platform.claude.com/docs/zh-TW/api/beta/memory_stores/delete)及其所有記憶和版本，請呼叫 `DELETE /v1/memory_stores/{memory_store_id}` (python, ruby: `client.beta.memory_stores.delete()`; typescript: `client.beta.memoryStores.delete()`; go, csharp: `client.Beta.MemoryStores.Delete()`; java: `client.beta().memoryStores().delete()`; php: `$client->beta->memoryStores->delete()`; cli: `ant beta:memory-stores delete`)。

## 記憶管理的最佳實務

當儲存庫達到 10,000 個記憶的上限時，寫入新記憶的操作會失敗：包括直接的 `POST /v1/memory_stores/{memory_store_id}/memories` (python, ruby: `client.beta.memory_stores.memories.create()`; typescript: `client.beta.memoryStores.memories.create()`; go: `client.Beta.MemoryStores.Memories.New()`; java: `client.beta().memoryStores().memories().create()`; csharp: `client.Beta.MemoryStores.Memories.Create()`; php: `$client->beta->memoryStores->memories->create()`; cli: `ant beta:memory-stores:memories create`) 呼叫，以及代理對未對應路徑的檔案寫入。現有記憶仍可讀取和編輯。以下實務可協助您保持遠低於上限，並在達到上限時順利復原。

* **使用專注的儲存區。**&#x8207;其使用一個大型的通用儲存區，不如使用較小的專用儲存區：每個使用者一個、共用領域知識一個，以及專案特定上下文一個。每個儲存區都有各自 10,000 個記憶的上限，因此限定儲存區的範圍可降低任何單一儲存區填滿的機會。

* **在儲存庫填滿之前進行精簡或修剪。**&#x4F7F;用 `DELETE /v1/memory_stores/{memory_store_id}/memories/{memory_id}` (python, ruby: `client.beta.memory_stores.memories.delete()`; typescript: `client.beta.memoryStores.memories.delete()`; go, csharp: `client.Beta.MemoryStores.Memories.Delete()`; java: `client.beta().memoryStores().memories().delete()`; php: `$client->beta->memoryStores->memories->delete()`; cli: `ant beta:memory-stores:memories delete`) 刪除過時或重複的記憶。您也可以執行[夢境工作階段](https://platform.claude.com/docs/zh-TW/managed-agents/dreams)，它會將零散的內容整合到另一個新的輸出儲存庫，而不是修改原始儲存庫。將您的工作階段切換到該輸出儲存庫，然後封存或刪除原始儲存庫。

* **在適當時機附加新的儲存庫。**&#x5982;果儲存庫已成長超出其有用範圍，請為新內容附加一個全新的儲存庫，並以 `read_only` 存取權限附加原始儲存庫。代理可以從兩者讀取，同時只寫入新的儲存庫。

* **在適當情況下限制寫入權限。**&#x50C5;讀取共用參考資料的工作階段不需要 `read_write`。將寫入權限限定於實際新增記憶的工作階段，可更容易追蹤成長的來源。

## 可用性

記憶儲存區在所有模型上處於 Beta 階段。

### API 支援

#### [Managed Agents](https://platform.claude.com/docs/zh-TW/managed-agents/overview)

* 可用性：可用

| 狀態 | 雲端平台 |
| ----- | ----- |
| Beta<sup>1</sup> | Claude API |
| Beta<sup>2</sup> | [Claude Platform on AWS](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-platform-on-aws) |
| Beta<sup>3</sup> | [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-models-on-google-cloud/anthropic-managed) |

1. 在記憶儲存區呼叫中同時傳送 `managed-agents-2026-04-01` 與 `agent-memory-2026-07-22` 會傳回 400 錯誤。
2. 在 Claude Platform on AWS 上，自行託管環境中的工作階段無法附加記憶儲存區。在記憶儲存區呼叫中同時傳送 `managed-agents-2026-04-01` 與 `agent-memory-2026-07-22` 會傳回 400 錯誤。
3. 在 Claude Models on Google Cloud (Anthropic managed) 上，自行託管環境中的工作階段不支援記憶儲存區。在記憶儲存區呼叫中同時傳送 `managed-agents-2026-04-01` 與 `agent-memory-2026-07-22` 會傳回 400 錯誤。

### 必要的 Beta 標頭

[Beta 標頭概覽](https://platform.claude.com/docs/zh-TW/api/beta-headers)

Beta 標頭可讓您在實驗性功能與新模型能力成為標準 API 的一部分之前搶先存取。

* `agent-memory-2026-07-22`

### 資料處理

[資料處理概覽](https://platform.claude.com/docs/zh-TW/manage-claude/api-and-data-retention#feature-eligibility)

| 項目 | 零資料保留 | HIPAA |
| ----- | ----- | ----- |
| 狀態 | 不符合資格 | 不符合資格 |
| 詳細資訊 | 不具 ZDR 適用資格，自行託管的 Managed Agents 除外。工作階段是具狀態的資源；對話記錄會保留至您將其刪除為止。 [深入了解](https://platform.claude.com/docs/zh-TW/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | 不具 HIPAA 適用資格。適用於所有 Managed Agents 子功能。 |

適用端點：

* `/v1/agents`
* `/v1/sessions`
* `/v1/environments`
