---
title: Agent-Memory verwenden
url: https://platform.claude.com/docs/de/managed-agents/memory
description: Gib deinen Agenten mithilfe von Memory Stores ein persistentes Gedächtnis, das über Sessions hinweg erhalten bleibt.
featureMetadata:
  status: beta
  betaHeader: agent-memory-2026-07-22
  zdr:
    eligibility: not-eligible
    note: Nicht für ZDR berechtigt, außer bei selbst gehosteten Managed Agents. Sitzungen sind zustandsbehaftete Ressourcen; Transkripte bleiben erhalten, bis du sie löschst.
  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: Wenn du bei einem Memory-Store-Aufruf `managed-agents-2026-04-01` zusammen mit `agent-memory-2026-07-22` sendest, wird ein 400-Fehler zurückgegeben.
    Claude Platform on AWS:
      availability: beta
      note: Auf Claude Platform on AWS können Sitzungen in selbst gehosteten Umgebungen keine Memory Stores anhängen. Wenn du bei einem Memory-Store-Aufruf `managed-agents-2026-04-01` zusammen mit `agent-memory-2026-07-22` sendest, wird ein 400-Fehler zurückgegeben.
    Claude Models on Google Cloud (Anthropic managed):
      availability: beta
      note: Auf Claude Models on Google Cloud (Anthropic managed) werden Memory Stores für Sitzungen in selbst gehosteten Umgebungen nicht unterstützt. Wenn du bei einem Memory-Store-Aufruf `managed-agents-2026-04-01` zusammen mit `agent-memory-2026-07-22` sendest, wird ein 400-Fehler zurückgegeben.
---

Jede Managed-Agents-Session startet standardmäßig mit einem frischen Kontext. Wenn eine Session endet, ist jeder Zustand, den der Agent aufgebaut hat, verloren. „Memory stores“ (Gedächtnisspeicher) ermöglichen es dem Agenten, Informationen über Sessions hinweg mitzunehmen: Benutzerpräferenzen, Projektkonventionen, frühere Fehler und Domänenkontext.

<Note>
  Kombiniere `agent-memory-2026-07-22` nicht mit `managed-agents-2026-04-01` in einer Memory-Store-Anfrage: Wenn du beide sendest, wird ein `400`-Fehler zurückgegeben. Wenn dein Code Beta-Header explizit setzt, ersetze bei Memory-Store-Aufrufen `managed-agents-2026-04-01` durch `agent-memory-2026-07-22`, anstatt einen zweiten Wert hinzuzufügen. Session-Endpunkte, einschließlich des Anhängens eines Memory Stores an eine Session, verwenden weiterhin `managed-agents-2026-04-01`.

  `GET /v1/memory_stores/{memory_store_id}/memories` verhält sich unter beiden Headern gleich: Ergebnisse werden in einer stabilen, serverseitig definierten Reihenfolge zurückgegeben, und `path_prefix` und `depth` gelten auf dieselbe Weise.
</Note>

## Überblick

Ein **Memory Store** ist eine Workspace-bezogene Sammlung von Textdokumenten, die für Claude optimiert ist. Wenn du einen Store an eine Session anhängst, wird er als Verzeichnis in der Sandbox der Session eingebunden. Der Agent liest und schreibt ihn mit denselben Datei-Tools, die er auch für den Rest des Dateisystems verwendet, und ein Hinweis, der jeden Mount beschreibt, wird automatisch zum System-Prompt hinzugefügt und teilt dem Agenten mit, wo er suchen soll. Das [Agent-Toolset](https://platform.claude.com/docs/de/managed-agents/tools) ist für diese Interaktionen erforderlich; stelle sicher, dass du es bei der [Agent-Erstellung](https://platform.claude.com/docs/de/managed-agents/agent-setup) aktivierst. Auf [selbst gehosteten Sandboxes](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory) ist dieses Verzeichnis kein Live-Mount. Stattdessen lädt dein Environment-Worker jeden angehängten Store in deine Sandbox herunter, bevor die Tools des Agenten ausgeführt werden, und hält diese Kopie mit dem Store synchron.

Jede **Memory** (Erinnerung) in einem Store wird über einen Pfad adressiert und kann direkt über die API oder die Claude Console gelesen und bearbeitet werden, was Feinabstimmung, Import und Export ermöglicht.

Jede Änderung an einer Memory erzeugt eine unveränderliche **Memory-Version**, die dir einen Audit-Trail und eine zeitpunktgenaue Wiederherstellung für alles bietet, was der Agent schreibt.

## Einen Memory Store erstellen

Gib dem Store einen `name` (csharp, go: `Name`) und eine `description` (csharp, go: `Description`). Die Beschreibung wird an den Agenten übergeben und teilt ihm mit, was der Store enthält.

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

Die `id` (csharp, go: `ID`) des Memory Stores (`memstore_...`) ist das, was du übergibst, wenn du den Store an eine Session anhängst.

### Mit Inhalten vorbefüllen (optional)

Befülle einen Store vorab mit Referenzmaterial, bevor ein Agent läuft:

<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>
  Einzelne Erinnerungen innerhalb des Stores sind auf 100 kB (\~25.000 Token) begrenzt. Ein Store enthält maximal 10.000 Erinnerungen. Strukturiere das Gedächtnis als viele kleine, fokussierte Dateien, nicht als wenige große.
</Tip>

## Einen Memory Store an eine Session anhängen

Memory Stores werden im `resources` (csharp, go: `Resources`)-Array der Session angehängt, wenn die [Session erstellt wird](https://platform.claude.com/docs/de/managed-agents/sessions#creating-a-session). Anders als Datei-Ressourcen können Memory Stores nur bei der Erstellung der Session angehängt werden; das Hinzufügen oder Entfernen eines Stores in einer laufenden Session wird nicht unterstützt. Du hängst Memory Stores für Sessions in Cloud- und [selbst gehosteten Umgebungen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory) auf dieselbe Weise an; selbst gehostete Umgebungen akzeptieren nur `memory_store`-Ressourcen.

Füge optional `instructions` (csharp, go: `Instructions`) hinzu, um sessionspezifische Anleitungen dafür bereitzustellen, wie der Agent diesen Store verwenden soll. Sie werden dem Agenten zusammen mit dem `name` (csharp, go: `Name`) und der `description` (csharp, go: `Description`) des Stores angezeigt und sind auf 4.096 Zeichen begrenzt.

Du kannst auch `access` (csharp, go: `Access`) konfigurieren. Der Standardwert ist `read_write` (im folgenden Beispiel explizit angegeben), aber `read_only` wird ebenfalls unterstützt.

<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>
  Memory Stores werden standardmäßig mit `read_write`-Zugriff angehängt. Wenn der Agent nicht vertrauenswürdige Eingaben verarbeitet (vom Benutzer bereitgestellte Prompts, abgerufene Webinhalte oder Ausgaben von Drittanbieter-Tools), könnte eine erfolgreiche Prompt-Injection bösartige Inhalte in den Store schreiben. Spätere Sessions lesen diese Inhalte dann als vertrauenswürdige Memory. Verwende `read_only` für Referenzmaterial, gemeinsam genutzte Nachschlagedaten und jeden Store, den der Agent nicht ändern muss.
</Warning>

Pro Session werden maximal **8 Memory Stores** unterstützt. Hänge mehrere Stores an, wenn verschiedene Teile des Gedächtnisses unterschiedliche Eigentümer oder Zugriffsregeln haben. Häufige Gründe:

* **Gemeinsam genutztes Referenzmaterial:** ein schreibgeschützter Store, der an viele Sessions angehängt ist (Standards, Konventionen, Domänenwissen), getrennt vom eigenen Lese-Schreib-Store jeder Session
* **Abbildung der Struktur deines Produkts:** ein Store pro Endbenutzer, Team oder Projekt, während eine einzige Agent-Konfiguration gemeinsam genutzt wird
* **Unterschiedliche Lebenszyklen:** ein Store, der jede einzelne Session überdauert, oder einer, den du nach eigenem Zeitplan archivieren möchtest

### Wie der Agent auf Memory zugreift

Jeder angehängte Store wird in der Sandbox der Session als Verzeichnis unter `/mnt/memory/` eingebunden. Der Verzeichnisname ist der Anzeigename des Stores, bereinigt zu einem dateisystemsicheren Slug (in Kleinbuchstaben, wobei jede Folge nicht-alphanumerischer Zeichen durch einen einzelnen Bindestrich ersetzt wird), sodass ein Store namens „Demo Memory“ unter `/mnt/memory/demo-memory/` eingebunden wird. Der genaue Pfad wird im Feld `mount_path` (java, php: `mountPath`; csharp, go: `MountPath`) der Memory-Store-Ressource der Session zurückgegeben; lies ihn dort aus, anstatt ihn selbst zu konstruieren. Der Agent liest und schreibt den Store mit dem Standard-[Agent-Toolset](https://platform.claude.com/docs/de/managed-agents/tools). Schreibvorgänge unter dem Einbindungspfad werden in den Store zurückgeschrieben und bleiben über Sessions, die ihn gemeinsam nutzen, synchron; Schreibvorgänge in einen anderen Pfad unter `/mnt/memory/` schlagen fehl, da die Sandbox dieses übergeordnete Verzeichnis schreibgeschützt einbindet. Eine kurze Beschreibung jeder Einbindung (Anzeigename, Einbindungspfad, Zugriffsmodus, `description` (csharp, go: `Description`) des Stores und eventuelle `instructions` (csharp, go: `Instructions`)) wird automatisch zum System-Prompt hinzugefügt.

`access` (csharp, go: `Access`) wird auf Dateisystemebene durchgesetzt: Eine `read_only`-Einbindung lehnt Schreibvorgänge ab, während Schreibvorgänge in eine `read_write`-Einbindung [Erinnerungsversionen](https://platform.claude.com/docs/de/managed-agents/memory#audit-memory-changes) erzeugen, die der Session zugeordnet werden.

<Note>
  Auf selbst gehosteten Sandboxes ist das Verzeichnis jedes Stores eine lokale Kopie, die der Worker mit dem Store synchronisiert, und kein Live-Mount. Eine Änderung erreicht den Store und andere Sessions erst bei einer Synchronisierung. Siehe [Wie der Worker mit Memory umgeht](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory#how-the-worker-handles-memory) und [Schreibgeschützte Stores und Konflikte](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory#read-only-stores-and-conflicts).
</Note>

Die Lese- und Schreibvorgänge des Agenten erscheinen im [Event-Stream](https://platform.claude.com/docs/de/managed-agents/events-and-streaming) als gewöhnliche `agent.tool_use`- und `agent.tool_result`-Events für das jeweilige Tool, das den Mount berührt hat.

## Memories anzeigen und bearbeiten

Memory Stores können direkt über die API verwaltet werden. Nutze dies, um Review-Workflows zu erstellen, fehlerhafte Memories zu korrigieren oder Stores vorzubefüllen, bevor eine Session läuft.

### Memories auflisten

Liste die Memories in einem Store auf. Ergebnisse werden in einer stabilen, serverseitig definierten Reihenfolge zurückgegeben.

* `path_prefix` beschränkt die Liste auf ein Verzeichnis. Es muss mit `/` enden und gleicht ganze Pfadsegmente ab, sodass `path_prefix=/notes/` `/notes/todo.md` zurückgibt, aber nicht `/notes-archive/todo.md`.
* `depth` steuert, wie tief die Liste unterhalb von `path_prefix` reicht: Lass den Parameter weg (oder übergib `0`), um den gesamten Teilbaum aufzulisten, oder übergib `1`, um nur die unmittelbaren Kinder aufzulisten. Andere Werte geben einen `400`-Fehler zurück.

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

Vollständige Parameter und das Antwortschema findest du in der Referenz [Erinnerungen auflisten](https://platform.claude.com/docs/de/api/beta/memory_stores/memories/list).

### Eine Memory lesen

Das Abrufen einer einzelnen Memory gibt den vollständigen Inhalt zurück.

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

Vollständige Parameter und das Antwortschema findest du in der Referenz [Eine Erinnerung abrufen](https://platform.claude.com/docs/de/api/beta/memory_stores/memories/retrieve).

### Eine Memory erstellen

`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`) erstellt eine Erinnerung unter einem angegebenen `path` (csharp, go: `Path`). Create überschreibt nicht; um [eine bestehende Erinnerung zu aktualisieren](https://platform.claude.com/docs/de/managed-agents/memory#update-a-memory), verwende `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>

Vollständige Parameter und das Antwortschema findest du in der Referenz [Eine Erinnerung erstellen](https://platform.claude.com/docs/de/api/beta/memory_stores/memories/create).

### Eine Memory aktualisieren

`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`) ändert eine bestehende Memory anhand ihrer ID. Du kannst `content` (csharp, go: `Content`), `path` (csharp, go: `Path`) (eine Umbenennung) oder beides ändern. Das Beispiel benennt eine Memory in einen Archivpfad um:

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

Vollständige Parameter und das Antwortschema findest du in der Referenz [Eine Erinnerung aktualisieren](https://platform.claude.com/docs/de/api/beta/memory_stores/memories/update).

#### Sichere Inhaltsbearbeitungen (optimistische Nebenläufigkeit)

Um das Überschreiben eines gleichzeitigen Schreibvorgangs zu vermeiden, übergib eine `content_sha256`-Vorbedingung. Das Update wird nur angewendet, wenn der gespeicherte Inhalts-Hash noch mit dem übereinstimmt, den du gelesen hast; bei einer Abweichung liest du die Erinnerung erneut und versuchst es mit dem aktuellen Zustand noch einmal.

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

### Eine Memory löschen

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

Vollständige Parameter und das Antwortschema findest du in der Referenz [Eine Erinnerung löschen](https://platform.claude.com/docs/de/api/beta/memory_stores/memories/delete).

## Memory-Änderungen auditieren

Jede Mutation einer Memory erzeugt eine unveränderliche **Memory-Version** (`memver_...`). Verwende die Versions-Endpunkte, um zu auditieren, wer was wann geändert hat, um einen früheren Snapshot zu inspizieren oder wiederherzustellen und um sensible Inhalte mit Redact aus der Historie zu entfernen.

Versionen gehören zum Store (nicht zur einzelnen Erinnerung) und werden nicht gelöscht, wenn die Erinnerung selbst gelöscht wird, sodass der Audit-Trail auch gelöschte Erinnerungen abdeckt, vorbehaltlich der weiter unten beschriebenen Aufbewahrung. Versionen werden 30 Tage nach ihrem Schreiben aufbewahrt; die neuesten Versionen einer aktiven Erinnerung werden jedoch unabhängig von ihrem Alter immer beibehalten, sodass Erinnerungen, die sich selten ändern, ihren Verlauf möglicherweise über 30 Tage hinaus behalten. Der Live-Aufruf `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`) gibt immer die neueste Version zurück; die Versions-Endpunkte liefern dir den aufbewahrten Verlauf.

Es gibt keinen eigenen Wiederherstellungs-Endpunkt; um ein Rollback durchzuführen, rufe die gewünschte Version ab und schreibe ihren `content` (csharp, go: `Content`) mit `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`) zurück (oder mit `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`), falls die übergeordnete Memory gelöscht wurde, sofern die gewünschte Version noch aufbewahrt wird).

Frühere Memory-Versionen können nach 30 Tagen gelöscht werden. Um die Memory-Historie länger zu bewahren, exportiere Versionen über die API.

### Versionen auflisten

Liste die Versionshistorie eines Stores auf, neueste zuerst. Das Beispiel filtert auf die Historie einer einzelnen Memory:

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

Vollständige Parameter und das Antwortschema findest du in der Referenz [Erinnerungsversionen auflisten](https://platform.claude.com/docs/de/api/beta/memory_stores/memory_versions/list).

### Eine Version abrufen

Das Abrufen einer einzelnen Version gibt dieselben Felder wie die Listenantwort zurück, zuzüglich des vollständigen `content` (csharp, go: `Content`)-Inhalts.

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

Vollständige Parameter und das Antwortschema findest du in der Referenz [Eine Erinnerungsversion abrufen](https://platform.claude.com/docs/de/api/beta/memory_stores/memory_versions/retrieve).

### Eine Version schwärzen (Redact)

Redact entfernt Inhalte aus einer historischen Version, während der Audit-Trail (wer hat was wann getan) erhalten bleibt. Verwende dies für Compliance-Workflows, etwa zum Entfernen geleakter Secrets oder personenbezogener Daten (PII) oder zur Erfüllung von Löschanfragen von Benutzern.

Eine Version, die der aktuelle Head einer aktiven Memory ist, kann nicht geschwärzt werden. Schreibe zuerst eine neue Version (oder lösche die Memory) und schwärze dann die alte.

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

Vollständige Parameter und das Antwortschema findest du in der Referenz [Eine Erinnerungsversion schwärzen](https://platform.claude.com/docs/de/api/beta/memory_stores/memory_versions/redact).

## Memory Stores verwalten

Zusätzlich zu [`create`](https://platform.claude.com/docs/de/api/beta/memory_stores/create) unterstützen Memory Stores [`retrieve`](https://platform.claude.com/docs/de/api/beta/memory_stores/retrieve), [`update`](https://platform.claude.com/docs/de/api/beta/memory_stores/update), [`list`](https://platform.claude.com/docs/de/api/beta/memory_stores/list), [`archive`](https://platform.claude.com/docs/de/api/beta/memory_stores/archive) und [`delete`](https://platform.claude.com/docs/de/api/beta/memory_stores/delete).

### Stores auflisten

Liste die Stores im Workspace auf. Archivierte Stores sind standardmäßig ausgeschlossen; setze `include_archived` (java, php: `includeArchived`; csharp, go: `IncludeArchived`) auf `true`, um sie einzuschließen.

<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 wird nur bei archivierten Stores gesetzt.
      $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>

Vollständige Parameter und das Antwortschema findest du in der Referenz [Memory Stores auflisten](https://platform.claude.com/docs/de/api/beta/memory_stores/list).

### Einen Store archivieren

Das Archivieren macht einen Store schreibgeschützt und verhindert, dass er an neue Sessions angehängt wird. Archivieren ist eine Einbahnstraße; es gibt kein Entarchivieren.

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

Vollständige Parameter und das Antwortschema findest du in der Referenz [Einen Memory Store archivieren](https://platform.claude.com/docs/de/api/beta/memory_stores/archive).

Um [einen Store dauerhaft zu löschen](https://platform.claude.com/docs/de/api/beta/memory_stores/delete), zusammen mit all seinen Erinnerungen und Versionen, rufe `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`) auf.

## Best Practices für die Memory-Verwaltung

Wenn ein Store sein Limit von 10.000 Memories erreicht, schlagen Schreibvorgänge für neue Memories fehl: sowohl direkte `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`)-Aufrufe als auch die Dateischreibvorgänge des Agenten in nicht zugeordnete Pfade. Vorhandene Memories bleiben lesbar und bearbeitbar. Die folgenden Praktiken helfen dir, deutlich unter dem Limit zu bleiben und dich problemlos zu erholen, falls du es erreichst.

* **Verwende fokussierte Stores.** Statt eines großen Allzweck-Stores solltest du kleinere, zweckgebundene Stores verwenden: einen für jeden Benutzer, einen für gemeinsam genutztes Domänenwissen und einen für projektspezifischen Kontext. Jeder Store hat sein eigenes Limit von 10.000 Erinnerungen, sodass eng gefasste Stores die Wahrscheinlichkeit verringern, dass ein einzelner voll wird.

* **Verdichte oder bereinige, bevor der Store voll ist.** Lösche veraltete oder redundante Memories mit `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`). Du kannst auch eine [Dreaming-Session](https://platform.claude.com/docs/de/managed-agents/dreams) ausführen, die fragmentierte Inhalte in einem separaten neuen Ausgabe-Store zusammenführt, anstatt das Original zu ändern. Stelle deine Sessions auf diesen Ausgabe-Store um und archiviere oder lösche dann das Original.

* **Hänge einen neuen Store an, wenn es sinnvoll ist.** Wenn ein Store über seinen nützlichen Umfang hinausgewachsen ist, hänge einen frischen Store für neue Inhalte an und hänge das Original mit `read_only`-Zugriff an. Der Agent kann aus beiden lesen, während er nur in den neuen schreibt.

* **Beschränke den Schreibzugriff, wo es angemessen ist.** Sessions, die nur gemeinsam genutztes Referenzmaterial lesen, benötigen kein `read_write`. Wenn der Schreibzugriff auf Sessions beschränkt bleibt, die tatsächlich neue Memories hinzufügen, lässt sich leichter nachverfolgen, woher das Wachstum kommt.

## Verfügbarkeit

Memory Stores sind auf allen Modellen in der Beta.

### API-Unterstützung

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

* Verfügbarkeit: Verfügbar

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

1. Wenn du bei einem Memory-Store-Aufruf `managed-agents-2026-04-01` zusammen mit `agent-memory-2026-07-22` sendest, wird ein 400-Fehler zurückgegeben.
2. Auf Claude Platform on AWS können Sitzungen in selbst gehosteten Umgebungen keine Memory Stores anhängen. Wenn du bei einem Memory-Store-Aufruf `managed-agents-2026-04-01` zusammen mit `agent-memory-2026-07-22` sendest, wird ein 400-Fehler zurückgegeben.
3. Auf Claude Models on Google Cloud (Anthropic managed) werden Memory Stores für Sitzungen in selbst gehosteten Umgebungen nicht unterstützt. Wenn du bei einem Memory-Store-Aufruf `managed-agents-2026-04-01` zusammen mit `agent-memory-2026-07-22` sendest, wird ein 400-Fehler zurückgegeben.

### Erforderliche Beta-Header

[Übersicht über Beta-Header](https://platform.claude.com/docs/de/api/beta-headers)

Mit Beta-Headern kannst du auf experimentelle Funktionen und neue Modellfähigkeiten zugreifen, bevor sie Teil der Standard-API werden.

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

### Datenverarbeitung

[Übersicht über die Datenverarbeitung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention#feature-eligibility)

| Element | Zero Data Retention | HIPAA |
| ----- | ----- | ----- |
| Status | Nicht berechtigt | Nicht berechtigt |
| Details | Nicht für ZDR berechtigt, außer bei selbst gehosteten Managed Agents. Sitzungen sind zustandsbehaftete Ressourcen; Transkripte bleiben erhalten, bis du sie löschst. [Mehr erfahren](https://platform.claude.com/docs/de/managed-agents/self-hosted-data-and-access#how-long-data-is-kept) | Nicht für HIPAA berechtigt. Gilt für alle Unterfunktionen von Managed Agents. |

Zutreffende Endpunkte:

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