---
title: エージェントメモリの使用
url: https://platform.claude.com/docs/ja/managed-agents/memory
description: メモリストアを使用して、セッションをまたいで保持される永続的なメモリをエージェントに与えます。
featureMetadata:
  status: beta
  betaHeader: agent-memory-2026-07-22
  zdr:
    eligibility: not-eligible
    note: セルフホスト型Managed Agentsを除き、ZDRの適格対象ではありません。セッションはステートフルなリソースであり、トランスクリプトは削除するまで保持されます。
  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` エラーが返されます。コードでベータヘッダーを明示的に設定している場合は、メモリストアの呼び出しでは2つ目の値を追加するのではなく、`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>

## 概要

**メモリストア**は、Claude向けに最適化されたテキストドキュメントの、ワークスペース単位のコレクションです。ストアをセッションにアタッチすると、セッションのサンドボックス内にディレクトリとしてマウントされます。エージェントは、ファイルシステムの他の部分で使用するのと同じファイルツールでストアの読み書きを行い、各マウントを説明するメモがシステムプロンプトに自動的に追加され、エージェントにどこを参照すべきかを伝えます。これらのやり取りには[エージェントツールセット](https://platform.claude.com/docs/ja/managed-agents/tools)が必要です。[エージェントの作成](https://platform.claude.com/docs/ja/managed-agents/agent-setup)時に必ず有効にしてください。[セルフホスト型サンドボックス](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-memory)では、そのディレクトリはライブマウントではありません。代わりに、環境ワーカーがエージェントのツールが実行される前に、アタッチされた各ストアをサンドボックスにダウンロードし、そのコピーをストアと同期させ続けます。

ストア内の各**メモリ**はパスでアドレス指定され、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トークン）です。1つのストアには最大10,000個のメモリを保持できます。メモリは、少数の大きなファイルではなく、焦点を絞った多数の小さなファイルとして構成してください。
</Tip>

## メモリストアをセッションにアタッチする

メモリストアは、[セッションの作成](https://platform.claude.com/docs/ja/managed-agents/sessions#creating-a-session)時にセッションの `resources` (csharp, go: `Resources`) 配列でアタッチします。ファイルリソースとは異なり、メモリストアはセッション作成時にのみアタッチでき、実行中のセッションへの追加や削除はサポートされていません。クラウド環境と[セルフホスト型環境](https://platform.claude.com/docs/ja/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` アクセスでアタッチされます。エージェントが信頼できない入力（ユーザー提供のプロンプト、取得した Web コンテンツ、サードパーティツールの出力）を処理する場合、プロンプトインジェクションが成功すると悪意のあるコンテンツがストアに書き込まれる可能性があります。その後のセッションは、そのコンテンツを信頼できるメモリとして読み取ってしまいます。参照資料、共有ルックアップ、およびエージェントが変更する必要のないストアには `read_only` を使用してください。
</Warning>

各セッションでは最大**8個のメモリストア**がサポートされます。メモリの異なる部分でオーナーやアクセスルールが異なる場合は、複数のストアをアタッチします。一般的な理由は次のとおりです：

* **共有の参考資料：** 多数のセッションにアタッチされる1つの読み取り専用ストア（標準、規約、ドメイン知識）を、各セッション独自の読み書き可能なストアとは分けて保持する
* **製品の構造へのマッピング：** 単一のエージェント設定を共有しながら、エンドユーザー、チーム、またはプロジェクトごとに1つのストアを使用する
* **異なるライフサイクル：** 単一のセッションよりも長く存続するストアや、独自のスケジュールでアーカイブしたいストア

### エージェントがメモリにアクセスする方法

アタッチされた各ストアは、セッションのサンドボックス内の `/mnt/memory/` 配下にディレクトリとしてマウントされます。ディレクトリ名は、ストアの表示名をファイルシステムで安全に使えるスラッグに変換したもの（小文字化し、英数字以外の連続する文字をそれぞれ1つのハイフンに置き換えたもの）であるため、「Demo Memory」という名前のストアは `/mnt/memory/demo-memory/` にマウントされます。正確なパスはセッションのメモリストアリソースの `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) フィールドで返されます。パスは自分で組み立てるのではなく、そこから読み取ってください。エージェントは標準の[エージェントツールセット](https://platform.claude.com/docs/ja/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/ja/managed-agents/memory#audit-memory-changes)を生成します。

<Note>
  セルフホスト型サンドボックスでは、各ストアのディレクトリはライブマウントではなく、ワーカーがストアと同期するローカルコピーです。変更がストアおよび他のセッションに反映されるのは、同期時のみです。[ワーカーによるメモリの処理方法](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-memory#how-the-worker-handles-memory)と[読み取り専用ストアと競合](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes-memory#read-only-stores-and-conflicts)を参照してください。
</Note>

エージェントの読み取りと書き込みは、マウントに触れたツールに応じた通常の `agent.tool_use` および `agent.tool_result` イベントとして[イベントストリーム](https://platform.claude.com/docs/ja/managed-agents/events-and-streaming)に表示されます。

## メモリの表示と編集

メモリストアは API を通じて直接管理できます。レビューワークフローの構築、誤ったメモリの修正、またはセッション実行前のストアのシードに使用してください。

### メモリを一覧表示する

ストア内のメモリを一覧表示します。結果はサーバー定義の安定した順序で返されます。

* `path_prefix` は一覧を1つのディレクトリに限定します。`/` で終わる必要があり、パスセグメント全体に一致するため、`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/ja/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/ja/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/ja/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/ja/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/ja/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/ja/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`) 呼び出しは常に最新バージョンを返します。保持されている履歴はバージョンエンドポイントで取得できます。

専用の復元エンドポイントはありません。ロールバックするには、目的のバージョンを取得し、その `content` (csharp, go: `Content`) を `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`) で書き戻します（親メモリが削除されている場合は、目的のバージョンがまだ保持されていれば `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/ja/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/ja/api/beta/memory_stores/memory_versions/retrieve)のリファレンスを参照してください。

### バージョンを redact する

redactは、監査証跡（誰が、いつ、何をしたか）を保持しながら、過去のバージョンからコンテンツを消去します。漏洩したシークレットや個人を特定できる情報（PII）の削除、ユーザーの削除リクエストへの対応など、コンプライアンスのワークフローに使用してください。

ライブメモリの現在のヘッドであるバージョンは redact できません。まず新しいバージョンを書き込み（またはメモリを削除し）、その後で古いバージョンを redact してください。

<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/ja/api/beta/memory_stores/memory_versions/redact)のリファレンスを参照してください。

## メモリストアを管理する

[`create`](https://platform.claude.com/docs/ja/api/beta/memory_stores/create) に加えて、メモリストアは [`retrieve`](https://platform.claude.com/docs/ja/api/beta/memory_stores/retrieve)、[`update`](https://platform.claude.com/docs/ja/api/beta/memory_stores/update)、[`list`](https://platform.claude.com/docs/ja/api/beta/memory_stores/list)、[`archive`](https://platform.claude.com/docs/ja/api/beta/memory_stores/archive)、および [`delete`](https://platform.claude.com/docs/ja/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 はアーカイブ済みストアにのみ設定されます。
      $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/ja/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/ja/api/beta/memory_stores/archive)のリファレンスを参照してください。

すべてのメモリとバージョンとともに[ストアを完全に削除する](https://platform.claude.com/docs/ja/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`) 呼び出しと、マッピングされていないパスへのエージェントのファイル書き込みの両方が含まれます。既存のメモリは引き続き読み取りと編集が可能です。以下のプラクティスは、上限を十分に下回る状態を保ち、上限に達した場合にも適切に回復するのに役立ちます。

* **焦点を絞ったストアを使用する。** 1つの大きな汎用ストアではなく、目的別の小さなストアを使用してください。たとえば、ユーザーごとに1つ、共有のドメイン知識用に1つ、プロジェクト固有のコンテキスト用に1つといった形です。各ストアにはそれぞれ10,000個のメモリ上限があるため、ストアの範囲を限定しておくことで、いずれか1つのストアが満杯になる可能性を低減できます。

* **ストアが満杯になる前に集約または整理する。** 古くなったメモリや冗長なメモリは `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/ja/managed-agents/dreams)を実行することもできます。これは元のストアを変更するのではなく、断片化したコンテンツを別の新しい出力ストアに統合します。セッションをその出力ストアに切り替えてから、元のストアをアーカイブまたは削除してください。

* **適切なタイミングで新しいストアをアタッチする。** ストアが有用なスコープを超えて大きくなった場合は、新しいコンテンツ用に新しいストアをアタッチし、元のストアは `read_only` アクセスでアタッチしてください。エージェントは両方から読み取りつつ、新しいストアにのみ書き込むことができます。

* **適切な場合は書き込みアクセスを制限する。** 共有参照資料を読み取るだけのセッションに `read_write` は必要ありません。書き込みアクセスを実際に新しいメモリを追加するセッションに限定しておくことで、増加がどこから来ているかを追跡しやすくなります。

## 利用可能状況

メモリストアはすべてのモデルでベータ版です。

### APIサポート

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

* 利用可能状況：利用可能

| ステータス | クラウドプラットフォーム |
| ----- | ----- |
| ベータ<sup>1</sup> | Claude API |
| ベータ<sup>2</sup> | [Claude Platform on AWS](https://platform.claude.com/docs/ja/build-with-claude/claude-platform-on-aws) |
| ベータ<sup>3</sup> | [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/ja/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エラーが返されます。

### 必須のベータヘッダー

[ベータヘッダーの概要](https://platform.claude.com/docs/ja/api/beta-headers)

ベータヘッダーを使用すると、実験的な機能や新しいモデル機能が標準APIに組み込まれる前にアクセスできます。

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

### データの取り扱い

[データの取り扱いの概要](https://platform.claude.com/docs/ja/manage-claude/api-and-data-retention#feature-eligibility)

| 項目 | ゼロデータ保持 | HIPAA |
| ----- | ----- | ----- |
| ステータス | 対象外 | 対象外 |
| 詳細 | セルフホスト型Managed Agentsを除き、ZDRの適格対象ではありません。セッションはステートフルなリソースであり、トランスクリプトは削除するまで保持されます。 [詳細はこちら](https://platform.claude.com/docs/ja/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | HIPAAの適格対象ではありません。すべてのManaged Agentsのサブ機能に適用されます。 |

対象エンドポイント：

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