---
title: "Migrating from Mem0.ai to Supermemory"
description: "Complete guide to migrate your data and applications from Mem0.ai to Supermemory"
sidebarTitle: "From Mem0"
---
Migrating from Mem0.ai to Supermemory is straightforward. This guide walks you through exporting your memories from Mem0 and importing them into Supermemory.
## Why Migrate to Supermemory?
Supermemory offers enhanced capabilities over Mem0.ai:
- **Memory Router** for zero-code LLM integration
- **Knowledge graph** architecture for better context relationships
- **Multiple content types** (URLs, PDFs, images, videos)
- **Generous free tier** (100k tokens) with affordable pricing
- **Multiple integration options** (API, Router, MCP, SDKs)
## Quick Migration (All-in-One)
Complete migration in one script:
```python
from mem0 import MemoryClient
from supermemory import Supermemory
import json, time
# Export from Mem0
mem0 = MemoryClient(api_key="your_mem0_api_key")
export = mem0.create_memory_export(
schema={"type": "object", "properties": {"memories": {"type": "array", "items": {"type": "object"}}}},
filters={}
)
time.sleep(5)
data = mem0.get_memory_export(memory_export_id=export["id"])
# Import to Supermemory
supermemory = Supermemory(api_key="your_supermemory_api_key")
for memory in data["memories"]:
if memory.get("content"):
supermemory.memories.add(
content=memory["content"],
container_tags=["imported_from_mem0"]
)
print(f"✅ {memory['content'][:50]}...")
print("Migration complete!")
```
## Step-by-Step Migration
Mem0 provides two ways to export your memories:
### Option 1: Export via Dashboard (Recommended)
1. Log into your [Mem0 dashboard](https://app.mem0.ai)
2. Navigate to the export section
3. Download your memories as JSON
### Option 2: Export via API
Simple script to export all your memories from Mem0:
```python
from mem0 import MemoryClient
import json
import time
# Connect to Mem0
client = MemoryClient(api_key="your_mem0_api_key")
# Create export job
schema = {
"type": "object",
"properties": {
"memories": {
"type": "array",
"items": {
"type": "object",
"properties": {
"id": {"type": "string"},
"content": {"type": "string"},
"metadata": {"type": "object"},
"created_at": {"type": "string"}
}
}
}
}
}
response = client.create_memory_export(schema=schema, filters={})
export_id = response["id"]
# Wait and retrieve
print("Exporting memories...")
time.sleep(5)
export_data = client.get_memory_export(memory_export_id=export_id)
# Save to file
with open("mem0_export.json", "w") as f:
json.dump(export_data, f, indent=2)
print(f"Exported {len(export_data['memories'])} memories")
```
Create your Supermemory account and get your API key:
1. Sign up at [console.supermemory.ai](https://console.supermemory.ai)
2. Create a new project
3. Generate an API key from the dashboard
```bash
# Set your environment variable
export SUPERMEMORY_API_KEY="your_supermemory_api_key"
```
Simple script to import your Mem0 memories into Supermemory:
```python
import json
from supermemory import Supermemory
# Load your Mem0 export
with open("mem0_export.json", "r") as f:
mem0_data = json.load(f)
# Connect to Supermemory
client = Supermemory(api_key="your_supermemory_api_key")
# Import memories
for memory in mem0_data["memories"]:
content = memory.get("content", "")
# Skip empty memories
if not content:
continue
# Import to Supermemory
try:
result = client.memories.add(
content=content,
container_tags=["imported_from_mem0"],
metadata={
"source": "mem0",
"created_at": memory.get("created_at"),
**(memory.get("metadata") or {})
}
)
print(f"Imported: {content[:50]}...")
except Exception as e:
print(f"Failed: {e}")
print("Migration complete!")
```
## API Migration Reference
Here's how common Mem0.ai operations map to Supermemory:
### Adding Memories
```python Mem0.ai
from mem0 import MemoryClient
client = MemoryClient(api_key="...")
client.add(
messages="User prefers dark mode",
user_id="alice"
)
```
```python Supermemory
from supermemory import Supermemory
client = Supermemory(api_key="...")
client.memories.add(
content="User prefers dark mode",
container_tags=["user_alice"]
)
```
### Searching Memories
```python Mem0.ai
results = client.search(
query="user preferences",
user_id="alice"
)
```
```python Supermemory
results = client.memories.search(
query="user preferences",
container_tags=["user_alice"]
)
```
### Getting All Memories
```python Mem0.ai
memories = client.get_all(
user_id="alice"
)
```
```python Supermemory
memories = client.memories.list(
container_tags=["user_alice"],
limit=100
)
```
### Deleting Memories
```python Mem0.ai
client.delete(memory_id="mem_123")
```
```python Supermemory
client.memories.delete("mem_123")
```
## Using Memory Router (Easiest Migration)
For the simplest migration path, use Supermemory's Memory Router which requires minimal code changes:
```python Before (Mem0 + OpenAI)
from openai import OpenAI
from mem0 import MemoryClient
# Two separate clients needed
openai = OpenAI(api_key="sk-...")
memory = MemoryClient(api_key="mem0_key")
# Manual memory management
context = memory.search("user preferences", user_id="alice")
messages = [
{"role": "system", "content": f"Context: {context}"},
{"role": "user", "content": "What are my preferences?"}
]
response = openai.chat.completions.create(
model="gpt-5",
messages=messages
)
```
```python After (Supermemory Router)
from openai import OpenAI
# Single client with automatic memory management
client = OpenAI(
api_key="sk-...",
base_url="https://api.supermemory.ai/v3/https://api.openai.com/v1",
default_headers={
"x-supermemory-api-key": "your_supermemory_key",
"x-supermemory-user-id": "alice"
}
)
# Memories handled automatically!
response = client.chat.completions.create(
model="gpt-5",
messages=[{"role": "user", "content": "What are my preferences?"}]
)
```
For enterprise migrations, [contact us](mailto:support@supermemory.com) for assistance.
## Next Steps
1. [Explore](/how-it-works) how Supermemory works
2. Read the [quickstart](/quickstart) and add and retrieve your first memories
3. [Connect](/connectors/overview) to Google Drive, Notion, and OneDrive with automatic syncing