---
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
  zdr:
    eligibility: not-eligible
    note: Non idoneo per ZDR, ad eccezione di Managed Agents self-hosted. Le sessioni sono risorse con stato; le trascrizioni restano finché non le elimini.
  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’invio di `managed-agents-2026-04-01` insieme a `agent-memory-2026-07-22` in una chiamata a un archivio di memoria restituisce un errore 400.
    Claude Platform on AWS:
      availability: beta
      note: Su Claude Platform on AWS, le sessioni su ambienti self-hosted non possono collegare archivi di memoria. L’invio di `managed-agents-2026-04-01` insieme a `agent-memory-2026-07-22` in una chiamata a un archivio di memoria restituisce un errore 400.
    Claude Models on Google Cloud (Anthropic managed):
      availability: beta
      note: Su Claude Models on Google Cloud (Anthropic managed), gli archivi di memoria non sono supportati per le sessioni su ambienti self-hosted. L’invio di `managed-agents-2026-04-01` insieme a `agent-memory-2026-07-22` in una chiamata a un archivio di memoria restituisce un errore 400.
---

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 archivio di memoria: 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 agli archivi di memoria invece di aggiungere un secondo valore. Gli endpoint delle sessioni, incluso il collegamento di un archivio di memoria 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 archivio di memoria

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: 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`) dell’archivio di memoria (`memstore_...`) è ciò che passi quando colleghi l’archivio 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: 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>
  Le singole memorie all’interno dello store sono limitate a 100 kB (\~25k token). Uno store contiene al massimo 10.000 memorie. Struttura la memoria come molti piccoli file mirati, non come pochi file di grandi dimensioni.
</Tip>

## Collega un archivio di memoria 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: 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>
  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>

Sono supportati al massimo **8 memory store** per ogni sessione. Collega più store quando parti diverse della memoria hanno proprietari o regole di accesso differenti. Motivi comuni:

* **Materiale di riferimento condiviso:** uno store di sola lettura collegato a molte sessioni (standard, convenzioni, conoscenze di dominio), mantenuto separato dallo store di lettura-scrittura di ciascuna sessione
* **Corrispondenza con la struttura del tuo prodotto:** uno store per ogni utente finale, team o progetto, condividendo un’unica configurazione dell’agente
* **Cicli di vita differenti:** 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, con ogni sequenza di caratteri non alfanumerici sostituita da 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 rimangono 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 di memoria](https://platform.claude.com/docs/it/managed-agents/memory#audit-memory-changes) attribuite alla sessione.

<Note>
  Sulle sandbox self-hosted, la directory di ogni store è una copia locale che il worker sincronizza con lo store, non un mount attivo. Una modifica raggiunge lo store, e le altre sessioni, solo al momento di una sincronizzazione. Consulta [Come il worker gestisce la memoria](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes-memory#how-the-worker-handles-memory) e [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 la profondità dell’elenco sotto `path_prefix`: omettilo (o passa `0`) per elencare l’intero sottoalbero, oppure passa `1` per elencare solo i figli diretti. 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: 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>

Consulta il riferimento [Elencare le 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: 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>

Consulta il riferimento [Recuperare 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 [aggiornare una memoria esistente](https://platform.claude.com/docs/it/managed-agents/memory#update-a-memory), usa `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>

Consulta il riferimento [Creare 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: 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>

Consulta il riferimento [Aggiornare 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 sullo 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: 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>

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

Consulta il riferimento [Eliminare 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 **versione della memoria** 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 l’oscuramento.

Le versioni appartengono all’archivio (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 più avanti. 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 `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`) sulla memoria attiva 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: 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>

Consulta il riferimento [Elencare le versioni di 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: 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>

Consulta il riferimento [Recuperare una versione di 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

L’oscuramento rimuove il contenuto da una versione storica preservando la traccia di audit (chi ha fatto cosa e quando). Usalo per i flussi di lavoro di conformità, come la rimozione di segreti trapelati o PII, o per soddisfare le richieste di eliminazione 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: 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>

Consulta il riferimento [Oscurare 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: 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 è impostato solo sugli store archiviati.
      $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>

Consulta il riferimento [Elencare i 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: 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>

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

Per [eliminare 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 con uno scopo specifico: uno per ogni utente, uno per le conoscenze di dominio condivise 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 qualsiasi 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.

## Disponibilità

La funzionalità Archivi di memoria è in beta su tutti i modelli.

### Supporto API

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

* Disponibilità: Disponibile

| Stato | Piattaforme cloud |
| ----- | ----- |
| Beta<sup>1</sup> | Claude API |
| Beta<sup>2</sup> | [Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws) |
| Beta<sup>3</sup> | [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed) |

1. L’invio di `managed-agents-2026-04-01` insieme a `agent-memory-2026-07-22` in una chiamata a un archivio di memoria restituisce un errore 400.
2. Su Claude Platform on AWS, le sessioni su ambienti self-hosted non possono collegare archivi di memoria. L’invio di `managed-agents-2026-04-01` insieme a `agent-memory-2026-07-22` in una chiamata a un archivio di memoria restituisce un errore 400.
3. Su Claude Models on Google Cloud (Anthropic managed), gli archivi di memoria non sono supportati per le sessioni su ambienti self-hosted. L’invio di `managed-agents-2026-04-01` insieme a `agent-memory-2026-07-22` in una chiamata a un archivio di memoria restituisce un errore 400.

### Header beta richiesti

[Panoramica degli header beta](https://platform.claude.com/docs/it/api/beta-headers)

Gli header beta consentono di accedere a funzionalità sperimentali e a nuove capacità dei modelli prima che entrino a far parte dell’API standard.

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

### Gestione dei dati

[Panoramica sulla gestione dei dati](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention#feature-eligibility)

| Elemento | Conservazione zero dei dati | HIPAA |
| ----- | ----- | ----- |
| Stato | Non idoneo | Non idoneo |
| Dettagli | Non idoneo per ZDR, ad eccezione di Managed Agents self-hosted. Le sessioni sono risorse con stato; le trascrizioni restano finché non le elimini. [Scopri di più](https://platform.claude.com/docs/it/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | Non idoneo per HIPAA. Si applica a tutte le sotto-funzionalità di Managed Agents. |

Endpoint applicabili:

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