memoraeu-server

Zero-knowledge persistent memory layer for LLMs — AES-256-GCM encrypted, semantic search via Qdrant, MCP server for Claude Desktop / Sovereign European MCP memory layer — self-hostable, AGPL v3

1 stars PythonOthers Updated Aug 3, 2026

aes-256aes-256-gcmaiclaudeclaude-codeencryptioneuropeanfastapillmmcpmcp-servermemoryprivacypythonqdrantself-hostedsemantic-searchvector-searchzero-knowledge

Documentation

MemoraEU Server

🇫🇷 Français · 🇬🇧 English

Français

> MemoraEU donne à votre IA une mémoire persistante et chiffrée —

> souveraine, zero-knowledge, hébergée en Europe.

> Compatible Claude, Cursor, Windsurf, ChatGPT, GitHub Copilot, n8n via MCP.

> Auto-hébergement gratuit (AGPL v3) ou cloud géré EU

Ce que ça fait

MemoraEU est un serveur de mémoire auto-hébergeable pour les assistants IA. Il implémente le Model Context Protocol (MCP) pour que n'importe quel client MCP (Claude, Cursor, Windsurf, ChatGPT, GitHub Copilot, n8n…)

Recherche sémantique propulsée par Qdrant + embeddings (Ollama ou Mistral)
Multi-utilisateur / multi-org avec auth JWT
Transports MCP : Legacy SSE (Cursor, curl) + HTTP Streamable (claude.ai, Copilot, n8n)
Faits temporels avec périodes de validité
Chiffrement zero-knowledge AES-256-GCM côté client (memoraeu-mcp)
RGPD natif : endpoints export / suppression / historique intégrés
Fusion intelligente : détection et merge de mémoires similaires via LLM (Mistral/Ollama)

Démarrage rapide

☁️ Option A — Cloud géré (zéro config)

bash

# Installer le client MCP
uvx memoraeu-mcp

# Ajouter dans votre config Claude Desktop :
# Server URL : https://api.memoraeu.com/mcp/sse
# Clé API sur : https://app.memoraeu.com

🏠 Option B — Auto-hébergement (gratuit, AGPL v3)

bash

git clone https://github.com/pquattro/memoraeu-server
cd memoraeu-server
cp .env.example .env   # remplir MEMORAEU_SECRET, MEMORAEU_SALT, MISTRAL_API_KEY
docker compose up -d
# API disponible sur http://localhost:8000
# Docs : http://localhost:8000/docs
# Serveur MCP : http://localhost:8000/mcp/sse

Configuration

Toute la configuration se fait via variables d'environnement (voir `.env.example`)

Variable	Défaut	Description
`JWT_SECRET`	—	Requis. 32 caractères minimum.
`REGISTRATION_OPEN`	`true`	Autoriser les nouvelles inscriptions
`EMBED_PROVIDER`	`ollama`	`ollama` ou `mistral`
`EMBED_MODEL`	`nomic-embed-text`	Nom du modèle d'embedding
`EMBED_URL`	`http://localhost:11434`	URL de base Ollama
`MISTRAL_API_KEY`	—	Requis si `EMBED_PROVIDER=mistral`
`QDRANT_URL`	`http://qdrant:6333`	URL de l'instance Qdrant
`SQLITE_PATH`	`/data/memoraeu.db`	Chemin de la base SQLite
`MCP_ALLOWED_HOSTS`	`localhost,127.0.0.1,localhost:8000,127.0.0.1:8000`	Hôtes acceptés sur `/mcp/` (protection DNS rebinding). Ajoutez votre domaine si vous exposez le serveur, sinon les requêtes sont rejetées en 421.
`MCP_ALLOWED_ORIGINS`	`http://localhost,http://127.0.0.1,https://claude.ai`	Origines acceptées sur `/mcp/`. Un `Origin` absent est accepté (appels serveur-à-serveur).

Connecter votre client MCP

Claude Desktop / Cursor / Windsurf (Legacy SSE)

json

{
  "mcpServers": {
    "memoraeu": {
      "url": "http://localhost:8000/mcp/sse",
      "headers": { "Authorization": "Bearer VOTRE_CLE_API" }
    }
  }
}

claude.ai (HTTP Streamable, nécessite une URL publique + OAuth)

Voir la documentation

Mistral AI (connecteurs beta — La Plateforme)

python

connector = client.beta.connectors.create(
    name="memoraeu",
    server="https://api.memoraeu.com/mcp/sse?token=meu-sk-••••",
)

⚠️ Beta — discovery et SSE testés, exécution des tools en cours de déploiement par Mistral.

⚠️ Depuis la 1.4.0, `POST /mcp/sse` n'accepte plus le token en query string. Si votre

connecteur utilise le transport HTTP Streamable, passez la clé via l'en-tête

`Authorization: Bearer`. Le `?token=` ci-dessus ne reste valable que pour le transport

SSE legacy (`GET /mcp/sse`).

Pourquoi MemoraEU ?

MemoraEU	Autres (ex: mem0)
Open source	✅ AGPL v3	✅ (core)
Hébergé en EU	✅ OVH France	❌ US
Zero-knowledge	✅ AES-256-GCM côté client	❌
Auto-hébergeable	✅ Docker Compose	✅
MCP natif	✅ stdio + SSE + HTTP Streamable	❌
Mistral connecteurs	✅ compatible (beta)
OAuth 2.0 PKCE	✅	❌
Graphe de connaissance temporel	✅	❌
Endpoints RGPD	✅ natifs	⚠️ partiel

Self-host vs Cloud

Auto-hébergé	MemoraEU Cloud
Installation	Docker Compose	Inscription, c'est tout
Localisation des données	Votre serveur	EU (OVH, France)
Embeddings	Ollama (local)
Mises à jour	Manuelles	Automatiques
Prix	Gratuit (AGPL)

Architecture

code

Claude Desktop / Claude Code                 claude.ai · Cursor · Windsurf · ChatGPT
         │                                              │
         │ stdio (MCP)  memoraeu-mcp (uvx)
         ▼                                              │ OAuth 2.0 PKCE
  memoraeu_mcp/main.py                                 │
         │                                              ▼
         ├── Mistral API  ←── embeddings locaux   api/main.py  (FastAPI)
         │                    (avant chiffrement)
         │ HTTP + Bearer token                          ├── POST /mcp/sse   ← HTTP Streamable
         │ [contenu chiffré AES-256-GCM + vecteur]     ├── GET  /mcp/sse   ← SSE legacy
         ▼                                              ├── /oauth/*        ← PKCE
   api/main.py  (FastAPI)
         ├── Qdrant          ← recherche vectorielle
         ├── SQLite (memories)
         └── SQLite (facts)

Stack :

FastAPI
Qdrant — base vectorielle (Docker)
Mistral AI
MCP
SQLite — persistance des métadonnées
AES-256-GCM + PBKDF2-SHA256 (210k itérations)

Flux zero-knowledge

Variable	Rôle
`MEMORAEU_API_KEY`	Authentification HTTP — Bearer token envoyé à chaque requête
`MEMORAEU_SECRET`	Mot de passe — entrée PBKDF2 pour dériver la clé AES localement
`MEMORAEU_SALT`	Salt KDF unique par compte, généré à l'inscription
`MISTRAL_API_KEY`	Clé Mistral côté client — embeddings calculés avant chiffrement

code

remember()
  texte clair
    → PBKDF2(SECRET, SALT, 210k)
    → Mistral embed(texte clair)
    → AES-256-GCM(texte, clé)
    → POST /memories { blob chiffré, vecteur }  ← le serveur ne voit que l'opaque

Installer en package Python

bash

pip install memoraeu

Avec les embeddings Mistral :

bash

pip install "memoraeu[mistral]"

Conformité RGPD

Endpoint	Méthode	Description
`/gdpr/status`	`GET`	Statistiques des données stockées
`/gdpr/export`	`GET`	Export JSON complet (Art. 20)
`/gdpr/delete-account`	`DELETE`	Purge irréversible Qdrant + SQLite (Art. 17)
`/me/gdpr-history`	`GET`	Historique des opérations RGPD

Journal admin filtrable par organisation et date :

code

GET /gdpr/admin/log?org_id=...&date_from=YYYY-MM-DD
X-Admin-Key:

Comment ça marche

Stocker une mémoire

code

Texte en clair
  → [LOCAL] Mistral compresse si > 300 caractères
  → [LOCAL] Mistral génère un vecteur d'embedding
  → [LOCAL] PBKDF2(SECRET, SALT, 210k itérations)
  → [LOCAL] AES-256-GCM(texte)
  → POST /memories { blob chiffré, vecteur }
  → [SERVEUR] similarité vectorielle → skip si > 94% doublon
  → [SERVEUR] SQLite ← métadonnées  |  Qdrant ← vecteur
  → Le serveur ne voit jamais le texte en clair.

Rappeler une mémoire

code

Requête texte (ex. "projet principal")
  → [LOCAL] Mistral génère le vecteur de la requête
  → POST /memories/search { vecteur, limit: 3 }
  → [SERVEUR] Qdrant cosine similarity → top-N blobs chiffrés
  → [LOCAL] AES-256-GCM déchiffre → texte en clair
  → Claude reçoit le contexte. Le serveur n'a vu qu'un vecteur.

Mémoire automatique (mode MCP stdio)

Le serveur MCP est conçu pour fonctionner sans intervention manuelle. Les descriptions des outils `recall` et `remember` instruisent Claude de les appeler automatiquement — `recall` au premier message de chaque session, `remember` dès qu'une information mérite d'être retenue. Au premier `recall`, le system prompt complet est injecté dans le contexte.

Contribuer

MemoraEU est open source (AGPL v3)

bash

git clone https://github.com/pquattro/memoraeu-server
cd memoraeu-server
python -m venv .venv && source .venv/bin/activate
pip install -e .
cp .env.example .env  # configurer votre .env local
uvicorn api.main:app --reload

Gardez les PRs ciblées — une fonctionnalité ou un correctif par PR.

Domaines où l'aide est la plus utile : SDK JavaScript/TypeScript, app mobile, intégrations MCP supplémentaires, traductions.

Licence

AGPL v3 — Copyright (c)

Si vous faites tourner une version modifiée en tant que service réseau, vous devez rendre le code source disponible à vos utilisateurs.

English

> MemoraEU gives your AI a persistent, encrypted memory —

> sovereign, zero-knowledge, hosted in Europe.

> Works with Claude, Cursor, Windsurf, ChatGPT, GitHub Copilot, n8n via MCP.

> Self-host for free (AGPL v3) or use the managed EU cloud

What it does

MemoraEU is a self-hostable memory server for AI assistants. It implements the Model Context Protocol (MCP) so any MCP-compatible client (Claude, Cursor, Windsurf, ChatGPT, GitHub Copilot, n8n…)

Semantic search powered by Qdrant + embeddings (Ollama or Mistral)
Multi-user / multi-org with JWT auth
MCP transports: Legacy SSE (Cursor, curl) + HTTP Streamable (claude.ai, Copilot, n8n)
Temporal facts with validity periods
Zero-knowledge encryption AES-256-GCM client-side (memoraeu-mcp)
Native GDPR: built-in export / deletion / history endpoints
Intelligent merge: similar memory detection and LLM-powered merge (Mistral/Ollama)

Quick start

☁️ Option A — Managed cloud (zero config)

bash

# Install the MCP client
uvx memoraeu-mcp

# Add to your Claude Desktop config:
# Server URL: https://api.memoraeu.com/mcp/sse
# Get your API key at: https://app.memoraeu.com

🏠 Option B — Self-host (free, AGPL v3)

bash

git clone https://github.com/pquattro/memoraeu-server
cd memoraeu-server
cp .env.example .env   # fill MEMORAEU_SECRET, MEMORAEU_SALT, MISTRAL_API_KEY
docker compose up -d
# API running at http://localhost:8000
# Docs: http://localhost:8000/docs
# MCP server: http://localhost:8000/mcp/sse

Configuration

All configuration is via environment variables (see `.env.example`)

Variable	Default	Description
`JWT_SECRET`	—	Required. Min 32 chars.
`REGISTRATION_OPEN`	`true`	Allow new user registration
`EMBED_PROVIDER`	`ollama`	`ollama` or `mistral`
`EMBED_MODEL`	`nomic-embed-text`	Embedding model name
`EMBED_URL`	`http://localhost:11434`	Ollama base URL
`MISTRAL_API_KEY`	—	Required if `EMBED_PROVIDER=mistral`
`QDRANT_URL`	`http://qdrant:6333`	Qdrant instance URL
`SQLITE_PATH`	`/data/memoraeu.db`	SQLite database path
`MCP_ALLOWED_HOSTS`	`localhost,127.0.0.1,localhost:8000,127.0.0.1:8000`	Accepted hosts on `/mcp/` (DNS rebinding protection). Add your own domain if you expose the server, otherwise requests are rejected with 421.
`MCP_ALLOWED_ORIGINS`	`http://localhost,http://127.0.0.1,https://claude.ai`	Accepted origins on `/mcp/`. A missing `Origin` is accepted (server-to-server calls).

Connect your MCP client

Claude Desktop / Cursor / Windsurf (Legacy SSE)

json

{
  "mcpServers": {
    "memoraeu": {
      "url": "http://localhost:8000/mcp/sse",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}

claude.ai (HTTP Streamable, requires public URL + OAuth)

See documentation

Mistral AI (beta connectors — La Plateforme)

python

connector = client.beta.connectors.create(
    name="memoraeu",
    server="https://api.memoraeu.com/mcp/sse?token=meu-sk-••••",
)

⚠️ Beta — discovery and SSE tested, tool execution being rolled out by Mistral.

⚠️ Since 1.4.0, `POST /mcp/sse` no longer accepts the token as a query parameter. If your

connector uses the HTTP Streamable transport, pass the key via the `Authorization: Bearer`

header. The `?token=` above remains valid only for the legacy SSE transport

(`GET /mcp/sse`).

Why MemoraEU?

MemoraEU	Others (e.g. mem0)
Open source	✅ AGPL v3	✅ (core)
Hosted in EU	✅ OVH France	❌ US
Zero-knowledge	✅ AES-256-GCM client-side	❌
Self-hostable	✅ Docker Compose	✅
MCP native	✅ stdio + SSE + HTTP Streamable	❌
Mistral connectors	✅ compatible (beta)
OAuth 2.0 PKCE	✅	❌
Temporal knowledge graph	✅	❌
GDPR endpoints	✅ native	⚠️ partial

Self-host vs Cloud

Self-hosted	MemoraEU Cloud
Setup	Docker Compose	Sign up, done
Data location	Your server	EU (OVH, France)
Embeddings	Ollama (local)
Updates	Manual	Automatic
Price	Free (AGPL)

Architecture

code

Claude Desktop / Claude Code                 claude.ai · Cursor · Windsurf · ChatGPT
         │                                              │
         │ stdio (MCP)  memoraeu-mcp (uvx)
         ▼                                              │ OAuth 2.0 PKCE
  memoraeu_mcp/main.py                                 │
         │                                              ▼
         ├── Mistral API  ←── local embeddings    api/main.py  (FastAPI)
         │                    (before encryption)
         │ HTTP + Bearer token                          ├── POST /mcp/sse   ← HTTP Streamable
         │ [AES-256-GCM ciphertext + vector]           ├── GET  /mcp/sse   ← SSE legacy
         ▼                                              ├── /oauth/*        ← PKCE
   api/main.py  (FastAPI)
         ├── Qdrant          ← vector search
         ├── SQLite (memories)
         └── SQLite (facts)

Stack:

FastAPI
Qdrant — vector database (Docker)
Mistral AI
MCP
SQLite — metadata persistence
AES-256-GCM + PBKDF2-SHA256 (210k iterations)

Zero-knowledge flow

Variable	Role
`MEMORAEU_API_KEY`	HTTP authentication — Bearer token sent with every request
`MEMORAEU_SECRET`	Password — PBKDF2 input to derive AES key locally
`MEMORAEU_SALT`	Per-account KDF salt, generated at registration
`MISTRAL_API_KEY`	Client-side Mistral key — embeddings computed before encryption

code

remember()
  plaintext
    → PBKDF2(SECRET, SALT, 210k)
    → Mistral embed(plaintext)
    → AES-256-GCM(plaintext, key)
    → POST /memories { ciphertext, vector }  ← server only sees opaque blobs

Install as Python package

bash

pip install memoraeu

With Mistral embeddings:

bash

pip install "memoraeu[mistral]"

Endpoint	Method	Description
`/gdpr/status`	`GET`	Stored data statistics
`/gdpr/export`	`GET`	Full JSON export (Art. 20)
`/gdpr/delete-account`	`DELETE`	Irreversible purge Qdrant + SQLite (Art. 17)
`/me/gdpr-history`	`GET`	GDPR operation history

Filterable admin log by organization and date:

code

GET /gdpr/admin/log?org_id=...&date_from=YYYY-MM-DD
X-Admin-Key:

How it works

Storing a memory

code

Plaintext
  → [LOCAL] Mistral compresses if > 300 chars
  → [LOCAL] Mistral generates an embedding vector
  → [LOCAL] PBKDF2(SECRET, SALT, 210k iterations)
  → [LOCAL] AES-256-GCM(plaintext)
  → POST /memories { encrypted blob, vector }
  → [SERVER] vector similarity check → skip if > 94% duplicate
  → [SERVER] SQLite ← metadata  |  Qdrant ← vector
  → Server never sees plaintext. Ever.

Recalling a memory

code

Text query (e.g. "main project")
  → [LOCAL] Mistral generates query embedding
  → POST /memories/search { vector, limit: 3 }
  → [SERVER] Qdrant cosine similarity → top-N encrypted blobs
  → [LOCAL] AES-256-GCM decrypt → plaintext
  → Claude receives context. Server only ever saw a vector.

Auto-memory (MCP stdio mode)

The MCP server is designed to work without manual intervention. The `recall` and `remember` tool descriptions instruct Claude to call them automatically — `recall` on the first message of each session, `remember` whenever information is worth retaining. On the first `recall` call, the full behavior system prompt is injected into Claude's context.

Contributing

MemoraEU is open source (AGPL v3)

bash

git clone https://github.com/pquattro/memoraeu-server
cd memoraeu-server
python -m venv .venv && source .venv/bin/activate
pip install -e .
cp .env.example .env  # configure your local .env
uvicorn api.main:app --reload

Please keep PRs focused — one feature or fix per PR.

Areas where help is most welcome: JavaScript/TypeScript SDK, mobile app, additional MCP client integrations, translations.

License

AGPL-3.0 — Copyright (C)

If you run a modified version as a network service, you must make the source available to your users.

Frequently asked questions

What is memoraeu-server?

memoraeu-server is Zero-knowledge persistent memory layer for LLMs — AES-256-GCM encrypted, semantic search via Qdrant, MCP server for Claude Desktop / Sovereign European MCP memory layer — self-hostable, AGPL v3

How do I install memoraeu-server?

Open the GitHub repository and follow its README. Most MCP servers are added to your client's MCP config, then called by your agent.

Is memoraeu-server open source?

Yes — it is hosted on GitHub at https://github.com/pquattro/memoraeu-server and has 1 stars.

Related MCP tools

projectmem

Open-source coding agent memory. Records issues, attempts, fixes and decisions, then warns your agent before it repeats an approach that already failed. Native MCP server for Claude Code, Cursor, Antigravity and Codex. 100% local, no cloud, no telemetry. MIT.

796 Python

ai-agentsai-memoryai-tools+17

google_workspace_mcp

Control Gmail, Google Calendar, Docs, Sheets, Slides, Chat, Forms, Tasks, Search & Drive with AI - Comprehensive Google Workspace MCP Server & CLI Tool

3,117 Python

aigmailgoogle-calendar+17

memora

Give your AI agents persistent, collective memory — with deduplicating absorb, supersession lineage, semantic search, and a graph UI. Speaks MCP.

715 Python

ai-agentclaudeknowledge-graph+13

fastapi_mcp

Expose your FastAPI endpoints as Model Context Protocol (MCP) tools, with Auth! Python-based implementation. Trusted by 11000+ developers.

11,002 Python

aiauthenticationauthorization+10

jcodemunch-mcp

Cut AI token costs 95%+ on code exploration. The leading MCP server for precise, symbol-level GitHub code retrieval via tree-sitter AST. Works with Claude Code, Cursor & any MCP client. 313B+ tokens saved.

2,651 Python

claudeclaude-codeai-coding+17

OpenOSINT

AI-powered OSINT agent with interactive REPL, MCP server, and CLI. 19 tools. Works with Claude, GPT-4, or local models. For authorized security research only.

1,523 Python

ai-agentanthropicclaude+16

Run your own MCP server? See who uses it and what to fix.

Measure it with TrackMCP

Documentation

MemoraEU Server

Français

Ce que ça fait

Démarrage rapide

☁️ Option A — Cloud géré (zéro config)

🏠 Option B — Auto-hébergement (gratuit, AGPL v3)

Configuration

Connecter votre client MCP

Pourquoi MemoraEU ?

Self-host vs Cloud

Architecture

Flux zero-knowledge

Installer en package Python

Conformité RGPD

Comment ça marche

Stocker une mémoire

Rappeler une mémoire

Mémoire automatique (mode MCP stdio)

Contribuer

Licence

English

What it does

Quick start

☁️ Option A — Managed cloud (zero config)

🏠 Option B — Self-host (free, AGPL v3)

Configuration

Connect your MCP client

Why MemoraEU?

Self-host vs Cloud

Architecture

Zero-knowledge flow

Install as Python package

GDPR compliance

How it works

Storing a memory

Recalling a memory

Auto-memory (MCP stdio mode)

Contributing

License

Frequently asked questions

What is memoraeu-server?

How do I install memoraeu-server?

Is memoraeu-server open source?

Related MCP tools