MCP-Mem0

y# 🐕 PomPom-AI: Intelligent Memory System for Qodo AI

PomPom-AI (PomPom Artificial Intelligence) - A smart MCP (Model Context Protocol) server that provides persistent memory capabilities for Qodo AI. Just like Pompompurin's friendly and reliable nature, PomPom-AI remembers everything important and helps your AI assistant provide personalized, intelligent responses across all conversations.

🎯 Personal Setup for Qodo AI Integration

This repository is configured for personal use with Qodo AI, providing long-term memory storage and retrieval capabilities.

Qodo AI MCP Configuration

{
  "pompom-ai": {
    "url": "http://localhost:8051/sse"
  }
}

Related MCP server: MCP-Mem0

🚀 Quick Start Guide

Prerequisites

• Python 3.12+

• OpenRouter API key (for Claude 3.7 Sonnet)

• Supabase PostgreSQL database (configured)

Installation

1. Clone and setup:

   git clone <your-repo-url>
   cd pompom-ai
   pip install -e .

2. Configure environment: Copy .env.example to .env and update with your credentials:

   TRANSPORT=sse
   HOST=0.0.0.0
   PORT=8051
   LLM_PROVIDER=openrouter
   LLM_BASE_URL=https://openrouter.ai/api/v1
   LLM_API_KEY=your-openrouter-api-key
   LLM_CHOICE=anthropic/claude-3.7-sonnet
   DATABASE_URL=your-supabase-postgresql-url

3. Start the server:

   python src/main.py

4. Test connectivity:

   .\test_server.ps1

🧠 How It Works - Detailed Explanation

Architecture Overview

Qodo AI ←→ MCP Protocol ←→ PomPom-AI Server ←→ Mem0 ←→ ChromaDB + PostgreSQL

Component Breakdown

1. MCP Server (src/main.py)

• FastMCP Framework: Handles MCP protocol communication

• SSE Transport: Server-Sent Events for real-time communication on port 8051

• Lifespan Management: Initializes and manages Mem0 client connection

• Three Core Tools: Exposes memory operations to Qodo AI

2. Memory Tools Available to Qodo AI

save_memory(text: str)

• Purpose: Store any information in long-term memory

• Usage: When you tell Qodo AI something important to remember

• Process:

  1. Receives text from Qodo AI

  2. Processes through Claude 3.7 Sonnet for fact extraction

  3. Generates embeddings using ChromaDB's built-in model

  4. Stores in both ChromaDB (vectors) and PostgreSQL (metadata)

get_all_memories()

• Purpose: Retrieve all stored memories for context

• Usage: When Qodo AI needs complete memory context

• Process:

  1. Queries Mem0 for all memories associated with default user

  2. Returns paginated results (50 items default)

  3. Provides full context for conversation continuity

search_memories(query: str, limit: int = 3)

• Purpose: Find relevant memories using semantic search

• Usage: When Qodo AI needs specific information

• Process:

  1. Converts query to embeddings

  2. Performs vector similarity search in ChromaDB

  3. Returns most relevant memories ranked by relevance

3. Memory Configuration (src/utils.py)

LLM Configuration (OpenRouter + Claude)

llm_config = {
    "provider": "openai",  # OpenRouter uses OpenAI-compatible API
    "config": {
        "model": "anthropic/claude-3.7-sonnet",
        "temperature": 0.2,  # Low temperature for consistent memory processing
        "max_tokens": 1500
    }
}

Embedding Configuration (ChromaDB Built-in)

• No external API calls: Uses ChromaDB's default embedding function

• Local processing: Embeddings generated locally for privacy

• No additional costs: No embedding API fees

Vector Store Configuration (ChromaDB)

vector_store_config = {
    "provider": "chroma",
    "config": {
        "collection_name": "mem0_memories",
        "path": "./chroma_db"  # Local SQLite database
    }
}

4. Data Flow When You Use Qodo AI

Saving a Memory:

You: "Remember that I prefer PowerShell for automation tasks"
↓
Qodo AI → MCP Protocol → PomPom-AI → save_memory("I prefer PowerShell for automation tasks")
↓
Claude 3.7 Sonnet processes and extracts key facts
↓
ChromaDB generates embeddings locally
↓
Stored in: ChromaDB (vectors) + PostgreSQL (metadata)
↓
PomPom-AI Response: "Successfully saved memory: I prefer PowerShell for automation tasks"

Retrieving Memories:

You: "What do you know about my preferences?"
↓
Qodo AI → MCP Protocol → PomPom-AI → search_memories("preferences", limit=5)
↓
ChromaDB performs vector similarity search
↓
PomPom-AI returns relevant memories about your preferences
↓
Qodo AI uses this context to provide personalized responses

5. Storage Architecture

ChromaDB (Local - ./chroma_db/)

• Vector embeddings: Semantic representations of memories

• Fast similarity search: Sub-second query responses

• Local SQLite: No external dependencies

• Collection: mem0_memories

PostgreSQL (Supabase)

• Metadata storage: User associations, timestamps

• Structured data: Relationships and memory organization

• Cloud backup: Persistent storage across devices

• Scalability: Handles large memory datasets

🔧 Memory Management Tools

View Current Memories

# Python script
python show_current_memories.py

# PowerShell script
.\show_memories.ps1

Visual Dashboard

# Streamlit dashboard
streamlit run chroma_viewer.py

# HTML dashboard with live data
python dashboard_server.py

Server Testing

# Test server connectivity
.\test_server.ps1

📊 Memory Analytics

The system tracks:

• Total memories stored

• Memory categories/collections

• Average memory length

• Search frequency patterns

• Memory creation timestamps

🔒 Privacy & Security

• Local embeddings: No data sent to external embedding APIs

• Encrypted storage: PostgreSQL with SSL

• Local processing: ChromaDB runs entirely on your machine

• API key security: Environment variables only

🎛️ Configuration Options

Memory Processing

• Temperature: 0.2 (consistent fact extraction)

• Max tokens: 1500 (detailed memory processing)

• Model: Claude 3.7 Sonnet (high-quality reasoning)

Search Parameters

• Default limit: 3 memories per search

• Similarity threshold: Automatic (ChromaDB optimized)

• Collection scope: Single user (isolated memories)

🚀 Usage Patterns with Qodo AI

Personal Information

"Remember that I work as a software engineer and prefer Python and PowerShell"
"I live in timezone UTC+3"
"My favorite IDE is VS Code"

Project Context

"I'm working on a MCP server project using FastMCP and Mem0"
"The project uses OpenRouter for LLM and ChromaDB for vectors"
"Port 8051 is used for the SSE transport"

Preferences & Settings

"I prefer detailed explanations with code examples"
"Always use PowerShell for Windows automation tasks"
"Format code blocks with syntax highlighting"

🔄 Maintenance

Regular Tasks

• Monitor ChromaDB size (./chroma_db/)

• Check PostgreSQL connection health

• Review memory quality and relevance

• Update API keys as needed

Troubleshooting

• Server won't start: Check .env configuration

• Memory not saving: Verify PostgreSQL connection

• Search not working: Restart server to refresh ChromaDB

• Qodo AI can't connect: Confirm port 8051 is open

📈 Performance Optimization

• ChromaDB: Optimized for <1000 memories per collection

• PostgreSQL: Indexed for fast metadata queries

• Memory size: Optimal range 50-500 characters per memory

• Search speed: Sub-100ms for typical queries

🎯 Best Practices

1. Memory Quality: Store specific, actionable information

2. Regular Cleanup: Remove outdated or irrelevant memories

3. Categorization: Use consistent language for similar topics

4. Testing: Regularly test memory retrieval accuracy

5. Backup: PostgreSQL provides automatic cloud backup

This system transforms Qodo AI into a truly personalized assistant that remembers your preferences, project context, and important information across all conversations.

🐕 Why "PomPom-AI"?

Just like Pompompurin is known for being:

• 🤗 Friendly & Reliable - PomPom-AI is always there to help remember what's important

• 🧠 Smart & Attentive - Intelligently processes and organizes your memories

• 💛 Loyal Companion - Grows smarter about your preferences over time

• 🎯 Focused & Efficient - Quickly finds exactly what you need when you need it

PomPom-AI = PomPom (friendly like Pompompurin) + AI (Artificial Intelligence)