---
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
  zdr:
    eligibility: not-eligible
    note: Non éligible à la ZDR, sauf pour Managed Agents auto-hébergé. Les sessions sont des ressources avec état ; les transcriptions persistent jusqu’à ce que vous les supprimiez.
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API:
      availability: beta
      note: L’envoi de `managed-agents-2026-04-01` avec `agent-memory-2026-07-22` lors d’un appel à un magasin de mémoire renvoie une erreur 400.
    Claude Platform on AWS:
      availability: beta
      note: Sur Claude Platform on AWS, les sessions sur des environnements auto-hébergés ne peuvent pas associer de magasins de mémoire. L’envoi de `managed-agents-2026-04-01` avec `agent-memory-2026-07-22` lors d’un appel à un magasin de mémoire renvoie une erreur 400.
    Claude Models on Google Cloud (Anthropic managed):
      availability: beta
      note: Sur Claude Models on Google Cloud (Anthropic managed), les magasins de mémoire ne sont pas pris en charge pour les sessions sur des environnements auto-hébergés. L’envoi de `managed-agents-2026-04-01` avec `agent-memory-2026-07-22` lors d’un appel à un magasin de mémoire renvoie une erreur 400.
---

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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{
      "name": "User Preferences",
      "description": "Per-user preferences and project context."
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply memory_store.yaml
    ```

    <File filename="memory_store.yaml">
      ```yaml
      # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/memory_store.json
      name: User Preferences
      description: Per-user preferences and project context.
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  store = client.beta.memory_stores.create(
      name="User Preferences",
      description="Per-user preferences and project context.",
  )
  print(store.id)  # memstore_01Hx...
  ```

  ```typescript TypeScript
  const store = await client.beta.memoryStores.create({
    name: "User Preferences",
    description: "Per-user preferences and project context."
  });
  console.log(store.id); // memstore_01Hx...
  ```

  ```csharp C#
  var store = await client.Beta.MemoryStores.Create(new()
  {
      Name = "User Preferences",
      Description = "Per-user preferences and project context.",
  });
  Console.WriteLine(store.ID);  // memstore_01Hx...
  ```

  ```go Go
  store, err := client.Beta.MemoryStores.New(ctx, anthropic.BetaMemoryStoreNewParams{
  	Name:        "User Preferences",
  	Description: anthropic.String("Per-user preferences and project context."),
  })
  if err != nil {
  	panic(err)
  }
  fmt.Println(store.ID) // memstore_01Hx...
  ```

  ```java Java
  var store = client.beta().memoryStores().create(
      MemoryStoreCreateParams.builder()
          .name("User Preferences")
          .description("Per-user preferences and project context.")
          .build()
  );
  IO.println(store.id());  // memstore_01Hx...
  ```

  ```php PHP
  use Anthropic\Client;

  $client = new Client();

  $store = $client->beta->memoryStores->create(
      name: 'User Preferences',
      description: 'Per-user preferences and project context.',
  );
  echo "{$store->id}\n"; // memstore_01Hx...
  ```

  ```ruby Ruby
  require "anthropic"

  client = Anthropic::Client.new

  store = client.beta.memory_stores.create(
    name: "User Preferences",
    description: "Per-user preferences and project context."
  )
  puts store.id # memstore_01Hx...
  ```
</CodeGroup>

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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{
      "path": "/formatting_standards.md",
      "content": "All reports use GAAP formatting. Dates are ISO-8601..."
    }'
  ```

  ```bash CLI
  ant beta:memory-stores:memories create \
    --memory-store-id "$store_id" \
    --path "/formatting_standards.md" \
    --content "All reports use GAAP formatting. Dates are ISO-8601..."
  ```

  ```python Python
  client.beta.memory_stores.memories.create(
      store.id,
      path="/formatting_standards.md",
      content="All reports use GAAP formatting. Dates are ISO-8601...",
  )
  ```

  ```typescript TypeScript
  await client.beta.memoryStores.memories.create(store.id, {
    path: "/formatting_standards.md",
    content: "All reports use GAAP formatting. Dates are ISO-8601..."
  });
  ```

  ```csharp C#
  await client.Beta.MemoryStores.Memories.Create(store.ID, new()
  {
      Path = "/formatting_standards.md",
      Content = "All reports use GAAP formatting. Dates are ISO-8601...",
  });
  ```

  ```go Go
  _, err = client.Beta.MemoryStores.Memories.New(ctx, store.ID, anthropic.BetaMemoryStoreMemoryNewParams{
  	Path:    "/formatting_standards.md",
  	Content: anthropic.String("All reports use GAAP formatting. Dates are ISO-8601..."),
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().memoryStores().memories().create(
      store.id(),
      MemoryCreateParams.builder()
          .path("/formatting_standards.md")
          .content("All reports use GAAP formatting. Dates are ISO-8601...")
          .build()
  );
  ```

  ```php PHP
  $client->beta->memoryStores->memories->create(
      $store->id,
      path: '/formatting_standards.md',
      content: 'All reports use GAAP formatting. Dates are ISO-8601...',
  );
  ```

  ```ruby Ruby
  client.beta.memory_stores.memories.create(
    store.id,
    path: "/formatting_standards.md",
    content: "All reports use GAAP formatting. Dates are ISO-8601..."
  )
  ```
</CodeGroup>

<Tip>
  Les mémoires individuelles d’un magasin sont limitées à 100 ko (\~25k tokens). Un magasin contient au maximum 10 000 mémoires. Structurez la mémoire sous forme de nombreux petits fichiers ciblés plutôt que de quelques fichiers volumineux.
</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: 2026-10-21" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "agent": "'"$agent_id"'",
      "environment_id": "'"$environment_id"'",
      "resources": [
        {
          "type": "memory_store",
          "memory_store_id": "'"$store_id"'",
          "access": "read_write",
          "instructions": "User preferences and project context. Check before starting any task."
        }
      ]
    }'
  ```

  ```bash CLI
  ant beta:sessions create <<YAML
  agent: $agent_id
  environment_id: $environment_id
  resources:
    - type: memory_store
      memory_store_id: $store_id
      access: read_write
      instructions: User preferences and project context. Check before starting any task.
  YAML
  ```

  ```python Python
  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      resources=[
          {
              "type": "memory_store",
              "memory_store_id": store.id,
              "access": "read_write",
              "instructions": "User preferences and project context. Check before starting any task.",
          }
      ],
  )
  ```

  ```typescript TypeScript
  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id,
    resources: [
      {
        type: "memory_store",
        memory_store_id: store.id,
        access: "read_write",
        instructions: "User preferences and project context. Check before starting any task."
      }
    ]
  });
  ```

  ```csharp C#
  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
      Resources =
      [
          new BetaManagedAgentsMemoryStoreResourceParam
          {
              MemoryStoreID = store.ID,
              Access = "read_write",
              Instructions = "User preferences and project context. Check before starting any task.",
          },
      ],
  });
  ```

  ```go Go
  session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfString: anthropic.String(agent.ID),
  	},
  	EnvironmentID: environment.ID,
  	Resources: []anthropic.BetaSessionNewParamsResourceUnion{{
  		OfMemoryStore: &anthropic.BetaManagedAgentsMemoryStoreResourceParam{
  			MemoryStoreID: store.ID,
  			Access:        anthropic.BetaManagedAgentsMemoryStoreResourceParamAccessReadWrite,
  			Instructions:  anthropic.String("User preferences and project context. Check before starting any task."),
  		},
  	}},
  })
  if err != nil {
  	panic(err)
  }
  ```

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

  ```php PHP
  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
      resources: [
          [
              'type' => 'memory_store',
              'memory_store_id' => $store->id,
              'access' => 'read_write',
              'instructions' => 'User preferences and project context. Check before starting any task.',
          ],
      ],
  );
  ```

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    resources: [
      {
        type: "memory_store",
        memory_store_id: store.id,
        access: "read_write",
        instructions: "User preferences and project context. Check before starting any task."
      }
    ]
  )
  ```
</CodeGroup>

<Warning>
  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 pour chaque 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 pour chaque utilisateur final, équipe ou projet, tout en partageant une seule configuration d’agent
* **Cycles de vie différents :** un magasin qui survit à toute session individuelle, ou que vous souhaitez archiver selon son propre calendrier

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

Chaque magasin attaché est monté dans le bac à sable de la session sous forme de 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, chaque suite de caractères non alphanumériques étant remplacée par 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 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 répercuté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 le bac à sable monte ce répertoire parent en lecture seule. Une courte 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 sur 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, le répertoire de chaque magasin est une copie locale que le worker synchronise avec le magasin, et non un montage en direct. Une modification n’atteint le magasin, et les autres sessions, que lors d’une synchronisation. Consultez [Comment le worker gère la mémoire](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory#how-the-worker-handles-memory) et [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 toute la sous-arborescence, 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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

  ```bash CLI
  ant beta:memory-stores:memories list \
    --memory-store-id "$store_id" \
    --path-prefix "/"
  ```

  ```python Python
  page = client.beta.memory_stores.memories.list(
      store.id,
      path_prefix="/",
  )
  for item in page.data:
      print(item.type, item.path)
  ```

  ```typescript TypeScript
  const page = await client.beta.memoryStores.memories.list(store.id, {
    path_prefix: "/"
  });
  for (const item of page.data) {
    console.log(item.type, item.path);
  }
  ```

  ```csharp C#
  var page = await client.Beta.MemoryStores.Memories.List(store.ID, new()
  {
      PathPrefix = "/",
  });
  await foreach (var item in page.Paginate())
  {
      var line = item.Match(
          memoryItem => $"memory  {memoryItem.Path}",
          prefixItem => $"memory_prefix  {prefixItem.Path}");
      Console.WriteLine(line);
  }
  ```

  ```go Go
  page, err := client.Beta.MemoryStores.Memories.List(ctx, store.ID, anthropic.BetaMemoryStoreMemoryListParams{
  	PathPrefix: anthropic.String("/"),
  })
  if err != nil {
  	panic(err)
  }
  for _, item := range page.Data {
  	fmt.Println(item.Type, item.Path)
  }
  ```

  ```java Java
  var page = client.beta().memoryStores().memories().list(
      store.id(),
      MemoryListParams.builder()
          .pathPrefix("/")
          .build()
  );
  for (var item : page.data()) {
      item.memory().ifPresent(memoryItem -> IO.println("memory  " + memoryItem.path()));
      item.memoryPrefix().ifPresent(prefixItem -> IO.println("memory_prefix  " + prefixItem.path()));
  }
  ```

  ```php PHP
  $page = $client->beta->memoryStores->memories->list(
      $store->id,
      pathPrefix: '/',
  );
  foreach ($page->data as $item) {
      echo "{$item->type}  {$item->path}\n";
  }
  ```

  ```ruby Ruby
  page = client.beta.memory_stores.memories.list(
    store.id,
    path_prefix: "/"
  )
  page.data.each do |entry|
    puts "#{entry.type}  #{entry.path}"
  end
  ```
</CodeGroup>

Consultez la référence [Lister les mémoires](https://platform.claude.com/docs/fr/api/beta/memory_stores/memories/list) pour connaître 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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

  ```bash CLI
  ant beta:memory-stores:memories retrieve \
    --memory-store-id "$store_id" \
    --memory-id "$mem_id"
  ```

  ```python Python
  retrieved = client.beta.memory_stores.memories.retrieve(
      mem.id,
      memory_store_id=store.id,
  )
  print(retrieved.content)
  ```

  ```typescript TypeScript
  const retrieved = await client.beta.memoryStores.memories.retrieve(mem.id, {
    memory_store_id: store.id
  });
  console.log(retrieved.content);
  ```

  ```csharp C#
  var retrieved = await client.Beta.MemoryStores.Memories.Retrieve(mem.ID, new()
  {
      MemoryStoreID = store.ID,
  });
  Console.WriteLine(retrieved.Content);
  ```

  ```go Go
  retrieved, err := client.Beta.MemoryStores.Memories.Get(ctx, mem.ID, anthropic.BetaMemoryStoreMemoryGetParams{
  	MemoryStoreID: store.ID,
  })
  if err != nil {
  	panic(err)
  }
  fmt.Println(retrieved.Content)
  ```

  ```java Java
  var retrieved = client.beta().memoryStores().memories().retrieve(
      mem.id(),
      MemoryRetrieveParams.builder()
          .memoryStoreId(store.id())
          .build()
  );
  IO.println(retrieved.content().orElseThrow());
  ```

  ```php PHP
  $retrieved = $client->beta->memoryStores->memories->retrieve($mem->id, memoryStoreID: $store->id);
  echo "{$retrieved->content}\n";
  ```

  ```ruby Ruby
  retrieved = client.beta.memory_stores.memories.retrieve(
    mem.id,
    memory_store_id: store.id
  )
  puts retrieved.content
  ```
</CodeGroup>

Consultez la référence [Récupérer une mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/memories/retrieve) pour connaître 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 pas de contenu existant ; pour [mettre à jour une mémoire existante](https://platform.claude.com/docs/fr/managed-agents/memory#update-a-memory), utilisez `POST /v1/memory_stores/{memory_store_id}/memories/{memory_id}` (python, ruby: `client.beta.memory_stores.memories.update()`; typescript: `client.beta.memoryStores.memories.update()`; go, csharp: `client.Beta.MemoryStores.Memories.Update()`; java: `client.beta().memoryStores().memories().update()`; php: `$client->beta->memoryStores->memories->update()`; cli: `ant beta:memory-stores:memories update`).

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memories" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{
      "path": "/preferences/formatting.md",
      "content": "Always use tabs, not spaces."
    }'
  ```

  ```bash CLI
  ant beta:memory-stores:memories create \
    --memory-store-id "$store_id" \
    --path "/preferences/formatting.md" \
    --content "Always use tabs, not spaces."
  ```

  ```python Python
  mem = client.beta.memory_stores.memories.create(
      store.id,
      path="/preferences/formatting.md",
      content="Always use tabs, not spaces.",
  )
  ```

  ```typescript TypeScript
  const mem = await client.beta.memoryStores.memories.create(store.id, {
    path: "/preferences/formatting.md",
    content: "Always use tabs, not spaces."
  });
  ```

  ```csharp C#
  var mem = await client.Beta.MemoryStores.Memories.Create(store.ID, new()
  {
      Path = "/preferences/formatting.md",
      Content = "Always use tabs, not spaces.",
  });
  ```

  ```go Go
  mem, err := client.Beta.MemoryStores.Memories.New(ctx, store.ID, anthropic.BetaMemoryStoreMemoryNewParams{
  	Path:    "/preferences/formatting.md",
  	Content: anthropic.String("Always use tabs, not spaces."),
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  var mem = client.beta().memoryStores().memories().create(
      store.id(),
      MemoryCreateParams.builder()
          .path("/preferences/formatting.md")
          .content("Always use tabs, not spaces.")
          .build()
  );
  ```

  ```php PHP
  $mem = $client->beta->memoryStores->memories->create(
      $store->id,
      path: '/preferences/formatting.md',
      content: 'Always use tabs, not spaces.',
  );
  ```

  ```ruby Ruby
  mem = client.beta.memory_stores.memories.create(
    store.id,
    path: "/preferences/formatting.md",
    content: "Always use tabs, not spaces."
  )
  ```
</CodeGroup>

Consultez la référence [Créer une mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/memories/create) pour connaître 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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{"path": "/archive/2026_q1_formatting.md"}'
  ```

  ```bash CLI
  ant beta:memory-stores:memories update \
    --memory-store-id "$store_id" \
    --memory-id "$mem_id" \
    --path "/archive/2026_q1_formatting.md"
  ```

  ```python Python
  client.beta.memory_stores.memories.update(
      mem.id,
      memory_store_id=store.id,
      path="/archive/2026_q1_formatting.md",
  )
  ```

  ```typescript TypeScript
  await client.beta.memoryStores.memories.update(mem.id, {
    memory_store_id: store.id,
    path: "/archive/2026_q1_formatting.md"
  });
  ```

  ```csharp C#
  await client.Beta.MemoryStores.Memories.Update(mem.ID, new()
  {
      MemoryStoreID = store.ID,
      Path = "/archive/2026_q1_formatting.md",
  });
  ```

  ```go Go
  _, err = client.Beta.MemoryStores.Memories.Update(ctx, mem.ID, anthropic.BetaMemoryStoreMemoryUpdateParams{
  	MemoryStoreID: store.ID,
  	Path:          anthropic.String("/archive/2026_q1_formatting.md"),
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().memoryStores().memories().update(
      mem.id(),
      MemoryUpdateParams.builder()
          .memoryStoreId(store.id())
          .path("/archive/2026_q1_formatting.md")
          .build()
  );
  ```

  ```php PHP
  $client->beta->memoryStores->memories->update(
      $mem->id,
      memoryStoreID: $store->id,
      path: '/archive/2026_q1_formatting.md',
  );
  ```

  ```ruby Ruby
  client.beta.memory_stores.memories.update(
    mem.id,
    memory_store_id: store.id,
    path: "/archive/2026_q1_formatting.md"
  )
  ```
</CodeGroup>

Consultez la référence [Mettre à jour une mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/memories/update) pour connaître 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 à partir de 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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{
      "content": "CORRECTED: Always use 2-space indentation.",
      "precondition": {"type": "content_sha256", "content_sha256": "'"$mem_sha"'"}
    }'
  ```

  ```bash CLI
  ant beta:memory-stores:memories update \
    --memory-store-id "$store_id" \
    --memory-id "$mem_id" \
    --content "CORRECTED: Always use 2-space indentation." \
    --precondition "{type: content_sha256, content_sha256: $mem_sha}"
  ```

  ```python Python
  client.beta.memory_stores.memories.update(
      memory_id=mem.id,
      memory_store_id=store.id,
      content="CORRECTED: Always use 2-space indentation.",
      precondition={"type": "content_sha256", "content_sha256": mem.content_sha256},
  )
  ```

  ```typescript TypeScript
  await client.beta.memoryStores.memories.update(mem.id, {
    memory_store_id: store.id,
    content: "CORRECTED: Always use 2-space indentation.",
    precondition: { type: "content_sha256", content_sha256: mem.content_sha256 }
  });
  ```

  ```csharp C#
  await client.Beta.MemoryStores.Memories.Update(mem.ID, new()
  {
      MemoryStoreID = store.ID,
      Content = "CORRECTED: Always use 2-space indentation.",
      Precondition = new BetaManagedAgentsPrecondition { ContentSha256 = mem.ContentSha256 },
  });
  ```

  ```go Go
  _, err = client.Beta.MemoryStores.Memories.Update(ctx, mem.ID, anthropic.BetaMemoryStoreMemoryUpdateParams{
  	MemoryStoreID: store.ID,
  	Content:       anthropic.String("CORRECTED: Always use 2-space indentation."),
  	Precondition: anthropic.BetaManagedAgentsPreconditionParam{
  		ContentSha256: anthropic.String(mem.ContentSha256),
  	},
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().memoryStores().memories().update(
      mem.id(),
      MemoryUpdateParams.builder()
          .memoryStoreId(store.id())
          .content("CORRECTED: Always use 2-space indentation.")
          .precondition(
              BetaManagedAgentsPrecondition.builder()
                  .contentSha256(mem.contentSha256())
                  .build()
          )
          .build()
  );
  ```

  ```php PHP
  $client->beta->memoryStores->memories->update(
      $mem->id,
      memoryStoreID: $store->id,
      content: 'CORRECTED: Always use 2-space indentation.',
      precondition: ['type' => 'content_sha256', 'content_sha256' => $mem->contentSha256],
  );
  ```

  ```ruby Ruby
  client.beta.memory_stores.memories.update(
    mem.id,
    memory_store_id: store.id,
    content: "CORRECTED: Always use 2-space indentation.",
    precondition: {type: "content_sha256", content_sha256: mem.content_sha256}
  )
  ```
</CodeGroup>

### 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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

  ```bash CLI
  ant beta:memory-stores:memories delete \
    --memory-store-id "$store_id" \
    --memory-id "$mem_id"
  ```

  ```python Python
  client.beta.memory_stores.memories.delete(
      mem.id,
      memory_store_id=store.id,
  )
  ```

  ```typescript TypeScript
  await client.beta.memoryStores.memories.delete(mem.id, {
    memory_store_id: store.id
  });
  ```

  ```csharp C#
  await client.Beta.MemoryStores.Memories.Delete(mem.ID, new()
  {
      MemoryStoreID = store.ID,
  });
  ```

  ```go Go
  _, err = client.Beta.MemoryStores.Memories.Delete(ctx, mem.ID, anthropic.BetaMemoryStoreMemoryDeleteParams{
  	MemoryStoreID: store.ID,
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().memoryStores().memories().delete(
      mem.id(),
      MemoryDeleteParams.builder()
          .memoryStoreId(store.id())
          .build()
  );
  ```

  ```php PHP
  $client->beta->memoryStores->memories->delete($mem->id, memoryStoreID: $store->id);
  ```

  ```ruby Ruby
  client.beta.memory_stores.memories.delete(
    mem.id,
    memory_store_id: store.id
  )
  ```
</CodeGroup>

Consultez la référence [Supprimer une mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/memories/delete) pour connaître 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 ; la piste d’audit couvre donc également les mémoires supprimées, sous réserve de la durée de conservation décrite ci-après. 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 rarement modifiées peuvent conserver un historique au-delà de 30 jours. L’appel `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`) sur la mémoire active renvoie toujours la dernière version ; les points de terminaison de versions vous donnent 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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

  ```bash CLI
  ant beta:memory-stores:memory-versions list \
    --memory-store-id "$store_id" \
    --memory-id "$mem_id" \
    --format json
  ```

  ```python Python
  versions = client.beta.memory_stores.memory_versions.list(
      store.id,
      memory_id=mem.id,
  )
  for version in versions:
      print(f"{version.id}: {version.operation}")

  version_id = versions.data[1].id
  ```

  ```typescript TypeScript
  const versions = await client.beta.memoryStores.memoryVersions.list(store.id, {
    memory_id: mem.id
  });
  for await (const memoryVersion of versions) {
    console.log(`${memoryVersion.id}: ${memoryVersion.operation}`);
  }

  const versionId = versions.data[1].id;
  ```

  ```csharp C#
  var versions = await client.Beta.MemoryStores.MemoryVersions.List(store.ID, new()
  {
      MemoryID = mem.ID,
  });
  var versionIds = new List<string>();
  await foreach (var memoryVersion in versions.Paginate())
  {
      Console.WriteLine($"{memoryVersion.ID}: {memoryVersion.Operation.Raw()}");
      versionIds.Add(memoryVersion.ID);
  }

  var versionId = versionIds[1];
  ```

  ```go Go
  versions := client.Beta.MemoryStores.MemoryVersions.ListAutoPaging(ctx, store.ID, anthropic.BetaMemoryStoreMemoryVersionListParams{
  	MemoryID: anthropic.String(mem.ID),
  })
  for versions.Next() {
  	memoryVersion := versions.Current()
  	fmt.Printf("%s: %s\n", memoryVersion.ID, memoryVersion.Operation)
  }
  if err := versions.Err(); err != nil {
  	panic(err)
  }

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

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

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

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

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

  ```ruby Ruby
  versions = client.beta.memory_stores.memory_versions.list(
    store.id,
    memory_id: mem.id
  )
  versions.auto_paging_each do |version|
    puts "#{version.id}: #{version.operation}"
  end

  version_id = versions.data[1].id
  ```
</CodeGroup>

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 connaître 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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

  ```bash CLI
  ant beta:memory-stores:memory-versions retrieve \
    --memory-store-id "$store_id" \
    --memory-version-id "$version_id"
  ```

  ```python Python
  version = client.beta.memory_stores.memory_versions.retrieve(
      version_id,
      memory_store_id=store.id,
  )
  print(version.content)
  ```

  ```typescript TypeScript
  const version = await client.beta.memoryStores.memoryVersions.retrieve(versionId, {
    memory_store_id: store.id
  });
  console.log(version.content);
  ```

  ```csharp C#
  var version = await client.Beta.MemoryStores.MemoryVersions.Retrieve(versionId, new()
  {
      MemoryStoreID = store.ID,
  });
  Console.WriteLine(version.Content);
  ```

  ```go Go
  version, err := client.Beta.MemoryStores.MemoryVersions.Get(ctx, versionID, anthropic.BetaMemoryStoreMemoryVersionGetParams{
  	MemoryStoreID: store.ID,
  })
  if err != nil {
  	panic(err)
  }
  fmt.Println(version.Content)
  ```

  ```java Java
  var version = client.beta().memoryStores().memoryVersions().retrieve(
      versionId,
      MemoryVersionRetrieveParams.builder()
          .memoryStoreId(store.id())
          .build()
  );
  IO.println(version.content().orElseThrow());
  ```

  ```php PHP
  $version = $client->beta->memoryStores->memoryVersions->retrieve(
      $versionId,
      memoryStoreID: $store->id,
  );
  echo "{$version->content}\n";
  ```

  ```ruby Ruby
  version = client.beta.memory_stores.memory_versions.retrieve(
    version_id,
    memory_store_id: store.id
  )
  puts version.content
  ```
</CodeGroup>

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 connaître 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, et quand). Utilisez-le pour les flux de travail de conformité, comme la suppression de secrets ou de données personnelles divulgués, ou pour répondre aux demandes de suppression des 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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{}'
  ```

  ```bash CLI
  ant beta:memory-stores:memory-versions redact \
    --memory-store-id "$store_id" \
    --memory-version-id "$version_id"
  ```

  ```python Python
  client.beta.memory_stores.memory_versions.redact(
      version_id,
      memory_store_id=store.id,
  )
  ```

  ```typescript TypeScript
  await client.beta.memoryStores.memoryVersions.redact(versionId, {
    memory_store_id: store.id
  });
  ```

  ```csharp C#
  await client.Beta.MemoryStores.MemoryVersions.Redact(versionId, new()
  {
      MemoryStoreID = store.ID,
  });
  ```

  ```go Go
  _, err = client.Beta.MemoryStores.MemoryVersions.Redact(ctx, versionID, anthropic.BetaMemoryStoreMemoryVersionRedactParams{
  	MemoryStoreID: store.ID,
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().memoryStores().memoryVersions().redact(
      versionId,
      MemoryVersionRedactParams.builder()
          .memoryStoreId(store.id())
          .build()
  );
  ```

  ```php PHP
  $client->beta->memoryStores->memoryVersions->redact(
      $versionId,
      memoryStoreID: $store->id,
  );
  ```

  ```ruby Ruby
  client.beta.memory_stores.memory_versions.redact(
    version_id,
    memory_store_id: store.id
  )
  ```
</CodeGroup>

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 connaître 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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

  ```bash CLI
  ant beta:memory-stores list --include-archived
  ```

  ```python Python
  for memory_store in client.beta.memory_stores.list(include_archived=True):
      print(memory_store.id, memory_store.name, memory_store.archived_at)
  ```

  ```typescript TypeScript
  for await (const memoryStore of client.beta.memoryStores.list({ include_archived: true })) {
    console.log(memoryStore.id, memoryStore.name, memoryStore.archived_at);
  }
  ```

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

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

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

  ```php PHP
  foreach ($client->beta->memoryStores->list(includeArchived: true)->pagingEachItem() as $memoryStore) {
      // archivedAt n'est défini que sur les magasins archivés.
      $archivedAt = isset($memoryStore->archivedAt) ? $memoryStore->archivedAt->format(DATE_ATOM) : '';
      echo "{$memoryStore->id} {$memoryStore->name} {$archivedAt}\n";
  }
  ```

  ```ruby Ruby
  client.beta.memory_stores.list(include_archived: true).auto_paging_each do |memory_store|
    puts "#{memory_store.id} #{memory_store.name} #{memory_store.archived_at}"
  end
  ```
</CodeGroup>

Consultez la référence [Lister les magasins de mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/list) pour connaître 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: 2026-10-21" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

  ```bash CLI
  ant beta:memory-stores archive --memory-store-id "$store_id"
  ```

  ```python Python
  client.beta.memory_stores.archive(store.id)
  ```

  ```typescript TypeScript
  await client.beta.memoryStores.archive(store.id);
  ```

  ```csharp C#
  await client.Beta.MemoryStores.Archive(store.ID);
  ```

  ```go Go
  _, err = client.Beta.MemoryStores.Archive(ctx, store.ID, anthropic.BetaMemoryStoreArchiveParams{})
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().memoryStores().archive(store.id());
  ```

  ```php PHP
  $client->beta->memoryStores->archive($store->id);
  ```

  ```ruby Ruby
  client.beta.memory_stores.archive(store.id)
  ```
</CodeGroup>

Consultez la référence [Archiver un magasin de mémoire](https://platform.claude.com/docs/fr/api/beta/memory_stores/archive) pour connaître 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 polyvalent, utilisez des magasins plus petits et dédiés : un pour chaque utilisateur, un pour les connaissances métier partagées et un pour le contexte propre au projet. Chaque magasin dispose de sa propre limite de 10 000 mémoires ; maintenir des magasins bien délimités réduit donc 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.

## Disponibilité

Magasins de mémoire sont en bêta sur tous les modèles.

### Prise en charge de l’API

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

* Disponibilité : Disponible

| Statut | Plateformes cloud |
| ----- | ----- |
| Bêta<sup>1</sup> | Claude API |
| Bêta<sup>2</sup> | [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws) |
| Bêta<sup>3</sup> | [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed) |

1. L’envoi de `managed-agents-2026-04-01` avec `agent-memory-2026-07-22` lors d’un appel à un magasin de mémoire renvoie une erreur 400.
2. Sur Claude Platform on AWS, les sessions sur des environnements auto-hébergés ne peuvent pas associer de magasins de mémoire. L’envoi de `managed-agents-2026-04-01` avec `agent-memory-2026-07-22` lors d’un appel à un magasin de mémoire renvoie une erreur 400.
3. Sur Claude Models on Google Cloud (Anthropic managed), les magasins de mémoire ne sont pas pris en charge pour les sessions sur des environnements auto-hébergés. L’envoi de `managed-agents-2026-04-01` avec `agent-memory-2026-07-22` lors d’un appel à un magasin de mémoire renvoie une erreur 400.

### En-têtes bêta requis

[Présentation des en-têtes bêta](https://platform.claude.com/docs/fr/api/beta-headers)

Les en-têtes bêta vous permettent d’accéder à des fonctionnalités expérimentales et à de nouvelles capacités des modèles avant qu’elles ne fassent partie de l’API standard.

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

### Traitement des données

[Présentation du traitement des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention#feature-eligibility)

| Élément | Zéro conservation des données | HIPAA |
| ----- | ----- | ----- |
| Statut | Non éligible | Non éligible |
| Détails | Non éligible à la ZDR, sauf pour Managed Agents auto-hébergé. Les sessions sont des ressources avec état ; les transcriptions persistent jusqu’à ce que vous les supprimiez. [En savoir plus](https://platform.claude.com/docs/fr/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | Non éligible à HIPAA. S’applique à toutes les sous-fonctionnalités de Managed Agents. |

Points de terminaison concernés :

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