---
title: Utiliser la mémoire des agents
url: https://platform.claude.com/docs/fr/managed-agents/memory
description: Donnez à vos agents une mémoire persistante qui survit d'une session à l'autre grâce aux magasins de mémoire.
featureMetadata:
  status: beta
  betaHeader: agent-memory-2026-07-22
---

Chaque session Managed Agents démarre par défaut avec un contexte vierge. Lorsqu'une session se termine, tout état que l'agent a accumulé disparaît. Les « memory stores » (magasins de mémoire) permettent à l'agent de conserver des informations d'une session à l'autre : préférences utilisateur, conventions de projet, erreurs passées et contexte métier.

<Note>
  Ne combinez pas `agent-memory-2026-07-22` avec `managed-agents-2026-04-01` dans une requête de magasin de mémoire : envoyer les deux renvoie une erreur `400`. Si votre code définit explicitement les en-têtes bêta, remplacez `managed-agents-2026-04-01` par `agent-memory-2026-07-22` dans les appels aux magasins de mémoire plutôt que d'ajouter une seconde valeur. Les points de terminaison de session, y compris l'attachement d'un magasin de mémoire à une session, utilisent toujours `managed-agents-2026-04-01`.

  `GET /v1/memory_stores/{memory_store_id}/memories` se comporte de la même manière avec l'un ou l'autre en-tête : les résultats sont renvoyés dans un ordre stable défini par le serveur, et `path_prefix` et `depth` s'appliquent de la même façon.
</Note>

## Vue d'ensemble

Un **magasin de mémoire** est une collection de documents texte, limitée à un espace de travail et optimisée pour Claude. Lorsque vous attachez un magasin à une session, il est monté en tant que répertoire dans la « sandbox » (bac à sable) de la session. L'agent le lit et y écrit avec les mêmes outils de fichiers qu'il utilise pour le reste du système de fichiers, et une note décrivant chaque montage est automatiquement ajoutée à l'invite système, indiquant à l'agent où chercher. L'[ensemble d'outils de l'agent](https://platform.claude.com/docs/fr/managed-agents/tools) est requis pour ces interactions ; veillez à l'activer lors de la [création de l'agent](https://platform.claude.com/docs/fr/managed-agents/agent-setup). Sur les [sandboxes auto-hébergées](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory), ce répertoire n'est pas un montage en direct. À la place, votre worker d'environnement télécharge chaque magasin attaché dans votre sandbox avant l'exécution des outils de l'agent et maintient cette copie synchronisée avec le magasin.

Chaque **mémoire** d'un magasin est adressée par un chemin et peut être lue et modifiée directement via l'API ou la Claude Console, ce qui permet l'ajustement, l'importation et l'exportation.

Chaque modification d'une mémoire crée une **version de mémoire** immuable, vous offrant une piste d'audit et une restauration à un instant donné pour tout ce que l'agent écrit.

## Créer un magasin de mémoire

Donnez au magasin un `name` (csharp, go: `Name`) et une `description` (csharp, go: `Description`). La description est transmise à l'agent pour lui indiquer ce que contient le magasin.

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

L'`id` (csharp, go: `ID`) du magasin de mémoire (`memstore_...`) est ce que vous transmettez lorsque vous attachez le magasin à une session.

### L'alimenter avec du contenu (facultatif)

Préchargez un magasin avec des documents de référence avant toute exécution d'agent :

<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>
  Les mémoires individuelles d'un magasin sont limitées à 100 ko (\~25 000 tokens). Un magasin contient au maximum 10 000 mémoires. Structurez la mémoire en de nombreux petits fichiers ciblés plutôt qu'en quelques gros fichiers.
</Tip>

## Attacher un magasin de mémoire à une session

Les magasins de mémoire sont attachés dans le tableau `resources` (csharp, go: `Resources`) de la session lors de la [création de la session](https://platform.claude.com/docs/fr/managed-agents/sessions#creating-a-session). Contrairement aux ressources de fichiers, les magasins de mémoire ne peuvent être attachés qu'au moment de la création de la session ; l'ajout ou le retrait d'un magasin dans une session en cours d'exécution n'est pas pris en charge. Vous attachez les magasins de mémoire de la même manière pour les sessions sur des environnements cloud et [auto-hébergés](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory) ; les environnements auto-hébergés n'acceptent que les ressources `memory_store`.

Vous pouvez éventuellement inclure des `instructions` (csharp, go: `Instructions`) pour fournir des consignes propres à la session sur la manière dont l'agent doit utiliser ce magasin. Elles sont présentées à l'agent avec le `name` (csharp, go: `Name`) et la `description` (csharp, go: `Description`) du magasin, et sont limitées à 4 096 caractères.

Vous pouvez également configurer `access` (csharp, go: `Access`). Sa valeur par défaut est `read_write` (indiquée explicitement dans l'exemple suivant), mais `read_only` est également pris en charge.

<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>
  Les magasins de mémoire sont attachés avec l'accès `read_write` par défaut. Si l'agent traite des entrées non fiables (prompts fournis par l'utilisateur, contenu web récupéré ou sortie d'outils tiers), une injection de prompt réussie pourrait écrire du contenu malveillant dans le magasin. Les sessions ultérieures liraient alors ce contenu comme une mémoire de confiance. Utilisez `read_only` pour les documents de référence, les consultations partagées et tout magasin que l'agent n'a pas besoin de modifier.
</Warning>

Un maximum de **8 magasins de mémoire** est pris en charge par session. Attachez plusieurs magasins lorsque différentes parties de la mémoire ont des propriétaires ou des règles d'accès différents. Raisons courantes :

* **Documents de référence partagés :** un magasin en lecture seule attaché à de nombreuses sessions (normes, conventions, connaissances métier), séparé du magasin en lecture-écriture propre à chaque session.
* **Correspondance avec la structure de votre produit :** un magasin par utilisateur final, par équipe ou par projet, tout en partageant une configuration d'agent unique.
* **Cycles de vie différents :** un magasin qui survit à toute session individuelle, ou un magasin que vous souhaitez archiver selon son propre calendrier.

### Comment l'agent accède à la mémoire

Chaque magasin attaché est monté dans la sandbox de la session en tant que répertoire sous `/mnt/memory/`. Le nom du répertoire est le nom d'affichage du magasin converti en un slug compatible avec le système de fichiers (en minuscules ; les suites de caractères non alphanumériques deviennent un seul trait d'union), de sorte qu'un magasin nommé « Demo Memory » est monté sur `/mnt/memory/demo-memory/`. Le chemin exact est renvoyé dans le champ `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) de la ressource de magasin de mémoire de la session ; lisez-le à partir de là plutôt que de le construire vous-même. L'agent lit et écrit dans le magasin avec l'[ensemble d'outils de l'agent](https://platform.claude.com/docs/fr/managed-agents/tools) standard. Les écritures sous le chemin de montage sont persistées dans le magasin et restent synchronisées entre les sessions qui le partagent ; les écritures vers tout autre chemin sous `/mnt/memory/` échouent, car la sandbox monte ce répertoire parent en lecture seule. Une brève description de chaque montage (nom d'affichage, chemin de montage, mode d'accès, `description` (csharp, go: `Description`) du magasin et éventuelles `instructions` (csharp, go: `Instructions`)) est automatiquement ajoutée à l'invite système.

`access` (csharp, go: `Access`) est appliqué au niveau du système de fichiers : un montage `read_only` rejette les écritures, tandis que les écritures dans un montage `read_write` produisent des [versions de mémoire](https://platform.claude.com/docs/fr/managed-agents/memory#audit-memory-changes) attribuées à la session.

<Note>
  Sur les [sandboxes auto-hébergées](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory), le répertoire de chaque magasin est une copie locale gérée par le worker plutôt qu'un montage en direct. Le worker réconcilie chaque copie avec son magasin après les appels d'outils, au plus une fois par intervalle de synchronisation (15 secondes par défaut), et une fois de plus à la fin de la session. Les outils `write` et `edit` de l'agent ne modifient que la copie locale ; le worker téléverse ces modifications lors de sa prochaine synchronisation, de sorte qu'une autre session s'exécutant sur une sandbox auto-hébergée ne voit une modification qu'après la synchronisation des deux workers. Les chemins sous `/mnt/memory/` situés en dehors des répertoires des magasins n'y constituent pas un espace de travail temporaire : les outils de fichiers du worker refusent d'y écrire, et tout ce qu'une commande shell y écrit n'est jamais synchronisé avec un magasin.

  Pour un magasin `read_only`, les outils `write` et `edit` du worker refusent les modifications sous ce répertoire et le worker n'en téléverse jamais rien. Pour savoir comment le worker résout les conflits d'écriture, et ce que l'outil `bash` peut encore modifier dans la copie locale d'un magasin en lecture seule, consultez [Magasins en lecture seule et conflits](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory#read-only-stores-and-conflicts).
</Note>

Les lectures et écritures de l'agent apparaissent dans le [flux d'événements](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming) sous forme d'événements `agent.tool_use` et `agent.tool_result` ordinaires pour l'outil qui a touché le montage.

## Consulter et modifier les mémoires

Les magasins de mémoire peuvent être gérés directement via l'API. Utilisez cette possibilité pour créer des flux de révision, corriger de mauvaises mémoires ou alimenter des magasins avant toute exécution de session.

### Lister les mémoires

Listez les mémoires d'un magasin. Les résultats sont renvoyés dans un ordre stable défini par le serveur.

* `path_prefix` limite la liste à un seul répertoire. Il doit se terminer par `/` et correspond à des segments de chemin entiers, de sorte que `path_prefix=/notes/` renvoie `/notes/todo.md` mais pas `/notes-archive/todo.md`.
* `depth` contrôle la profondeur de la liste sous `path_prefix` : omettez-le (ou passez `0`) pour lister tout le sous-arbre, ou passez `1` pour ne lister que les enfants immédiats. Les autres valeurs renvoient une erreur `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>

Consultez la [référence Lister les mémoires](https://platform.claude.com/docs/fr/api/beta/memory_stores/memories/list) pour l'ensemble des paramètres et le schéma de réponse.

### Lire une mémoire

La récupération d'une mémoire individuelle renvoie le contenu complet.

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

Consultez la [référence Récupérer une mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/memories/retrieve) pour l'ensemble des paramètres et le schéma de réponse.

### Créer une mémoire

`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`) crée une mémoire à un `path` (csharp, go: `Path`) donné. La création n'écrase rien ; pour modifier une mémoire existante, [mettez-la à jour](https://platform.claude.com/docs/fr/managed-agents/memory#update-a-memory) avec `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>

Consultez la [référence Créer une mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/memories/create) pour l'ensemble des paramètres et le schéma de réponse.

### Mettre à jour une mémoire

`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`) modifie une mémoire existante par son ID. Vous pouvez modifier `content` (csharp, go: `Content`), `path` (csharp, go: `Path`) (un renommage), ou les deux. L'exemple renomme une mémoire vers un chemin d'archive :

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

Consultez la [référence Mettre à jour une mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/memories/update) pour l'ensemble des paramètres et le schéma de réponse.

#### Modifications de contenu sûres (concurrence optimiste)

Pour éviter d'écraser une écriture concurrente, passez une précondition `content_sha256`. La mise à jour ne s'applique que si le hachage du contenu stocké correspond toujours à celui que vous avez lu ; en cas de non-correspondance, relisez la mémoire et réessayez sur l'état actualisé.

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

### Supprimer une mémoire

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

Consultez la [référence Supprimer une mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/memories/delete) pour l'ensemble des paramètres et le schéma de réponse.

## Auditer les modifications de mémoire

Chaque mutation d'une mémoire crée une **version de mémoire** immuable (`memver_...`). Utilisez les points de terminaison de version pour auditer qui a modifié quoi et quand, pour inspecter ou restaurer un instantané antérieur, et pour effacer du contenu sensible de l'historique grâce au caviardage (redact).

Les versions appartiennent au magasin (et non à la mémoire individuelle) et ne sont pas supprimées lorsque la mémoire elle-même est supprimée, de sorte que la piste d'audit couvre également les mémoires supprimées, sous réserve de la durée de conservation décrite ci-dessous. Les versions sont conservées pendant 30 jours après leur écriture ; toutefois, les versions récentes d'une mémoire active sont toujours conservées quel que soit leur âge, de sorte que les mémoires qui changent rarement peuvent conserver un historique au-delà de 30 jours. L'appel en direct `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`) renvoie toujours la dernière version ; les points de terminaison de version vous donnent accès à l'historique conservé.

Il n'existe pas de point de terminaison de restauration dédié ; pour revenir en arrière, récupérez la version souhaitée et réécrivez son `content` (csharp, go: `Content`) avec `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`) (ou `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 mémoire parente a été supprimée, à condition que la version souhaitée soit toujours conservée).

Les anciennes versions de mémoire peuvent être supprimées après 30 jours. Pour préserver l'historique de mémoire plus longtemps, exportez les versions via l'API.

### Lister les versions

Listez l'historique des versions d'un magasin, de la plus récente à la plus ancienne. L'exemple filtre sur l'historique d'une seule mémoire :

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

Consultez la [référence Lister les versions de mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/memory_versions/list) pour l'ensemble des paramètres et le schéma de réponse.

### Récupérer une version

La récupération d'une version individuelle renvoie les mêmes champs que la réponse de liste, plus le corps complet 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>

Consultez la [référence Récupérer une version de mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/memory_versions/retrieve) pour l'ensemble des paramètres et le schéma de réponse.

### Caviarder une version

Le caviardage (redact) efface le contenu d'une version historique tout en préservant la piste d'audit (qui a fait quoi, quand). Utilisez-le pour les flux de conformité tels que la suppression de secrets divulgués, de données personnelles (PII) ou le traitement des demandes de suppression d'utilisateurs.

Une version qui est la tête actuelle d'une mémoire active ne peut pas être caviardée. Écrivez d'abord une nouvelle version (ou supprimez la mémoire), puis caviardez l'ancienne.

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

Consultez la [référence Caviarder une version de mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/memory_versions/redact) pour l'ensemble des paramètres et le schéma de réponse.

## Gérer les magasins de mémoire

En plus de [`create`](https://platform.claude.com/docs/fr/api/beta/memory_stores/create), les magasins de mémoire prennent en charge [`retrieve`](https://platform.claude.com/docs/fr/api/beta/memory_stores/retrieve), [`update`](https://platform.claude.com/docs/fr/api/beta/memory_stores/update), [`list`](https://platform.claude.com/docs/fr/api/beta/memory_stores/list), [`archive`](https://platform.claude.com/docs/fr/api/beta/memory_stores/archive) et [`delete`](https://platform.claude.com/docs/fr/api/beta/memory_stores/delete).

### Lister les magasins

Listez les magasins de l'espace de travail. Les magasins archivés sont exclus par défaut ; définissez `include_archived` (java, php: `includeArchived`; csharp, go: `IncludeArchived`) sur `true` pour les inclure.

<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 n'est défini que sur les magasins archivés.
      $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>

Consultez la [référence Lister les magasins de mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/list) pour l'ensemble des paramètres et le schéma de réponse.

### Archiver un magasin

L'archivage rend un magasin en lecture seule et empêche qu'il soit attaché à de nouvelles sessions. L'archivage est irréversible ; il n'existe pas de désarchivage.

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

Consultez la [référence Archiver un magasin de mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/archive) pour l'ensemble des paramètres et le schéma de réponse.

Pour [supprimer définitivement un magasin](https://platform.claude.com/docs/fr/api/beta/memory_stores/delete) ainsi que toutes ses mémoires et versions, appelez `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`).

## Bonnes pratiques de gestion de la mémoire

Lorsqu'un magasin atteint sa limite de 10 000 mémoires, les écritures de nouvelles mémoires échouent : aussi bien les appels directs à `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`) que les écritures de fichiers de l'agent vers des chemins non mappés. Les mémoires existantes restent lisibles et modifiables. Les pratiques suivantes vous aident à rester bien en deçà de la limite et à vous rétablir sans difficulté si vous l'atteignez.

* **Utilisez des magasins ciblés.** Plutôt qu'un seul grand magasin généraliste, utilisez des magasins plus petits conçus pour un usage précis : un par utilisateur, un pour les connaissances métier partagées et un pour le contexte propre au projet. Chaque magasin a sa propre limite de 10 000 mémoires, donc garder des magasins bien délimités réduit le risque que l'un d'eux se remplisse.

* **Condensez ou élaguez avant que le magasin ne se remplisse.** Supprimez les mémoires obsolètes ou redondantes avec `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`). Vous pouvez également exécuter une [session de rêve](https://platform.claude.com/docs/fr/managed-agents/dreams), qui consolide le contenu fragmenté dans un nouveau magasin de sortie distinct plutôt que de modifier l'original. Basculez vos sessions vers ce magasin de sortie, puis archivez ou supprimez l'original.

* **Attachez un nouveau magasin lorsque cela a du sens.** Si un magasin a dépassé son périmètre utile, attachez-en un nouveau pour le nouveau contenu et attachez l'original avec l'accès `read_only`. L'agent peut lire les deux tout en n'écrivant que dans le nouveau.

* **Limitez l'accès en écriture lorsque c'est approprié.** Les sessions qui ne font que lire des documents de référence partagés n'ont pas besoin de `read_write`. Restreindre l'accès en écriture aux sessions qui ajoutent réellement de nouvelles mémoires facilite le suivi de l'origine de la croissance.