Skip to main content
Glama

mem0-mcp

MCP-Server, der die Mem0 v2-API bereitstellt, damit KI-Agenten Langzeitgedächtnisse über das standardisierte MCP-Protokoll mittels semantischer Suche speichern, abrufen und durchsuchen können.

mem0-mcp MCP-Server

Übersicht

Der Mem0-MCP-Server ist ein selbst gehosteter MCP-Server (Model Context Protocol), der KI-Agenten mit einem persistenten Speicher verbindet. Er ermöglicht eine intelligente Kontextspeicherung über Konversationen und Sitzungen hinweg unter Verwendung der AsyncMemory-API von Mem0.

Hauptfunktionen:

  • MCP-Protokollintegration - Stellt Mem0-Funktionalität über MCP-Tools bereit

  • Semantische Gedächtnissuche - Ähnlichkeitsbasierte Gedächtnisabfrage mit Vektorsuche

  • Multi-Tenant-Isolierung - Speicherisolierung nach Benutzer/Agent/Sitzung

  • Flexible Übertragung - stdio für lokale Agenten, SSE für Remote-Verbindungen

  • Konfigurationsmanagement - Pydantic-basierte Validierung mit Unterstützung für Umgebungsvariablen

Related MCP server: Amber

Dokumentation

Abschnitt

Beschreibung

API-Referenz

Vollständige API-Dokumentation für alle Module und Tools

Muster-Guides

Dokumentation von Entwurfsmustern (Singleton, Repository, etc.)

Nutzungsbeispiele

Anleitungen für den Einstieg und fortgeschrittene Nutzung

Bereitstellung

Docker Compose-Konfiguration und Servicedetails

Architektur

Systemarchitektur und Interaktionen der Komponenten

Schnellstart

Installation

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

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

Konfiguration

Erstellen Sie ~/.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"
    }
  }
}

Starten des Servers

# 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

MCP-Tools

Tool

Beschreibung

add_memory

Informationen im Langzeitgedächtnis mit semantischer Indizierung speichern

search_memories

Gedächtnisse mittels semantischer Ähnlichkeit durchsuchen

get_memory

Bestimmtes Gedächtnis anhand der ID abrufen

update_memory

Bestehenden Gedächtnisinhalt aktualisieren

delete_memory

Gedächtnis aus dem Speicher entfernen

list_memories

Gedächtnisse mit Filterung und Paginierung auflisten

Nutzungsbeispiel

# 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
})

Architektur

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

Komponenten:

  • COMP-1: ConfigLoader - Konfigurationsladen und -validierung

  • COMP-2: FastMCP Server - MCP-Protokollserver

  • COMP-3: MemoryManager - Speicheroperationen mit Multi-Tenant-Isolierung

  • COMP-4: MCP Tools - Tool-Definitionen

  • COMP-5: SafeLogger - Trennung der Ausgabeströme

Konfiguration

Parameter-Rangfolge

Konfigurationswerte werden in folgender Reihenfolge aufgelöst:

  1. Tool-Parameter (direkt)

  2. Umgebungsvariablen (mit MCP_-Präfix)

  3. Konfigurationsdatei-Werte

  4. Fest codierte Standardwerte

Umgebungsvariablen

Variable

Standardwert

Beschreibung

OPENAI_API_KEY

(erforderlich)

OpenAI-API-Schlüssel für LLM

MCP_TRANSPORT

sse

Übertragungstyp (stdio, sse)

MCP_HOST

0.0.0.0

Bind-Adresse des Servers

MCP_PORT

8080

Bind-Port des Servers

Bereitstellung

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

Dienste:

Dienst

Beschreibung

mem0-mcp

MCP-Server, der die Mem0-API auf Port 8050 bereitstellt

ollama-qwen3-embedding

Ollama mit qwen3-embedding:8b für Vektor-Embeddings (Port 11434)

ollama-qwen

Ollama mit qwen2.5:7b für Chat-Vervollständigungen (Port 11435)

Siehe Bereitstellung → Docker für eine detaillierte Konfiguration.

Kubernetes

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

Entwicklung

Befehl

Beschreibung

make install

Abhängigkeiten mit uv installieren

make lint

Code mit ruff prüfen

make lint-fix

Linting-Probleme automatisch beheben

make typecheck

Typüberprüfung mit pyright

make test

Alle Tests ausführen

make test-unit

Nur Unit-Tests ausführen

make test-coverage

Tests mit Coverage-Bericht ausführen

make build

Docker-Image bauen

make run

Entwicklungsserver starten

Mehrere Befehle ausführen: make install && make lint && make typecheck && make test

Siehe Makefile für alle verfügbaren Befehle, einschließlich Docker-Management (docker-up, docker-down, docker-logs usw.).

Projektstruktur

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

Lizenz

MIT-Lizenz

Maintenance

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • 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
  • 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
    11
    3
    Apache 2.0
  • A
    license
    Not graded
    quality
    B
    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.
    75
    1
    -