---
title: Использование памяти агента
url: https://platform.claude.com/docs/ru/managed-agents/memory
description: Предоставьте вашим агентам постоянную память, которая сохраняется между сессиями, с помощью хранилищ памяти.
featureMetadata:
  status: beta
  betaHeader: agent-memory-2026-07-22
---

Каждая сессия 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: 2023-06-01" \
    -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: 2023-06-01" \
    -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: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    --data '{
      "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
          {
              Type = "memory_store",
              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{
  			Type:          anthropic.BetaManagedAgentsMemoryStoreResourceParamTypeMemoryStore,
  			MemoryStoreID: store.ID,
  			Access:        anthropic.BetaManagedAgentsMemoryStoreResourceParamAccessReadWrite,
  			Instructions:  anthropic.String("User preferences and project context. Check before starting any task."),
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  ```

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

  ```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/`. Имя каталога — это отображаемое имя хранилища, преобразованное в безопасный для файловой системы слаг (в нижнем регистре; последовательности небуквенно-цифровых символов заменяются одним дефисом), поэтому хранилище с именем «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) каталог каждого хранилища — это локальная копия, которой управляет рабочий процесс, а не живая точка монтирования. Рабочий процесс согласовывает каждую копию с её хранилищем после вызовов инструментов, не чаще одного раза за интервал синхронизации (по умолчанию 15 секунд), и ещё раз при завершении сессии. Инструменты агента `write` и `edit` изменяют только локальную копию; рабочий процесс выгружает эти изменения при следующей синхронизации, поэтому другая сессия, работающая в самостоятельно размещаемой песочнице, увидит изменение только после того, как оба рабочих процесса выполнят синхронизацию. Пути в `/mnt/memory/` вне каталогов хранилищ там не являются временным пространством: файловые инструменты рабочего процесса отказываются записывать в них, а всё, что туда записывает команда оболочки, никогда не синхронизируется с хранилищем.

  Для хранилища `read_only` инструменты рабочего процесса `write` и `edit` отклоняют изменения в этом каталоге, и рабочий процесс никогда ничего из него не выгружает. Чтобы узнать, как рабочий процесс разрешает конфликты записи и что инструмент `bash` всё же может изменить в локальной копии хранилища только для чтения, см. [Хранилища только для чтения и конфликты](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: 2023-06-01" \
    -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(m => $"memory  {m.Path}", p => $"memory_prefix  {p.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(m -> IO.println("memory  " + m.path()));
      item.memoryPrefix().ifPresent(p -> IO.println("memory_prefix  " + p.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: 2023-06-01" \
    -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: 2023-06-01" \
    -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: 2023-06-01" \
    -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: 2023-06-01" \
    -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
      {
          Type = "content_sha256",
          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{
  		Type:          anthropic.BetaManagedAgentsPreconditionTypeContentSha256,
  		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()
                  .type(BetaManagedAgentsPrecondition.Type.CONTENT_SHA256)
                  .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: 2023-06-01" \
    -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: 2023-06-01" \
    -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 v of versions) {
    console.log(`${v.id}: ${v.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 v in versions.Paginate())
  {
      Console.WriteLine($"{v.ID}: {v.Operation.Raw()}");
      versionIds.Add(v.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() {
  	v := versions.Current()
  	fmt.Printf("%s: %s\n", v.ID, v.Operation)
  }
  if err := versions.Err(); err != nil {
  	panic(err)
  }

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

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

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

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

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

  ```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: 2023-06-01" \
    -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) версии

Операция 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: 2023-06-01" \
    -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: 2023-06-01" \
    -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 s of client.beta.memoryStores.list({ include_archived: true })) {
    console.log(s.id, s.name, s.archived_at);
  }
  ```

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

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

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

  ```php PHP
  foreach ($client->beta->memoryStores->list(includeArchived: true)->pagingEachItem() as $s) {
      // archivedAt устанавливается только для архивированных хранилищ.
      $archivedAt = isset($s->archivedAt) ? $s->archivedAt->format(DATE_ATOM) : '';
      echo "{$s->id} {$s->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: 2023-06-01" \
    -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`. Ограничение доступа на запись сессиями, которые действительно добавляют новые записи памяти, упрощает отслеживание источников роста.