Mem0 (Long-Term Memory)

by coleam00

107 stars
474 downloads
Not rated
GitHub

About

Provides persistent long-term memory capabilities through semantic indexing, retrieval, and search functions with support for multiple LLM providers and PostgreSQL vector storage.

Details

Author
coleam00
Repository
coleam00/mcp-mem0
GitHub stars
107
Downloads
474
License
MIT License
Categories
Developer Tools, Design, File Management, AI, Search, Database, Knowledge Base, Infrastructure, Frontend

Jump to

The server provides three essential memory management tools:

1. save_memory: Store any information in long-term memory with semantic indexing
2. get_all_memories: Retrieve all stored memories for comprehensive context
3. search_memories: Find relevant memories using semantic search

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

  1. Download and install Highlight from highlightai.com/download
  2. Navigate to the plugins tab and select "Add Custom Plugin"
  3. Configure the plugin with the settings below
    Plugin Name Mem0 (Long-Term Memory)
    Command (node, npx, python, etc.) python
    Arguments
    • Argument 1 your/path/to/mcp-mem0/src/main.py
    Environment
    • TRANSPORT stdio
    • LLM_CHOICE gpt-4o-mini
    • LLM_API_KEY YOUR-API-KEY
    • DATABASE_URL YOUR-DATABASE-URL
    • LLM_BASE_URL https://api.openai.com/v1
    • LLM_PROVIDER openai
    • EMBEDDING_MODEL_CHOICE text-embedding-3-small

    Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.

  4. Enable "Start Automatically" if you want the plugin to start when Highlight launches

From the repository

The following environment variables can be configured in your .env file:

| Variable | Description | Example |
|----------|-------------|----------|
| TRANSPORT | Transport protocol (sse or stdio) | sse |
| HOST | Host to bind to when using SSE transport | 0.0.0.0 |
| PORT | Port to listen on when using SSE transport | 8050 |
| LLM_PROVIDER | LLM provider (openai, openrouter, or ollama) | openai |
| LLM_BASE_URL | Base URL for the LLM API | https://api.openai.com/v1 |
| LLM_API_KEY | API key for the LLM provider | sk-... |
| LLM_CHOICE | LLM model to use | gpt-4o-mini |
| EMBEDDING_MODEL_CHOICE | Embedding model to use | text-embedding-3-small |
| DATABASE_URL | PostgreSQL connection string | postgresql://user:pass@host:port/db |

Once you have the server running with SSE transport, you can connect to it using this configuration:

{
  "mcpServers": {
    "mem0": {
      "transport": "sse",
      "url": "http://localhost:8050/sse"
    }
  }
}

> Note for Windsurf users: Use serverUrl instead of url in your configuration:
> 

> {

>   "mcpServers": {

>     "mem0": {

>       "transport": "sse",

>       "serverUrl": "http://localhost:8050/sse"

>     }

>   }

> }

>

> Note for n8n users: Use host.docker.internal instead of localhost since n8n has to reach outside of it's own container to the host machine:
>
> So the full URL in the MCP node would be: http://host.docker.internal:8050/sse

Make sure to update the port if you are using a value other than the default 8050.

Add this server to your MCP configuration for Claude Desktop, Windsurf, or any other MCP client:

{
  "mcpServers": {
    "mem0": {
      "command": "your/path/to/mcp-mem0/.venv/Scripts/python.exe",
      "args": ["your/path/to/mcp-mem0/src/main.py"],
      "env": {
        "TRANSPORT": "stdio",
        "LLM_PROVIDER": "openai",
        "LLM_BASE_URL": "https://api.openai.com/v1",
        "LLM_API_KEY": "YOUR-API-KEY",
        "LLM_CHOICE": "gpt-4o-mini",
        "EMBEDDING_MODEL_CHOICE": "text-embedding-3-small",
        "DATABASE_URL": "YOUR-DATABASE-URL"
      }
    }
  }
}

{
  "mcpServers": {
    "mem0": {
      "command": "docker",
      "args": ["run", "--rm", "-i", 
               "-e", "TRANSPORT", 
               "-e", "LLM_PROVIDER", 
               "-e", "LLM_BASE_URL", 
               "-e", "LLM_API_KEY", 
               "-e", "LLM_CHOICE", 
               "-e", "EMBEDDING_MODEL_CHOICE", 
               "-e", "DATABASE_URL", 
               "mcp/mem0"],
      "env": {
        "TRANSPORT": "stdio",
        "LLM_PROVIDER": "openai",
        "LLM_BASE_URL": "https://api.openai.com/v1",
        "LLM_API_KEY": "YOUR-API-KEY",
        "LLM_CHOICE": "gpt-4o-mini",
        "EMBEDDING_MODEL_CHOICE": "text-embedding-3-small",
        "DATABASE_URL": "YOUR-DATABASE-URL"
      }
    }
  }
}

save_memory

Store any information in long-term memory with semantic indexing.

get_all_memories

Retrieve all stored memories for comprehensive context.

search_memories

Find relevant memories using semantic search.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "mem0 (long-term memory)": {
            "env": {
                "TRANSPORT": "stdio",
                "LLM_CHOICE": "gpt-4o-mini",
                "LLM_API_KEY": "YOUR-API-KEY",
                "DATABASE_URL": "YOUR-DATABASE-URL",
                "LLM_BASE_URL": "https://api.openai.com/v1",
                "LLM_PROVIDER": "openai",
                "EMBEDDING_MODEL_CHOICE": "text-embedding-3-small"
            },
            "args": [
                "your/path/to/mcp-mem0/src/main.py"
            ],
            "command": "python"
        }
    }
}

Linux

{
    "env": {
        "TRANSPORT": "stdio",
        "LLM_CHOICE": "gpt-4o-mini",
        "LLM_API_KEY": "YOUR-API-KEY",
        "DATABASE_URL": "YOUR-DATABASE-URL",
        "LLM_BASE_URL": "https://api.openai.com/v1",
        "LLM_PROVIDER": "openai",
        "EMBEDDING_MODEL_CHOICE": "text-embedding-3-small"
    },
    "args": [
        "your/path/to/mcp-mem0/src/main.py"
    ],
    "command": "python"
}

Macos

{
    "env": {
        "TRANSPORT": "stdio",
        "LLM_CHOICE": "gpt-4o-mini",
        "LLM_API_KEY": "YOUR-API-KEY",
        "DATABASE_URL": "YOUR-DATABASE-URL",
        "LLM_BASE_URL": "https://api.openai.com/v1",
        "LLM_PROVIDER": "openai",
        "EMBEDDING_MODEL_CHOICE": "text-embedding-3-small"
    },
    "args": [
        "your/path/to/mcp-mem0/src/main.py"
    ],
    "command": "python"
}

Windows

{
    "env": {
        "TRANSPORT": "stdio",
        "LLM_CHOICE": "gpt-4o-mini",
        "LLM_API_KEY": "YOUR-API-KEY",
        "DATABASE_URL": "YOUR-DATABASE-URL",
        "LLM_BASE_URL": "https://api.openai.com/v1",
        "LLM_PROVIDER": "openai",
        "EMBEDDING_MODEL_CHOICE": "text-embedding-3-small"
    },
    "args": [
        "/c",
        "your/path/to/mcp-mem0/.venv/Scripts/python.exe",
        "your/path/to/mcp-mem0/src/main.py"
    ],
    "command": "cmd"
}

<h1 align="center">MCP-Mem0: Long-Term Memory for AI Agents</h1>

<p align="center">
Mem0 and MCP Integration
</p>

A template implementation of the Model Context Protocol (MCP) server integrated with Mem0 for providing AI agents with persistent memory capabilities.

Use this as a reference point to build your MCP servers yourself, or give this as an example to an AI coding assistant and tell it to follow this example for structure and code correctness!

Overview

This project demonstrates how to build an MCP server that enables AI agents to store, retrieve, and search memories using semantic search. It serves as a practical template for creating your own MCP servers, simply using Mem0 and a practical example.

The implementation follows the best practices laid out by Anthropic for building MCP servers, allowing seamless integration with any MCP-compatible client.

Features

The server provides three essential memory management tools:

1. save_memory: Store any information in long-term memory with semantic indexing
2. get_all_memories: Retrieve all stored memories for comprehensive context
3. search_memories: Find relevant memories using semantic search

Prerequisites

- Python 3.12+
- Supabase or any PostgreSQL database (for vector storage of memories)
- API keys for your chosen LLM provider (OpenAI, OpenRouter, or Ollama)
- Docker if running the MCP server as a container (recommended)

Installation

Using uv

1. Install uv if you don't have it:

   pip install uv

2. Clone this repository:

   git clone https://github.com/coleam00/mcp-mem0.git

   cd mcp-mem0

3. Install dependencies:

   uv pip install -e .

4. Create a .env file based on .env.example:

   cp .env.example .env

5. Configure your environment variables in the .env file (see Configuration section)

Using Docker (Recommended)

1. Build the Docker image:

   docker build -t mcp/mem0 --build-arg PORT=8050 .

2. Create a .env file based on .env.example and configure your environment variables

Configuration

The following environment variables can be configured in your .env file:

| Variable | Description | Example |
|----------|-------------|----------|
| TRANSPORT | Transport protocol (sse or stdio) | sse |
| HOST | Host to bind to when using SSE transport | 0.0.0.0 |
| PORT | Port to listen on when using SSE transport | 8050 |
| LLM_PROVIDER | LLM provider (openai, openrouter, or ollama) | openai |
| LLM_BASE_URL | Base URL for the LLM API | https://api.openai.com/v1 |
| LLM_API_KEY | API key for the LLM provider | sk-... |
| LLM_CHOICE | LLM model to use | gpt-4o-mini |
| EMBEDDING_MODEL_CHOICE | Embedding model to use | text-embedding-3-small |
| DATABASE_URL | PostgreSQL connection string | postgresql://user:pass@host:port/db |

Running the Server

Using uv

SSE Transport

# Set TRANSPORT=sse in .env then:
uv run src/main.py

The MCP server will essentially be run as an API endpoint that you can then connect to with config shown below.

Stdio Transport

With stdio, the MCP client iself can spin up the MCP server, so nothing to run at this point.

Using Docker

SSE Transport

docker run --env-file .env -p:8050:8050 mcp/mem0

The MCP server will essentially be run as an API endpoint within the container that you can then connect to with config shown below.

Stdio Transport

With stdio, the MCP client iself can spin up the MCP server container, so nothing to run at this point.

Integration with MCP Clients

SSE Configuration

Once you have the server running with SSE transport, you can connect to it using this configuration:

{
  "mcpServers": {
    "mem0": {
      "transport": "sse",
      "url": "http://localhost:8050/sse"
    }
  }
}

> Note for Windsurf users: Use serverUrl instead of url in your configuration:
> 

> {

>   "mcpServers": {

>     "mem0": {

>       "transport": "sse",

>       "serverUrl": "http://localhost:8050/sse"

>     }

>   }

> }

>

> Note for n8n users: Use host.docker.internal instead of localhost since n8n has to reach outside of it's own container to the host machine:
>
> So the full URL in the MCP node would be: http://host.docker.internal:8050/sse

Make sure to update the port if you are using a value other than the default 8050.

Python with Stdio Configuration

Add this server to your MCP configuration for Claude Desktop, Windsurf, or any other MCP client:

{
  "mcpServers": {
    "mem0": {
      "command": "your/path/to/mcp-mem0/.venv/Scripts/python.exe",
      "args": ["your/path/to/mcp-mem0/src/main.py"],
      "env": {
        "TRANSPORT": "stdio",
        "LLM_PROVIDER": "openai",
        "LLM_BASE_URL": "https://api.openai.com/v1",
        "LLM_API_KEY": "YOUR-API-KEY",
        "LLM_CHOICE": "gpt-4o-mini",
        "EMBEDDING_MODEL_CHOICE": "text-embedding-3-small",
        "DATABASE_URL": "YOUR-DATABASE-URL"
      }
    }
  }
}

Docker with Stdio Configuration

{
  "mcpServers": {
    "mem0": {
      "command": "docker",
      "args": ["run", "--rm", "-i", 
               "-e", "TRANSPORT", 
               "-e", "LLM_PROVIDER", 
               "-e", "LLM_BASE_URL", 
               "-e", "LLM_API_KEY", 
               "-e", "LLM_CHOICE", 
               "-e", "EMBEDDING_MODEL_CHOICE", 
               "-e", "DATABASE_URL", 
               "mcp/mem0"],
      "env": {
        "TRANSPORT": "stdio",
        "LLM_PROVIDER": "openai",
        "LLM_BASE_URL": "https://api.openai.com/v1",
        "LLM_API_KEY": "YOUR-API-KEY",
        "LLM_CHOICE": "gpt-4o-mini",
        "EMBEDDING_MODEL_CHOICE": "text-embedding-3-small",
        "DATABASE_URL": "YOUR-DATABASE-URL"
      }
    }
  }
}

Building Your Own Server

This template provides a foundation for building more complex MCP servers. To build your own:

1. Add your own tools by creating methods with the @mcp.tool() decorator
2. Create your own lifespan function to add your own dependencies (clients, database connections, etc.)
3. Modify the utils.py file for any helper functions you need for your MCP server
4. Feel free to add prompts and resources as well with @mcp.resource() and @mcp.prompt()

No reviews yet — be the first

Sign in to leave a review

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

Install

Add to Claude Desktop or Cursor

{
    "mcpServers": {
        "mem0 (long-term memory)": {
            "env": {
                "TRANSPORT": "stdio",
                "LLM_CHOICE": "gpt-4o-mini",
                "LLM_API_KEY": "YOUR-API-KEY",
                "DATABASE_URL": "YOUR-DATABASE-URL",
                "LLM_BASE_URL": "https://api.openai.com/v1",
                "LLM_PROVIDER": "openai",
                "EMBEDDING_MODEL_CHOICE": "text-embedding-3-small"
            },
            "args": [
                "your/path/to/mcp-mem0/src/main.py"
            ],
            "command": "python"
        }
    }
}

More like this

Similar MCP servers you might find useful

Browse category

Git

A Model Context Protocol (MCP) server that provides tools for LLMs to read, search, and manipulate Git repositories. It enables automated repository…

88.1k
Developer Tools

Context 7

Official Context7 MCP server that brings up-to-date, version-specific library documentation and code examples into AI coding prompts.

58.7k
Developer Tools

Playwright

Official Playwright MCP server for browser automation, page inspection, screenshots, and web interaction from Claude, Cursor, and other AI agents.

34.8k
Web Scraping