---
title: Использование памяти агента
url: https://platform.claude.com/docs/ru/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 по умолчанию начинается с чистого контекста. Когда сессия завершается, всё состояние, накопленное агентом, исчезает. Хранилища памяти позволяют агенту переносить информацию между сессиями: предпочтения пользователя, соглашения проекта, прошлые ошибки и контекст предметной области.

<Note>
  Не комбинируйте `agent-memory-2026-07-22` с `managed-agents-2026-04-01` в запросе к хранилищу памяти: отправка обоих значений возвращает ошибку `400`. Если ваш код задаёт бета-заголовки явно, замените `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. Когда вы подключаете хранилище к сессии, оно монтируется как каталог внутри песочницы («sandbox») сессии. Агент читает и записывает его с помощью тех же файловых инструментов, которые он использует для остальной файловой системы, а примечание с описанием каждой точки монтирования автоматически добавляется в системную подсказку, сообщая агенту, где искать. Для этих взаимодействий требуется [набор инструментов агента](https://platform.claude.com/docs/ru/managed-agents/tools); обязательно включите его при [создании агента](https://platform.claude.com/docs/ru/managed-agents/agent-setup). В [самостоятельно размещаемых песочницах](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-memory) этот каталог не является живой точкой монтирования. Вместо этого рабочий процесс («worker») вашего окружения загружает каждое подключённое хранилище в вашу песочницу до запуска инструментов агента и поддерживает эту копию в синхронизации с хранилищем.

Каждая **запись памяти** («memory») в хранилище адресуется по пути и может быть прочитана и отредактирована напрямую через API или Claude Console, что позволяет выполнять настройку, импорт и экспорт.

Каждое изменение записи памяти создаёт неизменяемую **версию памяти** («memory version»), предоставляя вам журнал аудита и возможность восстановления на определённый момент времени для всего, что записывает агент.

## Создание хранилища памяти

Задайте хранилищу `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 кБ (\~25 тыс. токенов). Хранилище вмещает не более 10 000 записей памяти. Структурируйте память как множество небольших тематических файлов, а не несколько крупных.
</Tip>

## Подключение хранилища памяти к сессии

Хранилища памяти подключаются в массиве `resources` (csharp, go: `Resources`) сессии при [создании сессии](https://platform.claude.com/docs/ru/managed-agents/sessions#creating-a-session). В отличие от файловых ресурсов, хранилища памяти можно подключить только во время создания сессии; добавление или удаление хранилища в работающей сессии не поддерживается. Хранилища памяти подключаются одинаково для сессий в облачных и [самостоятельно размещаемых окружениях](https://platform.claude.com/docs/ru/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`. Если агент обрабатывает недоверенные входные данные (подсказки, предоставленные пользователем, загруженный веб-контент или вывод сторонних инструментов), успешная «prompt injection» (инъекция подсказки) может записать вредоносное содержимое в хранилище. Последующие сессии затем читают это содержимое как доверенную память. Используйте `read_only` для справочных материалов, общих справочников и любого хранилища, которое агенту не нужно изменять.
</Warning>

Для каждой сессии поддерживается не более **8 хранилищ памяти**. Подключайте несколько хранилищ, когда разные части памяти имеют разных владельцев или разные правила доступа. Типичные причины:

* **Общие справочные материалы:** одно хранилище только для чтения, подключённое ко многим сессиям (стандарты, соглашения, знания предметной области), хранящееся отдельно от собственного хранилища для чтения и записи каждой сессии
* **Соответствие структуре вашего продукта:** по одному хранилищу на каждого конечного пользователя, команду или проект при использовании единой конфигурации агента
* **Разные жизненные циклы:** хранилище, которое живёт дольше любой отдельной сессии, или хранилище, которое вы хотите архивировать по собственному графику

### Как агент получает доступ к памяти

Каждое подключённое хранилище монтируется внутри песочницы сессии как каталог в `/mnt/memory/`. Имя каталога — это отображаемое имя хранилища, преобразованное в безопасный для файловой системы slug (в нижнем регистре, каждая последовательность небуквенно-цифровых символов заменена одним дефисом), поэтому хранилище с именем “Demo Memory” монтируется в `/mnt/memory/demo-memory/`. Точный путь возвращается в поле `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) ресурса хранилища памяти сессии; считывайте его оттуда, а не формируйте самостоятельно. Агент читает и записывает хранилище с помощью стандартного [набора инструментов агента](https://platform.claude.com/docs/ru/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/ru/managed-agents/memory#audit-memory-changes), привязанные к сессии.

<Note>
  В самостоятельно размещаемых песочницах каталог каждого хранилища — это локальная копия, которую воркер синхронизирует с хранилищем, а не живая точка монтирования. Изменение попадает в хранилище и в другие сессии только при синхронизации. См. [Как воркер обрабатывает память](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-memory#how-the-worker-handles-memory) и [Хранилища только для чтения и конфликты](https://platform.claude.com/docs/ru/managed-agents/self-hosted-sandboxes-memory#read-only-stores-and-conflicts).
</Note>

Операции чтения и записи агента отображаются в [потоке событий](https://platform.claude.com/docs/ru/managed-agents/events-and-streaming) как обычные события `agent.tool_use` и `agent.tool_result` для того инструмента, который обращался к точке монтирования.

## Просмотр и редактирование записей памяти

Хранилищами памяти можно управлять напрямую через 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/ru/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/ru/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/ru/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/ru/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/ru/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/ru/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/ru/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/ru/api/beta/memory_stores/memory_versions/retrieve).

### Редактирование (redact) версии

Редактирование удаляет содержимое из исторической версии, сохраняя при этом журнал аудита (кто, что и когда сделал). Используйте его для процессов обеспечения соответствия требованиям, например для удаления утёкших секретов или персональных данных (PII) либо для выполнения запросов пользователей на удаление.

Версию, которая является текущей головной версией существующей записи памяти, отредактировать нельзя. Сначала запишите новую версию (или удалите запись памяти), а затем отредактируйте старую.

<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/ru/api/beta/memory_stores/memory_versions/redact).

## Управление хранилищами памяти

Помимо [`create`](https://platform.claude.com/docs/ru/api/beta/memory_stores/create), хранилища памяти поддерживают [`retrieve`](https://platform.claude.com/docs/ru/api/beta/memory_stores/retrieve), [`update`](https://platform.claude.com/docs/ru/api/beta/memory_stores/update), [`list`](https://platform.claude.com/docs/ru/api/beta/memory_stores/list), [`archive`](https://platform.claude.com/docs/ru/api/beta/memory_stores/archive) и [`delete`](https://platform.claude.com/docs/ru/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/ru/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/ru/api/beta/memory_stores/archive).

Чтобы [навсегда удалить хранилище](https://platform.claude.com/docs/ru/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`), так и записи файлов агентом по несопоставленным путям. Существующие записи памяти остаются доступными для чтения и редактирования. Следующие рекомендации помогут вам оставаться значительно ниже лимита и корректно восстановиться, если вы его достигнете.

* **Используйте тематические хранилища.** Вместо одного большого хранилища общего назначения используйте небольшие специализированные хранилища: по одному на каждого пользователя, одно для общих знаний предметной области и одно для контекста конкретного проекта. У каждого хранилища свой лимит в 10 000 записей памяти, поэтому ограничение области хранилищ снижает вероятность заполнения какого-либо одного из них.

* **Сжимайте или очищайте хранилище до его заполнения.** Удаляйте устаревшие или избыточные записи памяти с помощью `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/ru/managed-agents/dreams), которая объединяет фрагментированное содержимое в отдельное новое выходное хранилище, не изменяя исходное. Переключите свои сессии на это выходное хранилище, а затем архивируйте или удалите исходное.

* **Подключайте новое хранилище, когда это целесообразно.** Если хранилище выросло за пределы своей полезной области, подключите новое для нового содержимого, а исходное подключите с доступом `read_only`. Агент сможет читать из обоих, записывая только в новое.

* **Ограничивайте доступ на запись там, где это уместно.** Сессиям, которые только читают общие справочные материалы, не нужен `read_write`. Ограничение доступа на запись сессиями, которые действительно добавляют новые записи памяти, упрощает отслеживание источников роста.

## Доступность

Хранилища памяти находятся в бета-версии для всех моделей.

### Поддержка API

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

* Доступность: Доступно

| Статус | Облачные платформы |
| ----- | ----- |
| Бета<sup>1</sup> | Claude API |
| Бета<sup>2</sup> | [Claude Platform on AWS](https://platform.claude.com/docs/ru/build-with-claude/claude-platform-on-aws) |
| Бета<sup>3</sup> | [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/ru/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/ru/api/beta-headers)

Бета-заголовки позволяют получить доступ к экспериментальным функциям и новым возможностям моделей до того, как они станут частью стандартного API.

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

### Обработка данных

[Обзор обработки данных](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention#feature-eligibility)

| Элемент | Нулевое хранение данных | HIPAA |
| ----- | ----- | ----- |
| Статус | Не допускается | Не допускается |
| Подробности | Не подпадает под ZDR, за исключением самостоятельно размещаемых Managed Agents. Сессии — это ресурсы с состоянием; их расшифровки хранятся, пока вы их не удалите. [Подробнее](https://platform.claude.com/docs/ru/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | Не подпадает под HIPAA. Относится ко всем подфункциям Managed Agents. |

Применимые конечные точки:

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