Skip to main content
Mem0 is a dynamic memory store that gives you full control over your data. Along with storing memories, it gives you the ability to retrieve, export, and migrate your data whenever you need. This cookbook shows you how to retrieve and export your data for inspection, migration, or compliance.

​
Setup

from mem0 import MemoryClient

client = MemoryClient(api_key="your-api-key")
Your API key needs export permissions to download memory data. Check your project settings on the dashboard if export operations fail with authentication errors.
Let’s add some sample memories to work with: 
# Dev's work history
client.add(
    "Dev works at TechCorp as a senior engineer",
    user_id="dev",
    metadata={"type": "professional"}
)

# Arjun's preferences
client.add(
    "Arjun prefers morning meetings and async communication",
    user_id="arjun",
    metadata={"type": "preference"}
)

# Carl's project notes
client.add(
    "Carl is leading the API redesign project, targeting Q2 launch",
    user_id="carl",
    metadata={"type": "project"}
)

​
Getting All Memories

Use get_all() with filters to retrieve everything for a specific user: 
dev_memories = client.get_all(
    filters={"user_id": "dev"},
    page_size=50
)

print(f"Total memories: {dev_memories['count']}")
print(f"First memory: {dev_memories['results'][0]['memory']}")
Output: 
Total memories: 1
First memory: Dev works at TechCorp as a senior engineer
Expected output: get_all() retrieved Dev’s complete memory record. This method returns everything matching your filters—no semantic search, no ranking, just raw retrieval. Perfect for exports and audits.
You can filter by metadata to get specific types: 
carl_projects = client.get_all(
    filters={
        "AND": [
            {"user_id": "carl"},
            {"metadata": {"type": "project"}}
        ]
    }
)

for memory in carl_projects['results']:
    print(memory['memory'])
Output: 
Carl is leading the API redesign project, targeting Q2 launch

​
Searching Memories

When you need semantic search instead of retrieving everything, use search(): 
results = client.search(
    query="What does Dev do for work?",
    filters={"user_id": "dev"},
    top_k=5
)

for result in results['results']:
    print(f"{result['memory']} (score: {result['score']:.2f})")
Output: 
Dev works at TechCorp as a senior engineer (score: 0.89)
Search works across all memory fields and ranks by relevance. Use it when you have a specific question, use get_all() when you need everything.

​
Exporting to Structured Format

For migrations or compliance, you can export memories into a structured schema using Pydantic-style JSON schemas.

​
Step 1: Define the schema

professional_profile_schema = {
    "properties": {
        "full_name": {
            "type": "string",
            "description": "The person's full name"
        },
        "current_role": {
            "type": "string",
            "description": "Current job title or role"
        },
        "company": {
            "type": "string",
            "description": "Current employer"
        }
    },
    "title": "ProfessionalProfile",
    "type": "object"
}

​
Step 2: Create export job

export_job = client.create_memory_export(
    schema=professional_profile_schema,
    filters={"user_id": "dev"}
)

print(f"Export ID: {export_job['id']}")
print(f"Status: {export_job['status']}")
Output: 
Export ID: exp_abc123
Status: processing
Export initiated: Status is “processing”. Large exports may take a few seconds. Poll with get_memory_export() until status changes to “completed” before downloading data.

​
Step 3: Download the export

# Get by ID
export_data = client.get_memory_export(
    memory_export_id=export_job['id']
)

print(export_data['data'])
Output: 
{
  "full_name": "Dev",
  "current_role": "senior engineer",
  "company": "TechCorp"
}
You can also retrieve exports by filters: 
# Get latest export matching filters
export_by_filters = client.get_memory_export(
    filters={"user_id": "dev"}
)

print(export_by_filters['data'])

​
Adding Export Instructions

Guide how Mem0 resolves conflicts or formats the export: 
export_with_instructions = client.create_memory_export(
    schema=professional_profile_schema,
    filters={"user_id": "arjun"},
    export_instructions="""
1. Use the most recent information if there are conflicts
2. Only include confirmed facts, not speculation
3. Return null for missing fields rather than guessing
"""
)
Always check export status before downloading. Call get_memory_export() in a loop with a short delay until status == "completed". Attempting to download while still processing returns incomplete data.

​
Platform Export

You can also export memories directly from the Mem0 platform UI:
  1. Navigate to Memory Exports in your project dashboard
  2. Click Create Export
  3. Select your filters and schema
  4. Download the completed export as JSON
This is useful for one-off exports or manual data reviews.
Exported data expires after 7 days. Download and store exports locally if you need long-term archives. After expiration, you’ll need to recreate the export job.

​
What You Built

A complete memory export system with multiple retrieval methods:
  • Bulk retrieval (get_all) - Fetch all memories matching filters for comprehensive audits
  • Semantic search - Query-based lookups with relevance scoring
  • Structured exports - Pydantic-schema exports for migrations and compliance
  • Export instructions - Guide conflict resolution and data formatting
  • Platform UI exports - One-off manual downloads via dashboard
This covers data portability, GDPR compliance, system migrations, and manual reviews.

​
Summary

Use get_all() for bulk retrieval, search() for specific questions, and create_memory_export() for structured data exports with custom schemas. Remember exports expire after 7 days—download them locally for long-term archives.

Expire Short-Term Data

Keep exports lean by clearing session context before you archive it.

Control Memory Ingestion

Ensure only verified insights make it into your export pipeline.