feat: Add memory vs rag and migration section to docs

2 files changed, 640 insertions, 0 deletions

diff --git a/apps/docs/migration/from-mem0.mdx b/apps/docs/migration/from-mem0.mdx
new file mode 100644
index 00000000..e24a5548
--- /dev/null
+++ b/apps/docs/migration/from-mem0.mdx
@@ -0,0 +1,303 @@
+---
+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
+
+<Steps>
+  <Step title="Export from Mem0.ai">
+    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")
+    ```
+  </Step>
+
+  <Step title="Set Up Supermemory">
+    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"
+    ```
+  </Step>
+
+  <Step title="Import to Supermemory">
+    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!")
+    ```
+  </Step>
+</Steps>
+
+## API Migration Reference
+
+Here's how common Mem0.ai operations map to Supermemory:
+
+### Adding Memories
+
+<CodeGroup>
+
+```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"]
+)
+```
+
+</CodeGroup>
+
+### Searching Memories
+
+<CodeGroup>
+
+```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"]
+)
+```
+
+</CodeGroup>
+
+### Getting All Memories
+
+<CodeGroup>
+
+```python Mem0.ai
+memories = client.get_all(
+    user_id="alice"
+)
+```
+
+```python Supermemory
+memories = client.memories.list(
+    container_tags=["user_alice"],
+    limit=100
+)
+```
+
+</CodeGroup>
+
+### Deleting Memories
+
+<CodeGroup>
+
+```python Mem0.ai
+client.delete(memory_id="mem_123")
+```
+
+```python Supermemory
+client.memories.delete("mem_123")
+```
+
+</CodeGroup>
+
+## Using Memory Router (Easiest Migration)
+
+For the simplest migration path, use Supermemory's Memory Router which requires minimal code changes:
+
+<CodeGroup>
+
+```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-4",
+    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-4",
+    messages=[{"role": "user", "content": "What are my preferences?"}]
+)
+```
+
+</CodeGroup>
+
+<Note>
+For enterprise migrations, [contact us](mailto:[email protected]) for assistance.
+</Note>
+
+## 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
+
diff --git a/apps/docs/migration/mem0-migration-script.py b/apps/docs/migration/mem0-migration-script.py
new file mode 100644
index 00000000..7b05edf6
--- /dev/null
+++ b/apps/docs/migration/mem0-migration-script.py
@@ -0,0 +1,337 @@
+#!/usr/bin/env python3
+"""
+Mem0.ai to Supermemory Migration Script
+========================================
+Simple script to migrate memories from Mem0.ai to Supermemory.
+
+Prerequisites:
+1. Install required packages:
+   pip install mem0ai supermemory python-dotenv
+
+2. Set environment variables:
+   export MEM0_API_KEY="your_mem0_api_key"
+   export MEM0_ORG_ID="your_org_id"  # Optional
+   export MEM0_PROJECT_ID="your_project_id"  # Optional
+   export SUPERMEMORY_API_KEY="your_supermemory_api_key"
+
+Usage:
+   python mem0-migration-script.py
+"""
+
+import os
+import json
+import time
+from datetime import datetime
+from typing import Dict, Any, Optional
+from mem0 import MemoryClient
+from supermemory import Supermemory
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+def export_from_mem0(
+    api_key: str,
+    org_id: Optional[str] = None,
+    project_id: Optional[str] = None,
+    filters: Optional[Dict] = None
+) -> Dict[str, Any]:
+    """
+    Export memories from Mem0.ai using their export API
+    """
+    print("🔄 Starting Mem0.ai export...")
+    
+    # Initialize Mem0 client
+    client = MemoryClient(
+        api_key=api_key,
+        org_id=org_id,
+        project_id=project_id
+    )
+    
+    # Define export schema - this matches what Mem0 actually returns
+    export_schema = {
+        "type": "object",
+        "properties": {
+            "memories": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "id": {"type": "string"},
+                        "content": {"type": "string"},
+                        "user_id": {"type": "string"},
+                        "agent_id": {"type": "string"},
+                        "app_id": {"type": "string"},
+                        "run_id": {"type": "string"},
+                        "metadata": {"type": "object"},
+                        "created_at": {"type": "string"},
+                        "updated_at": {"type": "string"}
+                    }
+                }
+            }
+        }
+    }
+    
+    try:
+        # Step 1: Create export job
+        print("📤 Creating export job...")
+        export_response = client.create_memory_export(
+            schema=export_schema,
+            filters=filters if filters else {}
+        )
+        
+        export_id = export_response.get("id")
+        print(f"✅ Export job created with ID: {export_id}")
+        
+        # Step 2: Wait for export to complete
+        print("⏳ Waiting for export to complete...")
+        time.sleep(5)  # Usually takes a few seconds
+        
+        # Step 3: Retrieve the exported data using the correct method
+        print("📥 Retrieving exported data...")
+        export_data = client.get_memory_export(memory_export_id=export_id)
+        
+        # Step 4: Save backup
+        backup_filename = f"mem0_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        with open(backup_filename, "w") as f:
+            json.dump(export_data, f, indent=2)
+        print(f"💾 Backup saved to: {backup_filename}")
+        
+        memory_count = len(export_data.get("memories", []))
+        print(f"✅ Successfully exported {memory_count} memories from Mem0.ai")
+        
+        # Show sample of exported data
+        if memory_count > 0:
+            print("\n📋 Sample exported memory:")
+            sample = export_data["memories"][0]
+            print(f"  Content: {sample.get('content', 'N/A')[:50]}...")
+            print(f"  ID: {sample.get('id', 'None')}")
+            print(f"  User ID: {sample.get('user_id', 'None')}")
+        
+        return export_data
+        
+    except Exception as e:
+        print(f"❌ Error exporting from Mem0: {str(e)}")
+        raise
+
+def import_to_supermemory(mem0_data: Dict[str, Any], api_key: str) -> Dict[str, int]:
+    """
+    Import Mem0 memories into Supermemory
+    """
+    print("\n🚀 Starting import to Supermemory...")
+    
+    # Initialize Supermemory client
+    client = Supermemory(api_key=api_key)
+    
+    memories = mem0_data.get("memories", [])
+    if not memories:
+        print("⚠️  No memories found to import")
+        return {"imported": 0, "failed": 0, "skipped": 0}
+    
+    # Statistics
+    stats = {
+        "imported": 0,
+        "failed": 0,
+        "skipped": 0
+    }
+    
+    print(f"📦 Processing {len(memories)} memories...")
+    
+    for i, memory in enumerate(memories, 1):
+        try:
+            # Check if content exists
+            content = memory.get("content", "").strip()
+            if not content:
+                print(f"⚠️  [{i}/{len(memories)}] Skipping: No content")
+                stats["skipped"] += 1
+                continue
+            
+            # Build container tags
+            container_tags = ["imported_from_mem0"]
+            
+            # Add user tag if present (handle None values)
+            user_id = memory.get("user_id")
+            if user_id and user_id != "None":
+                container_tags.append(f"user_{user_id}")
+            
+            # Add agent tag if present
+            agent_id = memory.get("agent_id")
+            if agent_id and agent_id != "None":
+                container_tags.append(f"agent_{agent_id}")
+            
+            # Add app tag if present
+            app_id = memory.get("app_id")
+            if app_id and app_id != "None":
+                container_tags.append(f"app_{app_id}")
+            
+            # Add session tag if present
+            session_id = memory.get("session_id")
+            if session_id and session_id != "None":
+                container_tags.append(f"session_{session_id}")
+            
+            # Generate a unique ID if Mem0 didn't provide one
+            memory_id = memory.get("id")
+            if not memory_id or memory_id == "None":
+                # Use content hash for uniqueness
+                import hashlib
+                memory_id = hashlib.md5(content.encode()).hexdigest()[:8]
+            
+            # Prepare metadata
+            metadata = {
+                "source": "mem0_migration",
+                "migration_date": datetime.now().isoformat()
+            }
+            
+            # Add original ID if it existed
+            if memory.get("id") and memory["id"] != "None":
+                metadata["original_id"] = memory["id"]
+            
+            # Add timestamps if available and not None
+            created_at = memory.get("created_at")
+            if created_at and created_at != "None":
+                metadata["original_created_at"] = created_at
+            
+            updated_at = memory.get("updated_at")
+            if updated_at and updated_at != "None":
+                metadata["original_updated_at"] = updated_at
+            
+            # Add hash information if available
+            hash_val = memory.get("hash")
+            if hash_val and hash_val != "None":
+                metadata["original_hash"] = hash_val
+            
+            prev_hash = memory.get("prev_hash")
+            if prev_hash and prev_hash != "None":
+                metadata["original_prev_hash"] = prev_hash
+            
+            # Merge with existing metadata if it's a valid dict
+            if memory.get("metadata") and isinstance(memory["metadata"], dict):
+                metadata.update(memory["metadata"])
+            
+            # Import to Supermemory
+            result = client.memories.add(
+                content=content,
+                container_tags=container_tags,
+                custom_id=f"mem0_{memory_id}",
+                metadata=metadata
+            )
+            
+            stats["imported"] += 1
+            print(f"✅ [{i}/{len(memories)}] Imported: {content[:50]}...")
+            
+            # Small delay to avoid rate limiting
+            if i % 10 == 0:
+                time.sleep(0.5)
+            
+        except Exception as e:
+            stats["failed"] += 1
+            print(f"❌ [{i}/{len(memories)}] Failed: {str(e)}")
+    
+    return stats
+
+def verify_migration(api_key: str, expected_count: int):
+    """
+    Verify that memories were imported correctly
+    """
+    print("\n🔍 Verifying migration...")
+    
+    client = Supermemory(api_key=api_key)
+    
+    try:
+        # Check imported memories
+        result = client.memories.list(
+            container_tags=["imported_from_mem0"],
+            limit=100
+        )
+        
+        total_imported = result['pagination']['totalItems']
+        print(f"✅ Found {total_imported} imported memories in Supermemory")
+        
+        # Show sample memories
+        if result['memories']:
+            print("\n📋 Sample imported memories:")
+            for memory in result['memories'][:3]:
+                print(f"  - {memory['id']}: {memory.get('summary', 'No summary')[:50]}...")
+        
+        # Check success rate
+        success_rate = (total_imported / expected_count * 100) if expected_count > 0 else 0
+        print(f"\n📊 Migration success rate: {success_rate:.1f}%")
+        
+        return total_imported
+        
+    except Exception as e:
+        print(f"❌ Error during verification: {str(e)}")
+        return 0
+
+def main():
+    """Main migration function"""
+    print("=" * 60)
+    print("🎯 Mem0.ai to Supermemory Migration Tool")
+    print("=" * 60)
+    
+    # Get credentials from environment
+    mem0_api_key = os.getenv("MEM0_API_KEY")
+    mem0_org_id = os.getenv("MEM0_ORG_ID")
+    mem0_project_id = os.getenv("MEM0_PROJECT_ID")
+    supermemory_api_key = os.getenv("SUPERMEMORY_API_KEY")
+    
+    # Validate credentials
+    if not mem0_api_key:
+        print("❌ Error: MEM0_API_KEY environment variable not set")
+        return
+    
+    if not supermemory_api_key:
+        print("❌ Error: SUPERMEMORY_API_KEY environment variable not set")
+        return
+    
+    try:
+        # Step 1: Export from Mem0
+        print("\n📤 STEP 1: Export from Mem0.ai")
+        print("-" * 40)
+        
+        # You can add filters here if needed
+        # Example: filters = {"AND": [{"user_id": "specific_user"}]}
+        filters = None
+        
+        mem0_data = export_from_mem0(
+            api_key=mem0_api_key,
+            org_id=mem0_org_id,
+            project_id=mem0_project_id,
+            filters=filters
+        )
+        
+        # Step 2: Import to Supermemory
+        print("\n📥 STEP 2: Import to Supermemory")
+        print("-" * 40)
+        
+        stats = import_to_supermemory(mem0_data, supermemory_api_key)
+        
+        # Step 3: Verify migration
+        print("\n✔️  STEP 3: Verification")
+        print("-" * 40)
+        
+        expected_count = len(mem0_data.get("memories", []))
+        verify_migration(supermemory_api_key, expected_count)
+        
+        # Final summary
+        print("\n" + "=" * 60)
+        print("📊 MIGRATION SUMMARY")
+        print("=" * 60)
+        print(f"📤 Exported from Mem0: {expected_count}")
+        print(f"✅ Successfully imported: {stats['imported']}")
+        print(f"⚠️  Skipped (no content): {stats['skipped']}")
+        print(f"❌ Failed: {stats['failed']}")
+        
+        if stats['imported'] == expected_count - stats['skipped']:
+            print("\n🎉 Migration completed successfully!")
+        elif stats['imported'] > 0:
+            print("\n⚠️  Migration completed with some issues. Check the logs above.")
+        else:
+            print("\n❌ Migration failed. Please check your credentials and try again.")
+            
+    except Exception as e:
+        print(f"\n❌ Migration error: {str(e)}")
+        print("Please check your credentials and network connection.")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file