---
title: Uso de la memoria del agente
url: https://platform.claude.com/docs/es/managed-agents/memory
description: Dale a tus agentes memoria persistente que sobrevive entre sesiones usando almacenes de memoria.
featureMetadata:
  status: beta
  betaHeader: agent-memory-2026-07-22
---

Cada sesión de Managed Agents comienza con un contexto nuevo de forma predeterminada. Cuando una sesión termina, cualquier estado que el agente haya acumulado desaparece. Los "memory stores" (almacenes de memoria) permiten que el agente conserve información entre sesiones: preferencias del usuario, convenciones del proyecto, errores previos y contexto del dominio.

<Note>
  No combines `agent-memory-2026-07-22` con `managed-agents-2026-04-01` en una solicitud de almacén de memoria: enviar ambos devuelve un error `400`. Si tu código establece encabezados beta explícitamente, reemplaza `managed-agents-2026-04-01` por `agent-memory-2026-07-22` en las llamadas a almacenes de memoria en lugar de agregar un segundo valor. Los endpoints de sesión, incluido adjuntar un almacén de memoria a una sesión, siguen usando `managed-agents-2026-04-01`.

  `GET /v1/memory_stores/{memory_store_id}/memories` se comporta igual con cualquiera de los dos encabezados: los resultados se devuelven en un orden estable definido por el servidor, y `path_prefix` y `depth` se aplican de la misma manera.
</Note>

## Descripción general

Un **almacén de memoria** ("memory store") es una colección de documentos de texto con alcance de espacio de trabajo, optimizada para Claude. Cuando adjuntas un almacén a una sesión, se monta como un directorio dentro del sandbox de la sesión. El agente lo lee y escribe con las mismas herramientas de archivos que usa para el resto del sistema de archivos, y se agrega automáticamente a la indicación del sistema una nota que describe cada montaje, indicándole al agente dónde buscar. El [conjunto de herramientas del agente](https://platform.claude.com/docs/es/managed-agents/tools) es necesario para estas interacciones; asegúrate de habilitarlo durante la [creación del agente](https://platform.claude.com/docs/es/managed-agents/agent-setup). En los [sandboxes autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory), ese directorio no es un montaje en vivo. En su lugar, tu worker de entorno descarga cada almacén adjunto en tu sandbox antes de que se ejecuten las herramientas del agente y mantiene esa copia sincronizada con el almacén.

Cada **memoria** en un almacén se direcciona mediante una ruta y puede leerse y editarse directamente a través de la API o de Claude Console, lo que permite ajustarla, importarla y exportarla.

Cada cambio en una memoria crea una **versión de memoria** ("memory version") inmutable, lo que te brinda un registro de auditoría y recuperación a un punto en el tiempo para todo lo que el agente escribe.

## Crear un almacén de memoria

Asigna al almacén un `name` (csharp, go: `Name`) y una `description` (csharp, go: `Description`). La descripción se pasa al agente y le indica qué contiene el almacén.

<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>

El `id` (csharp, go: `ID`) del almacén de memoria (`memstore_...`) es lo que pasas al adjuntar el almacén a una sesión.

### Inicializarlo con contenido (opcional)

Precarga un almacén con material de referencia antes de que se ejecute cualquier agente:

<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>
  Las memorias individuales dentro del almacén tienen un límite de 100 kB (\~25k tokens). Un almacén contiene un máximo de 10,000 memorias. Estructura la memoria como muchos archivos pequeños y enfocados, no como unos pocos archivos grandes.
</Tip>

## Adjuntar un almacén de memoria a una sesión

Los almacenes de memoria se adjuntan en el arreglo `resources` (csharp, go: `Resources`) de la sesión cuando [se crea la sesión](https://platform.claude.com/docs/es/managed-agents/sessions#creating-a-session). A diferencia de los recursos de archivo, los almacenes de memoria solo se pueden adjuntar al momento de crear la sesión; no se admite agregar ni quitar uno de una sesión en ejecución. Los almacenes de memoria se adjuntan de la misma manera para sesiones en entornos en la nube y en [entornos autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory); los entornos autoalojados solo aceptan recursos `memory_store`.

Opcionalmente, incluye `instructions` (csharp, go: `Instructions`) para proporcionar orientación específica de la sesión sobre cómo debe usar el agente este almacén. Se muestra al agente junto con el `name` (csharp, go: `Name`) y la `description` (csharp, go: `Description`) del almacén, y tiene un límite de 4,096 caracteres.

También puedes configurar `access` (csharp, go: `Access`). Su valor predeterminado es `read_write` (que se muestra explícitamente en el siguiente ejemplo), pero también se admite `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>
  Los almacenes de memoria se adjuntan con acceso `read_write` de forma predeterminada. Si el agente procesa entradas no confiables (prompts proporcionados por el usuario, contenido web obtenido o salida de herramientas de terceros), una inyección de prompt exitosa podría escribir contenido malicioso en el almacén. Las sesiones posteriores leerían entonces ese contenido como memoria confiable. Usa `read_only` para material de referencia, consultas compartidas y cualquier almacén que el agente no necesite modificar.
</Warning>

Se admite un máximo de **8 almacenes de memoria** por sesión. Adjunta varios almacenes cuando distintas partes de la memoria tengan distintos propietarios o reglas de acceso. Razones comunes:

* **Material de referencia compartido:** un almacén de solo lectura adjunto a muchas sesiones (estándares, convenciones, conocimiento del dominio), separado del almacén de lectura y escritura propio de cada sesión.
* **Correspondencia con la estructura de tu producto:** un almacén por usuario final, por equipo o por proyecto, compartiendo una única configuración de agente.
* **Ciclos de vida diferentes:** un almacén que sobrevive a cualquier sesión individual, o uno que quieras archivar según su propio calendario.

### Cómo accede el agente a la memoria

Cada almacén adjunto se monta dentro del sandbox de la sesión como un directorio bajo `/mnt/memory/`. El nombre del directorio es el nombre visible del almacén convertido en un slug seguro para el sistema de archivos (en minúsculas; las secuencias de caracteres no alfanuméricos se convierten en un solo guion), por lo que un almacén llamado "Demo Memory" se monta en `/mnt/memory/demo-memory/`. La ruta exacta se devuelve en el campo `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) del recurso de almacén de memoria de la sesión; léela desde ahí en lugar de construirla tú mismo. El agente lee y escribe el almacén con el [conjunto de herramientas del agente](https://platform.claude.com/docs/es/managed-agents/tools) estándar. Las escrituras bajo la ruta de montaje se persisten en el almacén y se mantienen sincronizadas entre las sesiones que lo comparten; las escrituras en cualquier otra ruta bajo `/mnt/memory/` fallan, porque el sandbox monta ese directorio padre como de solo lectura. Se agrega automáticamente a la indicación del sistema una breve descripción de cada montaje (nombre visible, ruta de montaje, modo de acceso, `description` (csharp, go: `Description`) del almacén y cualquier `instructions` (csharp, go: `Instructions`)).

`access` (csharp, go: `Access`) se aplica a nivel del sistema de archivos: un montaje `read_only` rechaza las escrituras, mientras que las escrituras en un montaje `read_write` producen [versiones de memoria](https://platform.claude.com/docs/es/managed-agents/memory#audit-memory-changes) atribuidas a la sesión.

<Note>
  En los [sandboxes autoalojados](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory), el directorio de cada almacén es una copia local que administra el worker en lugar de un montaje en vivo. El worker concilia cada copia con su almacén después de las llamadas a herramientas, como máximo una vez por intervalo de sincronización (15 segundos de forma predeterminada), y una vez más cuando termina la sesión. Las herramientas `write` y `edit` del agente solo modifican la copia local; el worker sube esos cambios en su siguiente sincronización, por lo que otra sesión que se ejecute en un sandbox autoalojado ve un cambio solo después de que ambos workers se hayan sincronizado. Las rutas bajo `/mnt/memory/` fuera de los directorios de los almacenes no son espacio temporal allí: las herramientas de archivos del worker se niegan a escribir en ellas, y cualquier cosa que un comando de shell escriba allí nunca se sincroniza con un almacén.

  Para un almacén `read_only`, las herramientas `write` y `edit` del worker rechazan los cambios bajo ese directorio y el worker nunca sube nada desde él. Para saber cómo resuelve el worker los conflictos de escritura, y qué puede seguir cambiando la herramienta `bash` en la copia local de un almacén de solo lectura, consulta [Almacenes de solo lectura y conflictos](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes-memory#read-only-stores-and-conflicts).
</Note>

Las lecturas y escrituras del agente aparecen en el [flujo de eventos](https://platform.claude.com/docs/es/managed-agents/events-and-streaming) como eventos ordinarios `agent.tool_use` y `agent.tool_result` de la herramienta que haya tocado el montaje.

## Ver y editar memorias

Los almacenes de memoria pueden administrarse directamente a través de la API. Usa esto para crear flujos de trabajo de revisión, corregir memorias incorrectas o inicializar almacenes antes de que se ejecute cualquier sesión.

### Listar memorias

Lista las memorias de un almacén. Los resultados se devuelven en un orden estable definido por el servidor.

* `path_prefix` limita la lista a un directorio. Debe terminar con `/` y coincide con segmentos de ruta completos, por lo que `path_prefix=/notes/` devuelve `/notes/todo.md` pero no `/notes-archive/todo.md`.
* `depth` controla qué tan profundo llega el listado por debajo de `path_prefix`: omítelo (o pasa `0`) para listar todo el subárbol, o pasa `1` para listar solo los hijos inmediatos. Otros valores devuelven un error `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>

Consulta la [referencia de Listar memorias](https://platform.claude.com/docs/es/api/beta/memory_stores/memories/list) para ver todos los parámetros y el esquema de respuesta.

### Leer una memoria

Obtener una memoria individual devuelve el contenido completo.

<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>

Consulta la [referencia de Recuperar una memoria](https://platform.claude.com/docs/es/api/beta/memory_stores/memories/retrieve) para ver todos los parámetros y el esquema de respuesta.

### Crear una memoria

`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`) crea una memoria en un `path` (csharp, go: `Path`) determinado. La creación no sobrescribe; para cambiar una memoria existente, [actualízala](https://platform.claude.com/docs/es/managed-agents/memory#update-a-memory) con `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>

Consulta la [referencia de Crear una memoria](https://platform.claude.com/docs/es/api/beta/memory_stores/memories/create) para ver todos los parámetros y el esquema de respuesta.

### Actualizar una memoria

`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`) modifica una memoria existente por ID. Puedes cambiar `content` (csharp, go: `Content`), `path` (csharp, go: `Path`) (un cambio de nombre) o ambos. El ejemplo cambia el nombre de una memoria a una ruta de archivo:

<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>

Consulta la [referencia de Actualizar una memoria](https://platform.claude.com/docs/es/api/beta/memory_stores/memories/update) para ver todos los parámetros y el esquema de respuesta.

#### Ediciones de contenido seguras (concurrencia optimista)

Para evitar pisar una escritura concurrente, pasa una precondición `content_sha256`. La actualización solo se aplica si el hash del contenido almacenado aún coincide con el que leíste; si no coincide, vuelve a leer la memoria y reintenta contra el estado actualizado.

<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>

### Eliminar una memoria

<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>

Consulta la [referencia de Eliminar una memoria](https://platform.claude.com/docs/es/api/beta/memory_stores/memories/delete) para ver todos los parámetros y el esquema de respuesta.

## Auditar cambios en la memoria

Cada mutación de una memoria crea una **versión de memoria** inmutable (`memver_...`). Usa los endpoints de versiones para auditar quién cambió qué y cuándo, para inspeccionar o restaurar una instantánea anterior, y para eliminar contenido sensible del historial mediante redacción.

Las versiones pertenecen al almacén (no a la memoria individual) y no se eliminan cuando se elimina la propia memoria, por lo que el registro de auditoría también abarca las memorias eliminadas, sujeto a la retención que se describe a continuación. Las versiones se conservan durante 30 días después de escribirse; sin embargo, las versiones recientes de una memoria activa siempre se conservan independientemente de su antigüedad, por lo que las memorias que cambian con poca frecuencia podrían conservar historial más allá de 30 días. La llamada en vivo `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`) siempre devuelve la versión más reciente; los endpoints de versiones te dan el historial conservado.

No existe un endpoint dedicado de restauración; para revertir, recupera la versión que quieras y vuelve a escribir su `content` (csharp, go: `Content`) con `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`) (o con `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`) si la memoria padre se ha eliminado, siempre que la versión que quieras todavía se conserve).

Las versiones de memoria pasadas podrían eliminarse después de 30 días. Para preservar el historial de memoria por más tiempo, exporta las versiones a través de la API.

### Listar versiones

Lista el historial de versiones de un almacén, de la más reciente a la más antigua. El ejemplo filtra el historial de una sola memoria:

<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>

Consulta la [referencia de Listar versiones de memoria](https://platform.claude.com/docs/es/api/beta/memory_stores/memory_versions/list) para ver todos los parámetros y el esquema de respuesta.

### Recuperar una versión

Obtener una versión individual devuelve los mismos campos que la respuesta de listado más el cuerpo completo de `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>

Consulta la [referencia de Recuperar una versión de memoria](https://platform.claude.com/docs/es/api/beta/memory_stores/memory_versions/retrieve) para ver todos los parámetros y el esquema de respuesta.

### Redactar una versión

Redactar elimina el contenido de una versión histórica preservando el registro de auditoría (quién hizo qué y cuándo). Úsalo para flujos de trabajo de cumplimiento, como eliminar secretos filtrados, PII o atender solicitudes de eliminación de usuarios.

Una versión que es la cabeza actual de una memoria activa no puede redactarse. Escribe primero una nueva versión (o elimina la memoria) y luego redacta la anterior.

<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>

Consulta la [referencia de Redactar una versión de memoria](https://platform.claude.com/docs/es/api/beta/memory_stores/memory_versions/redact) para ver todos los parámetros y el esquema de respuesta.

## Administrar almacenes de memoria

Además de [`create`](https://platform.claude.com/docs/es/api/beta/memory_stores/create), los almacenes de memoria admiten [`retrieve`](https://platform.claude.com/docs/es/api/beta/memory_stores/retrieve), [`update`](https://platform.claude.com/docs/es/api/beta/memory_stores/update), [`list`](https://platform.claude.com/docs/es/api/beta/memory_stores/list), [`archive`](https://platform.claude.com/docs/es/api/beta/memory_stores/archive) y [`delete`](https://platform.claude.com/docs/es/api/beta/memory_stores/delete).

### Listar almacenes

Lista los almacenes del espacio de trabajo. Los almacenes archivados se excluyen de forma predeterminada; establece `include_archived` (java, php: `includeArchived`; csharp, go: `IncludeArchived`) en `true` para incluirlos.

<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 solo se establece en almacenes archivados.
      $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>

Consulta la [referencia de Listar almacenes de memoria](https://platform.claude.com/docs/es/api/beta/memory_stores/list) para ver todos los parámetros y el esquema de respuesta.

### Archivar un almacén

Archivar hace que un almacén sea de solo lectura e impide que se adjunte a nuevas sesiones. Archivar es irreversible; no existe la opción de desarchivar.

<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>

Consulta la [referencia de Archivar un almacén de memoria](https://platform.claude.com/docs/es/api/beta/memory_stores/archive) para ver todos los parámetros y el esquema de respuesta.

Para [eliminar permanentemente un almacén](https://platform.claude.com/docs/es/api/beta/memory_stores/delete) junto con todas sus memorias y versiones, llama a `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`).

## Mejores prácticas para la administración de memoria

Cuando un almacén alcanza su límite de 10,000 memorias, las escrituras de nuevas memorias fallan: tanto las llamadas directas a `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`) como las escrituras de archivos del agente en rutas no asignadas. Las memorias existentes siguen siendo legibles y editables. Las siguientes prácticas te ayudan a mantenerte muy por debajo del límite y a recuperarte sin problemas si lo alcanzas.

* **Usa almacenes enfocados.** En lugar de un único almacén grande de propósito general, usa almacenes más pequeños diseñados para un propósito específico: uno por usuario, uno para conocimiento del dominio compartido y uno para contexto específico del proyecto. Cada almacén tiene su propio límite de 10,000 memorias, por lo que mantener los almacenes con un alcance definido reduce la probabilidad de que alguno se llene.

* **Condensa o depura antes de que el almacén se llene.** Elimina las memorias obsoletas o redundantes con `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`). También puedes ejecutar una [sesión de dreaming](https://platform.claude.com/docs/es/managed-agents/dreams), que consolida el contenido fragmentado en un nuevo almacén de salida independiente en lugar de modificar el original. Cambia tus sesiones a ese almacén de salida y luego archiva o elimina el original.

* **Adjunta un nuevo almacén cuando tenga sentido.** Si un almacén ha crecido más allá de su alcance útil, adjunta uno nuevo para el contenido nuevo y adjunta el original con acceso `read_only`. El agente puede leer de ambos mientras solo escribe en el nuevo.

* **Limita el acceso de escritura cuando corresponda.** Las sesiones que solo leen material de referencia compartido no necesitan `read_write`. Mantener el acceso de escritura limitado a las sesiones que realmente agregan nuevas memorias facilita rastrear de dónde proviene el crecimiento.