Skip to main content
Glama
Sign In
deenesjakoruzh
mem0-mcp

mem0-mcp

by olk
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Hybrid

mem0-mcp-server

MCP server exposing Mem0 v2 API for AI agents to store, retrieve, and search long-term memories using semantic search through the standardized MCP protocol.

Overview

Mem0-MCP Server is a self-hosted MCP (Model Context Protocol) server that bridges AI agents with persistent memory storage. It enables intelligent context retention across conversations and sessions using Mem0's AsyncMemory API.

Key Features:

  • MCP Protocol Integration - Exposes Mem0 functionality via MCP tools

  • Semantic Memory Search - Similarity-based memory retrieval with vector search

  • Multi-Tenant Isolation - User/Agent/Session scoped memory isolation

  • Flexible Transport - stdio for local agents, SSE for remote connections

  • Configuration Management - Pydantic-based validation with environment variable support

Related MCP server: Amber

Documentation

Section

Description

API Reference

Complete API documentation for all modules and tools

Pattern Guides

Design pattern documentation (Singleton, Repository, etc.)

Usage Examples

Getting started and advanced usage guides

Deployment

Docker Compose configuration and service details

Architecture

System architecture and component interactions

Quick Start

Installation

# Clone and install
git clone https://github.com/your-org/mem0-mcp-server.git
cd mem0-mcp-server
uv sync

# Set environment variables
export OPENAI_API_KEY="your-api-key"

Configuration

Create ~/.config/mem0-mcp-server/settings.json:

{
  "vector_store": {
    "provider": "redis",
    "config": {
      "redis_url": "redis://localhost:6379"
    }
  },
  "llm": {
    "provider": "openai",
    "config": {
      "model": "gpt-4o"
    }
  },
  "embedder": {
    "provider": "openai",
    "config": {
      "model": "text-embedding-3-small"
    }
  }
}

Running the Server

# SSE Transport (remote connections)
uv run python -m mcp_server.main

# stdio Transport (local AI agents)
export MCP_TRANSPORT=stdio
uv run python -m mcp_server.main

OpenCode Configuration

In ~/config/opencode/opencode.json

OpenCode Configuration

In ~/config/opencode/opencode.json

	"mcp": {
		"mem0": {
			"type": "remote",
			"enabled": true,
			"url": "http://localhost:8050/sse"
		}
    }

MCP Tools

Tool

Description

add_memory

Store information in long-term memory with semantic indexing

search_memories

Search memories using semantic similarity

get_memory

Retrieve specific memory by ID

update_memory

Update existing memory content

delete_memory

Remove memory from storage

list_memories

List memories with filtering and pagination

Usage Example

# Add memory
result = await client.call_tool("add_memory", {
    "messages": [{"role": "user", "content": "I prefer dark mode"}],
    "user_id": "alice"
})

# Search memories
result = await client.call_tool("search_memories", {
    "query": "theme preferences",
    "filters": {"user_id": "alice"},
    "limit": 5
})

Architecture

AI Agent → FastMCP Server → MemoryManager → Mem0 AsyncMemory → Redis
              │                                  │
              ├── SafeLogger (stdout/stderr)     │
              ├── Transport (stdio/SSE)          │
              └── Config (Pydantic validation)   │

Components:

  • COMP-1: ConfigLoader - Configuration loading and validation

  • COMP-2: FastMCP Server - MCP protocol server

  • COMP-3: MemoryManager - Memory operations with multi-tenant isolation

  • COMP-4: MCP Tools - Tool definitions

  • COMP-5: SafeLogger - Output stream separation

Configuration

Parameter Precedence

Configuration values are resolved in order:

  1. Tool parameters (direct)

  2. Environment variables (with MCP_ prefix)

  3. Config file values

  4. Hardcoded defaults

Environment Variables

Variable

Default

Description

OPENAI_API_KEY

(required)

OpenAI API key for LLM

MCP_TRANSPORT

sse

Transport type (stdio, sse)

MCP_HOST

0.0.0.0

Server bind address

MCP_PORT

8080

Server bind port

Deployment

Docker

# Using docker-compose
docker-compose up -d

# Using Makefile
make docker-up      # Start services with docker compose
make docker-down    # Stop services
make docker-logs    # Show logs

Services:

Service

Description

mem0-mcp

MCP server exposing Mem0 API on port 8050

ollama-qwen3-embedding

Ollama with qwen3-embedding:8b for vector embeddings (port 11434)

ollama-qwen

Ollama with qwen2.5:7b for chat completions (port 11435)

See Deployment → Docker for detailed configuration.

Kubernetes

# Using Helm chart
helm install mem0-mcp ./charts/mem0-mcp-server

Development

Command

Description

make install

Install dependencies with uv

make lint

Lint code with ruff

make lint-fix

Auto-fix linting issues

make typecheck

Type check with pyright

make test

Run all tests

make test-unit

Run unit tests only

make test-coverage

Run tests with coverage report

make build

Build Docker image

make run

Run development server

Run multiple commands: make install && make lint && make typecheck && make test

See Makefile for all available commands including Docker management (docker-up, docker-down, docker-logs, etc.).

Project Structure

mem0-mcp/
├── src/mcp_server/
│   ├── __init__.py          # FastMCP singleton
│   ├── lifespan.py          # Resource lifecycle
│   ├── transport.py         # Transport selection
│   ├── memory/
│   │   ├── manager.py        # MemoryManager
│   │   └── lifespan.py       # AsyncMemory lifecycle
│   ├── config/
│   │   ├── settings.py       # Pydantic models
│   │   └── loader.py        # Config file loading
│   ├── tools/
│   │   ├── add_memory.py
│   │   ├── search_memories.py
│   │   └── ...
│   └── utils/
│       └── safe_logger.py   # Output separation
├── doc/
│   ├── api/                 # API reference
│   ├── patterns/            # Pattern guides
│   ├── examples/            # Usage examples
│   └── architecture/        # Architecture docs
├── tests/
├── Makefile
├── Dockerfile
└── docker-compose.yml

License

MIT License

This server cannot be deployed

Context All Your Agents Can ShareAgents share what they learn, hand off work, and hold it when you switch models. Start with 5 GB free.fulcradynamics.comAd

Maintenance

ActivityInactive
ResponsivenessNo issues

Resources

Related MCP Connectors

Related MCP Servers

  • Amber

    Amberofficial

    ambermem
    A
    license
    A
    quality
    B
    maintenance
    Gives your AI persistent memory across conversations. Stores facts automatically, finds them by meaning using hybrid search with query expansion, and organizes everything into topics without manual tagging.
    18
    1
    MIT

  • Statewave

    smaramwbc
    A
    license
    A
    quality
    A
    maintenance
    MCP server for Statewave, an open-source memory runtime for AI agents. Provides persistent memory, context retrieval, and memory compilation through the Model Context Protocol.
    6
    15 npm
    4
    Apache 2.0

  • agenticmemory

    jyswee
    F
    license
    Not graded
    quality
    C
    maintenance
    Persistent memory MCP server for AI agents that stores, recalls, and searches conversation history, key-value context, and long-term entries across sessions with semantic search and FIFO queues.
    526 npm
    1
    -