# Remove Memories Safely

Deleting memories is how you honor compliance requests, undo bad data, or clean up expired sessions. Mem0 lets you delete a specific memory, a list of IDs, or everything that matches a filter.

**Why it matters**

- Satisfies user erasure (GDPR/CCPA) without touching the rest of your data.
- Keeps knowledge bases accurate by removing stale or incorrect facts.
- Works for both the managed Platform API and the OSS SDK.

## Key terms

- **memory_id**: Unique ID returned by `add`/`search` identifying the record to delete.
- **batch_delete**: API call that removes up to 1000 memories in one request.
- **delete_all**: Filter-based deletion by user, agent, run, or metadata.
- **immutable**: Flagged memories that cannot be updated; delete + re-add instead.

## How the delete flow works

1. **Choose the scope**
   Decide whether you’re removing a single memory, a list, or everything that matches a filter.

2. **Submit the delete call**
   Call `delete`, `batch_delete`, or `delete_all` with the required IDs or filters.

3. **Verify**
   Confirm the response message, then re-run `search` or check the dashboard/logs to ensure the memory is gone.

## Delete a single memory (Platform)

### Python
```python
from mem0 import MemoryClient

client = MemoryClient(api_key="your-api-key")

memory_id = "your_memory_id"
client.delete(memory_id=memory_id)
```

### JavaScript
```javascript
import MemoryClient from 'mem0ai';

const client = new MemoryClient({ apiKey: "your-api-key" });

client.delete("your_memory_id")
  .then(result => console.log(result))
  .catch(error => console.error(error));
```

You’ll receive a confirmation payload. The dashboard reflects the removal within seconds.

## Batch delete multiple memories (Platform)

### Python
```python
from mem0 import MemoryClient

client = MemoryClient(api_key="your-api-key")

delete_memories = [
    {"memory_id": "id1"},
    {"memory_id": "id2"}
]

response = client.batch_delete(delete_memories)
print(response)
```

### JavaScript
```javascript
import MemoryClient from 'mem0ai';

const client = new MemoryClient({ apiKey: "your-api-key" });

const deleteMemories = [
  { memory_id: "id1" },
  { memory_id: "id2" }
];

client.batchDelete(deleteMemories)
  .then(response => console.log('Batch delete response:', response))
  .catch(error => console.error(error));
```

## Delete memories by filter (Platform)

### Python
```python
from mem0 import MemoryClient

client = MemoryClient(api_key="your-api-key")

# Delete all memories for a specific user
client.delete_all(user_id="alice")

# Delete all memories for a specific agent
client.delete_all(agent_id="support-bot")

# Delete all memories for a specific run
client.delete_all(run_id="session-xyz")
```

### JavaScript
```javascript
import MemoryClient from 'mem0ai';

const client = new MemoryClient({ apiKey: "your-api-key" });

client.deleteAll({ userId: "alice" })
  .then(result => console.log(result))
  .catch(error => console.error(error));
```

You can also filter by other parameters such as:

- `agent_id`
- `run_id`
- `metadata` (as JSON string)

**Breaking change:**`delete_all` previously wiped all project memories when called with no filters. It now **raises an error** if no filters are provided. Use `"*"` wildcards for intentional bulk deletion (see below).

### Wildcard deletes

Setting a filter to `"*"` deletes **all memories** for that entity type across the entire project.

### Python
```python
from mem0 import MemoryClient

client = MemoryClient(api_key="your-api-key")

# Delete all memories across every user in the project
client.delete_all(user_id="*")

# Delete all memories across every agent in the project
client.delete_all(agent_id="*")

# Full project wipe: all four filters must be explicitly set to "*"
client.delete_all(user_id="*", agent_id="*", app_id="*", run_id="*")
```

### JavaScript
```javascript
import MemoryClient from 'mem0ai';

const client = new MemoryClient({ apiKey: "your-api-key" });

// Delete all memories across every user in the project
client.deleteAll({ userId: "*" })
  .then(result => console.log(result))
  .catch(error => console.error(error));

// Full project wipe: all four filters must be explicitly set to "*"
client.deleteAll({ userId: "*", agentId: "*", appId: "*", runId: "*" })
  .then(result => console.log(result))
  .catch(error => console.error(error));
```

A full project wipe requires **all four** filters set to `"*"`. Setting only some to `"*"` deletes memories only for those entity types, not the entire project.

## Delete with Mem0 OSS

### Python
```python
from mem0 import Memory

memory = Memory()

memory.delete(memory_id="mem_123")
memory.delete_all(user_id="alice")
```

### TypeScript
```typescript
import { Memory } from "mem0ai/oss";

const memory = new Memory();

await memory.delete("mem_123");
await memory.deleteAll({ userId: "alice" });
```

## Use cases recap

- Forget a user’s preferences at their request.
- Remove outdated or incorrect facts before they spread.
- Clean up memories after session expiration or retention deadlines.
- Comply with privacy legislation (GDPR, CCPA) and internal policies.

**MCP Alternative**: With [Mem0 MCP](https://docs.mem0.ai/platform/mem0-mcp), AI agents can delete their own memories when data becomes irrelevant or at user request.

## Method comparison

| Method | Use when | IDs required | Filters |
| --- | --- | --- | --- |
| `delete(memory_id)` | You know the exact record | ✔️ | ✖️ |
| `batch_delete([...])` | You have a list of IDs to purge | ✔️ | ✖️ |
| `delete_all(...)` | You need to forget a user/agent/run | ✖️ | ✔️ |

## Put it into practice

- Review the [Delete Memory API reference](https://docs.mem0.ai/api-reference/memory/delete-memory), plus [Batch Delete](https://docs.mem0.ai/api-reference/memory/batch-delete) and [Filtered Delete](https://docs.mem0.ai/api-reference/memory/delete-memories).
- Pair deletes with the [expiration date field](https://docs.mem0.ai/api-reference/memory/update-memory) to automate retention.

## See it live

- [Support Inbox with Mem0](https://docs.mem0.ai/cookbooks/operations/support-inbox) demonstrates compliance-driven deletes.
- [Data Management tooling](https://docs.mem0.ai/platform/features/direct-import) shows how deletes fit into broader lifecycle flows.