---
title: Usare la memoria degli agenti
url: https://platform.claude.com/docs/it/managed-agents/memory
description: Fornisci ai tuoi agenti una memoria persistente che sopravvive tra le sessioni utilizzando i memory store.
featureMetadata:
  status: beta
  betaHeader: agent-memory-2026-07-22
---

Ogni sessione di Managed Agents inizia per impostazione predefinita con un contesto nuovo. Quando una sessione termina, qualsiasi stato che l'agente ha costruito va perso. I "memory store" (archivi di memoria) consentono all'agente di trasportare informazioni tra le sessioni: preferenze dell'utente, convenzioni di progetto, errori precedenti e contesto di dominio.

<Note>
  Non combinare `agent-memory-2026-07-22` con `managed-agents-2026-04-01` in una richiesta relativa a un memory store: inviarli entrambi restituisce un errore `400`. Se il tuo codice imposta esplicitamente gli header beta, sostituisci `managed-agents-2026-04-01` con `agent-memory-2026-07-22` nelle chiamate ai memory store invece di aggiungere un secondo valore. Gli endpoint delle sessioni, incluso il collegamento di un memory store a una sessione, usano ancora `managed-agents-2026-04-01`.

  `GET /v1/memory_stores/{memory_store_id}/memories` si comporta allo stesso modo con entrambi gli header: i risultati vengono restituiti in un ordine stabile definito dal server, e `path_prefix` e `depth` si applicano nello stesso modo.
</Note>

## Panoramica

Un **memory store** (archivio di memoria) è una raccolta di documenti di testo con ambito a livello di workspace, ottimizzata per Claude. Quando colleghi uno store a una sessione, viene montato come directory all'interno della sandbox della sessione. L'agente lo legge e lo scrive con gli stessi strumenti per i file che usa per il resto del filesystem, e una nota che descrive ogni mount viene aggiunta automaticamente al prompt di sistema, indicando all'agente dove cercare. Il [toolset dell'agente](https://platform.claude.com/docs/it/managed-agents/tools) è necessario per queste interazioni; assicurati di abilitarlo durante la [creazione dell'agente](https://platform.claude.com/docs/it/managed-agents/agent-setup). Sulle [sandbox self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes-memory), quella directory non è un mount attivo. Invece, il worker del tuo ambiente scarica ogni store collegato nella tua sandbox prima che gli strumenti dell'agente vengano eseguiti e mantiene quella copia sincronizzata con lo store.

Ogni **memory** (memoria) in uno store è indirizzata da un percorso e può essere letta e modificata direttamente tramite l'API o la Claude Console, consentendo messa a punto, importazione ed esportazione.

Ogni modifica a una memoria crea una **memory version** (versione della memoria) immutabile, fornendoti una traccia di audit e un ripristino point-in-time per tutto ciò che l'agente scrive.

## Crea un memory store

Assegna allo store un `name` (csharp, go: `Name`) e una `description` (csharp, go: `Description`). La descrizione viene passata all'agente, indicandogli cosa contiene lo store.

<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`) del memory store (`memstore_...`) è ciò che passi quando colleghi lo store a una sessione.

### Popolalo con contenuti (opzionale)

Precarica uno store con materiale di riferimento prima che qualsiasi agente venga eseguito:

<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>
  Le singole memorie all'interno dello store hanno un limite di 100 kB (\~25k token). Uno store contiene un massimo di 10.000 memorie. Struttura la memoria come molti file piccoli e mirati, non pochi file grandi.
</Tip>

## Collega un memory store a una sessione

I memory store vengono collegati nell'array `resources` (csharp, go: `Resources`) della sessione quando la [sessione viene creata](https://platform.claude.com/docs/it/managed-agents/sessions#creating-a-session). A differenza delle risorse file, i memory store possono essere collegati solo al momento della creazione della sessione; aggiungerne o rimuoverne uno da una sessione in esecuzione non è supportato. I memory store si collegano allo stesso modo per le sessioni su ambienti cloud e [self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes-memory); gli ambienti self-hosted accettano solo risorse `memory_store`.

Facoltativamente, includi `instructions` (csharp, go: `Instructions`) per fornire indicazioni specifiche della sessione su come l'agente dovrebbe usare questo store. Vengono mostrate all'agente insieme al `name` (csharp, go: `Name`) e alla `description` (csharp, go: `Description`) dello store, e sono limitate a 4.096 caratteri.

Puoi configurare anche `access` (csharp, go: `Access`). Il valore predefinito è `read_write` (mostrato esplicitamente nell'esempio seguente), ma è supportato anche `read_only`.

<CodeGroup>
  ```bash cURL
  curl -s https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    --data '{
      "agent": "'"$agent_id"'",
      "environment_id": "'"$environment_id"'",
      "resources": [
        {
          "type": "memory_store",
          "memory_store_id": "'"$store_id"'",
          "access": "read_write",
          "instructions": "User preferences and project context. Check before starting any task."
        }
      ]
    }'
  ```

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

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

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

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

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

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

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

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

<Warning>
  I memory store vengono collegati con accesso `read_write` per impostazione predefinita. Se l'agente elabora input non attendibili (prompt forniti dall'utente, contenuti web recuperati o output di strumenti di terze parti), una prompt injection riuscita potrebbe scrivere contenuti dannosi nello store. Le sessioni successive leggerebbero poi quel contenuto come memoria attendibile. Usa `read_only` per materiale di riferimento, consultazioni condivise e qualsiasi store che l'agente non ha bisogno di modificare.
</Warning>

È supportato un massimo di **8 memory store** per sessione. Collega più store quando parti diverse della memoria hanno proprietari o regole di accesso differenti. Motivi comuni:

* **Materiale di riferimento condiviso:** uno store in sola lettura collegato a molte sessioni (standard, convenzioni, conoscenza di dominio), tenuto separato dallo store in lettura-scrittura proprio di ciascuna sessione.
* **Mappatura sulla struttura del tuo prodotto:** uno store per utente finale, per team o per progetto, condividendo una singola configurazione dell'agente.
* **Cicli di vita diversi:** uno store che sopravvive a qualsiasi singola sessione, o uno che vuoi archiviare secondo una propria pianificazione.

### Come l'agente accede alla memoria

Ogni store collegato viene montato all'interno della sandbox della sessione come directory sotto `/mnt/memory/`. Il nome della directory è il nome visualizzato dello store convertito in uno slug sicuro per il filesystem (in minuscolo; le sequenze di caratteri non alfanumerici diventano un singolo trattino), quindi uno store chiamato "Demo Memory" viene montato in `/mnt/memory/demo-memory/`. Il percorso esatto viene restituito nel campo `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) della risorsa memory store della sessione; leggilo da lì invece di costruirlo tu stesso. L'agente legge e scrive lo store con il [toolset dell'agente](https://platform.claude.com/docs/it/managed-agents/tools) standard. Le scritture sotto il percorso di mount vengono salvate nello store e restano sincronizzate tra le sessioni che lo condividono; le scritture in qualsiasi altro percorso sotto `/mnt/memory/` falliscono, perché la sandbox monta quella directory padre in sola lettura. Una breve descrizione di ciascun mount (nome visualizzato, percorso di mount, modalità di accesso, `description` (csharp, go: `Description`) dello store ed eventuali `instructions` (csharp, go: `Instructions`)) viene aggiunta automaticamente al prompt di sistema.

`access` (csharp, go: `Access`) viene applicato a livello di filesystem: un mount `read_only` rifiuta le scritture, mentre le scritture su un mount `read_write` producono [versioni della memoria](https://platform.claude.com/docs/it/managed-agents/memory#audit-memory-changes) attribuite alla sessione.

<Note>
  Sulle [sandbox self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes-memory), la directory di ogni store è una copia locale gestita dal worker anziché un mount attivo. Il worker riconcilia ogni copia con il relativo store dopo le chiamate agli strumenti, al massimo una volta per intervallo di sincronizzazione (15 secondi per impostazione predefinita), e un'ultima volta quando la sessione termina. Gli strumenti `write` ed `edit` dell'agente modificano solo la copia locale; il worker carica tali modifiche alla sincronizzazione successiva, quindi un'altra sessione in esecuzione su una sandbox self-hosted vede una modifica solo dopo che entrambi i worker si sono sincronizzati. I percorsi sotto `/mnt/memory/` al di fuori delle directory degli store non sono spazio temporaneo in quel caso: gli strumenti per i file del worker si rifiutano di scriverci, e tutto ciò che un comando shell vi scrive non viene mai sincronizzato con uno store.

  Per uno store `read_only`, gli strumenti `write` ed `edit` del worker rifiutano le modifiche sotto quella directory e il worker non carica mai nulla da essa. Per scoprire come il worker risolve i conflitti di scrittura e cosa lo strumento `bash` può ancora modificare nella copia locale di uno store di sola lettura, consulta [Store di sola lettura e conflitti](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes-memory#read-only-stores-and-conflicts).
</Note>

Le letture e scritture dell'agente appaiono nel [flusso di eventi](https://platform.claude.com/docs/it/managed-agents/events-and-streaming) come normali eventi `agent.tool_use` e `agent.tool_result` per qualunque strumento abbia toccato il mount.

## Visualizza e modifica le memorie

I memory store possono essere gestiti direttamente tramite l'API. Usalo per costruire flussi di revisione, correggere memorie errate o popolare gli store prima che qualsiasi sessione venga eseguita.

### Elenca le memorie

Elenca le memorie in uno store. I risultati vengono restituiti in un ordine stabile definito dal server.

* `path_prefix` limita l'elenco a una directory. Deve terminare con `/` e corrisponde a segmenti di percorso interi, quindi `path_prefix=/notes/` restituisce `/notes/todo.md` ma non `/notes-archive/todo.md`.
* `depth` controlla quanto in profondità va l'elenco sotto `path_prefix`: omettilo (o passa `0`) per elencare l'intero sottoalbero, oppure passa `1` per elencare solo i figli immediati. Altri valori restituiscono un errore `400`.

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memories?path_prefix=/" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

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

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

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

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

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

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

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

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

Consulta il [riferimento Elenca memorie](https://platform.claude.com/docs/it/api/beta/memory_stores/memories/list) per i parametri completi e lo schema della risposta.

### Leggi una memoria

Il recupero di una singola memoria restituisce il contenuto completo.

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memories/$mem_id" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

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

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

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

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

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

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

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

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

Consulta il [riferimento Recupera una memoria](https://platform.claude.com/docs/it/api/beta/memory_stores/memories/retrieve) per i parametri completi e lo schema della risposta.

### Crea una memoria

`POST /v1/memory_stores/{memory_store_id}/memories` (python, ruby: `client.beta.memory_stores.memories.create()`; typescript: `client.beta.memoryStores.memories.create()`; go: `client.Beta.MemoryStores.Memories.New()`; java: `client.beta().memoryStores().memories().create()`; csharp: `client.Beta.MemoryStores.Memories.Create()`; php: `$client->beta->memoryStores->memories->create()`; cli: `ant beta:memory-stores:memories create`) crea una memoria in un determinato `path` (csharp, go: `Path`). La creazione non sovrascrive; per modificare una memoria esistente, [aggiornala](https://platform.claude.com/docs/it/managed-agents/memory#update-a-memory) con `POST /v1/memory_stores/{memory_store_id}/memories/{memory_id}` (python, ruby: `client.beta.memory_stores.memories.update()`; typescript: `client.beta.memoryStores.memories.update()`; go, csharp: `client.Beta.MemoryStores.Memories.Update()`; java: `client.beta().memoryStores().memories().update()`; php: `$client->beta->memoryStores->memories->update()`; cli: `ant beta:memory-stores:memories update`).

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

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

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

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

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

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

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

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

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

Consulta il [riferimento Crea una memoria](https://platform.claude.com/docs/it/api/beta/memory_stores/memories/create) per i parametri completi e lo schema della risposta.

### Aggiorna una memoria

`POST /v1/memory_stores/{memory_store_id}/memories/{memory_id}` (python, ruby: `client.beta.memory_stores.memories.update()`; typescript: `client.beta.memoryStores.memories.update()`; go, csharp: `client.Beta.MemoryStores.Memories.Update()`; java: `client.beta().memoryStores().memories().update()`; php: `$client->beta->memoryStores->memories->update()`; cli: `ant beta:memory-stores:memories update`) modifica una memoria esistente tramite ID. Puoi modificare `content` (csharp, go: `Content`), `path` (csharp, go: `Path`) (una ridenominazione) o entrambi. L'esempio rinomina una memoria spostandola in un percorso di archivio:

<CodeGroup>
  ```bash cURL
  curl -s -X POST "https://api.anthropic.com/v1/memory_stores/$store_id/memories/$mem_id" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{"path": "/archive/2026_q1_formatting.md"}'
  ```

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

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

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

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

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

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

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

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

Consulta il [riferimento Aggiorna una memoria](https://platform.claude.com/docs/it/api/beta/memory_stores/memories/update) per i parametri completi e lo schema della risposta.

#### Modifiche sicure del contenuto (concorrenza ottimistica)

Per evitare di sovrascrivere una scrittura concorrente, passa una precondizione `content_sha256`. L'aggiornamento viene applicato solo se l'hash del contenuto memorizzato corrisponde ancora a quello che hai letto; in caso di mancata corrispondenza, rileggi la memoria e riprova rispetto allo stato aggiornato.

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

### Elimina una memoria

<CodeGroup>
  ```bash cURL
  curl -s -X DELETE "https://api.anthropic.com/v1/memory_stores/$store_id/memories/$mem_id" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

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

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

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

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

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

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

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

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

Consulta il [riferimento Elimina una memoria](https://platform.claude.com/docs/it/api/beta/memory_stores/memories/delete) per i parametri completi e lo schema della risposta.

## Verifica le modifiche alla memoria

Ogni mutazione di una memoria crea una **memory version** immutabile (`memver_...`). Usa gli endpoint delle versioni per verificare chi ha cambiato cosa e quando, per ispezionare o ripristinare uno snapshot precedente, e per rimuovere contenuti sensibili dalla cronologia con redact.

Le versioni appartengono allo store (non alla singola memoria) e non vengono eliminate quando la memoria stessa viene eliminata, quindi la traccia di audit copre anche le memorie eliminate, nei limiti della conservazione descritta di seguito. Le versioni vengono conservate per 30 giorni dopo essere state scritte; tuttavia, le versioni recenti di una memoria attiva vengono sempre mantenute indipendentemente dalla loro età, quindi le memorie che cambiano raramente potrebbero conservare una cronologia oltre i 30 giorni. La chiamata attiva `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`) restituisce sempre la versione più recente; gli endpoint delle versioni ti forniscono la cronologia conservata.

Non esiste un endpoint di ripristino dedicato; per tornare indietro, recupera la versione desiderata e riscrivi il suo `content` (csharp, go: `Content`) con `POST /v1/memory_stores/{memory_store_id}/memories/{memory_id}` (python, ruby: `client.beta.memory_stores.memories.update()`; typescript: `client.beta.memoryStores.memories.update()`; go, csharp: `client.Beta.MemoryStores.Memories.Update()`; java: `client.beta().memoryStores().memories().update()`; php: `$client->beta->memoryStores->memories->update()`; cli: `ant beta:memory-stores:memories update`) (oppure `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`) se la memoria padre è stata eliminata, a condizione che la versione desiderata sia ancora conservata).

Le versioni passate delle memorie potrebbero essere eliminate dopo 30 giorni. Per preservare la cronologia della memoria più a lungo, esporta le versioni tramite l'API.

### Elenca le versioni

Elenca la cronologia delle versioni di uno store, dalla più recente. L'esempio filtra la cronologia di una singola memoria:

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memory_versions?memory_id=$mem_id" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

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

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

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

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

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

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

  var versionId = versionIds[1];
  ```

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

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

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

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

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

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

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

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

Consulta il [riferimento Elenca versioni della memoria](https://platform.claude.com/docs/it/api/beta/memory_stores/memory_versions/list) per i parametri completi e lo schema della risposta.

### Recupera una versione

Il recupero di una singola versione restituisce gli stessi campi della risposta dell'elenco più il corpo completo di `content` (csharp, go: `Content`).

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/memory_stores/$store_id/memory_versions/$version_id" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

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

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

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

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

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

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

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

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

Consulta il [riferimento Recupera una versione della memoria](https://platform.claude.com/docs/it/api/beta/memory_stores/memory_versions/retrieve) per i parametri completi e lo schema della risposta.

### Oscura una versione

Redact (oscuramento) rimuove il contenuto da una versione storica preservando la traccia di audit (chi ha fatto cosa, quando). Usalo per flussi di conformità come la rimozione di segreti trapelati, PII o richieste di cancellazione degli utenti.

Una versione che è l'attuale head di una memoria attiva non può essere oscurata. Scrivi prima una nuova versione (o elimina la memoria), poi oscura quella vecchia.

<CodeGroup>
  ```bash cURL
  curl -s -X POST "https://api.anthropic.com/v1/memory_stores/$store_id/memory_versions/$version_id/redact" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: agent-memory-2026-07-22" \
    -H "content-type: application/json" \
    -d '{}'
  ```

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

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

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

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

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

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

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

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

Consulta il [riferimento Oscura una versione della memoria](https://platform.claude.com/docs/it/api/beta/memory_stores/memory_versions/redact) per i parametri completi e lo schema della risposta.

## Gestisci i memory store

Oltre a [`create`](https://platform.claude.com/docs/it/api/beta/memory_stores/create), i memory store supportano [`retrieve`](https://platform.claude.com/docs/it/api/beta/memory_stores/retrieve), [`update`](https://platform.claude.com/docs/it/api/beta/memory_stores/update), [`list`](https://platform.claude.com/docs/it/api/beta/memory_stores/list), [`archive`](https://platform.claude.com/docs/it/api/beta/memory_stores/archive) e [`delete`](https://platform.claude.com/docs/it/api/beta/memory_stores/delete).

### Elenca gli store

Elenca gli store nel workspace. Gli store archiviati sono esclusi per impostazione predefinita; imposta `include_archived` (java, php: `includeArchived`; csharp, go: `IncludeArchived`) su `true` per includerli.

<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 è impostato solo sugli store archiviati.
      $archivedAt = isset($s->archivedAt) ? $s->archivedAt->format(DATE_ATOM) : '';
      echo "{$s->id} {$s->name} {$archivedAt}\n";
  }
  ```

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

Consulta il [riferimento Elenca memory store](https://platform.claude.com/docs/it/api/beta/memory_stores/list) per i parametri completi e lo schema della risposta.

### Archivia uno store

L'archiviazione rende uno store di sola lettura e impedisce che venga collegato a nuove sessioni. L'archiviazione è irreversibile; non esiste un'operazione di disarchiviazione.

<CodeGroup>
  ```bash cURL
  curl -s -X POST "https://api.anthropic.com/v1/memory_stores/$store_id/archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: agent-memory-2026-07-22"
  ```

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

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

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

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

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

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

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

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

Consulta il [riferimento Archivia un memory store](https://platform.claude.com/docs/it/api/beta/memory_stores/archive) per i parametri completi e lo schema della risposta.

Per [rimuovere definitivamente uno store](https://platform.claude.com/docs/it/api/beta/memory_stores/delete) insieme a tutte le sue memorie e versioni, chiama `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`).

## Best practice per la gestione della memoria

Quando uno store raggiunge il limite di 10.000 memorie, le scritture di nuove memorie falliscono: sia le chiamate dirette `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`) sia le scritture di file dell'agente su percorsi non mappati. Le memorie esistenti restano leggibili e modificabili. Le seguenti pratiche ti aiutano a restare ben al di sotto del limite e a recuperare senza problemi se lo raggiungi.

* **Usa store mirati.** Invece di un unico grande store generico, usa store più piccoli costruiti per uno scopo specifico: uno per utente, uno per la conoscenza di dominio condivisa e uno per il contesto specifico del progetto. Ogni store ha il proprio limite di 10.000 memorie, quindi mantenere gli store circoscritti riduce la probabilità che uno di essi si riempia.

* **Condensa o sfoltisci prima che lo store si riempia.** Elimina le memorie obsolete o ridondanti con `DELETE /v1/memory_stores/{memory_store_id}/memories/{memory_id}` (python, ruby: `client.beta.memory_stores.memories.delete()`; typescript: `client.beta.memoryStores.memories.delete()`; go, csharp: `client.Beta.MemoryStores.Memories.Delete()`; java: `client.beta().memoryStores().memories().delete()`; php: `$client->beta->memoryStores->memories->delete()`; cli: `ant beta:memory-stores:memories delete`). Puoi anche eseguire una [sessione di dreaming](https://platform.claude.com/docs/it/managed-agents/dreams), che consolida i contenuti frammentati in un nuovo store di output separato anziché modificare quello originale. Sposta le tue sessioni su quello store di output, quindi archivia o elimina l'originale.

* **Collega un nuovo store quando ha senso.** Se uno store è cresciuto oltre il suo ambito utile, collegane uno nuovo per i nuovi contenuti e collega l'originale con accesso `read_only`. L'agente può leggere da entrambi scrivendo solo su quello nuovo.

* **Limita l'accesso in scrittura dove appropriato.** Le sessioni che leggono solo materiale di riferimento condiviso non hanno bisogno di `read_write`. Mantenere l'accesso in scrittura limitato alle sessioni che effettivamente aggiungono nuove memorie rende più facile tracciare da dove proviene la crescita.