Bietet KI-Assistenten einen Local-First Graph-Speicher mittels SQLite und semantischer Suche, um sich an langfristigen Kontext zu erinnern, Verbindungen zu knüpfen und daraus zu lernen.
Auch bekannt als SimoneB79/memory-engine-mcp, memory-engine-mcp
- Stars
- 1
- Tools
- 36
- Downloads, 30 Tage
- —
- Neueste Version
- 1.5.3
- Letzter Commit
- 22. Okt. 2026
- Lizenz
- MIT
Was ist Memory Engine MCP?
Bietet KI-Assistenten einen Local-First Graph-Speicher mittels SQLite und semantischer Suche, um sich an langfristigen Kontext zu erinnern, Verbindungen zu knüpfen und daraus zu lernen. Er stellt 36 Tools bereit, etwa remember, recall, working_set.
Zusammenfassung generiert aus dem README des Projekts
Über Memory Engine MCP server
Memory Engine MCP ermöglicht KI-Assistenten langfristige Kontinuität durch ein Local-First Graph-Memory-System. Es erlaubt Entwicklern, Agenten wie Claude Desktop, Cursor oder Windsurf die Fähigkeit zu geben, sich mithilfe einer Kombination aus SQLite und semantischer Suche an vergangene Interaktionen zu erinnern, diese zu verknüpfen und daraus zu lernen. Indem Informationen als typisierte Atome modelliert werden, die durch typisierte Bonds verbunden sind, geht das System über einfache Key-Value-Speicherung hinaus und erstellt einen strukturierten Knowledge Graph.
Nutzer können diesen Server via Docker oder lokale Python-Umgebungen bereitstellen und über SSE oder stdio mit MCP-Clients verbinden. Das System nutzt SQLite FTS5 für die Volltextsuche und kann mit lokalen Ollama-Embeddings unter Verwendung des nomic-embed-text Modells für die bedeutungsorientierte Suche integriert werden. Es enthält spezialisierte Tools zur Verwaltung der Memory-Health, wie etwa curator_run für die Wartung und error_log zum Protokollieren von Fehlern. Dieses Setup stellt sicher, dass der Kontext durch Decay-Zyklen und automatisierte Dublettenerkennung relevant bleibt, ohne dass Cloud-basierte API-Keys benötigt werden.
Was du damit machen kannst
- 1Langfristigen Projektkontext beibehaltenBitte deinen KI-Assistenten, spezifische Architektur-Entscheidungen oder Projektfakten aus früheren Sessions abzurufen.
- 2Wissen in einem Graphen organisierenLass den Assistenten Beziehungen zwischen verschiedenen Informationen erstellen, um eine strukturierte Wissensbasis aufzubauen.
Geschrieben aus dem README des Projekts. Jeder Use Case wurde gegen ein Zitat daraus geprüft.
So installierst du Memory Engine MCP
Formate geprüft am 10. Nov. 2026Zu Cursor hinzufügenZu Goose hinzufügenMemory Engine MCP in Claude Code installieren
$ claude mcp add memory-engine-mcp -- docker run -i --rm ghcr.io/simoneb79/memory-engine-mcp:1.5.3Memory Engine MCP in Cursor installieren
~/.cursor/mcp.json
{
"mcpServers": {
"memory-engine-mcp": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/simoneb79/memory-engine-mcp:1.5.3"
]
}
}
}Memory Engine MCP in VS Code installieren
.vscode/mcp.json
{
"servers": {
"memory-engine-mcp": {
"type": "stdio",
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/simoneb79/memory-engine-mcp:1.5.3"
]
}
}
}Memory Engine MCP in VS Code CLI installieren
$ code --add-mcp '{"name":"memory-engine-mcp","type":"stdio","command":"docker","args":["run","-i","--rm","ghcr.io/simoneb79/memory-engine-mcp:1.5.3"]}'Memory Engine MCP in Claude Desktop installieren
claude_desktop_config.json
{
"mcpServers": {
"memory-engine-mcp": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/simoneb79/memory-engine-mcp:1.5.3"
]
}
}
}Memory Engine MCP in Codex installieren
$ codex mcp add memory-engine-mcp -- docker run -i --rm ghcr.io/simoneb79/memory-engine-mcp:1.5.3Memory Engine MCP in Codex config.toml installieren
~/.codex/config.toml
[mcp_servers.memory-engine-mcp] command = "docker" args = ["run", "-i", "--rm", "ghcr.io/simoneb79/memory-engine-mcp:1.5.3"]
Memory Engine MCP in Gemini CLI installieren
$ gemini mcp add -s user memory-engine-mcp docker -- run -i --rm ghcr.io/simoneb79/memory-engine-mcp:1.5.3Memory Engine MCP in Gemini settings.json installieren
~/.gemini/settings.json
{
"mcpServers": {
"memory-engine-mcp": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/simoneb79/memory-engine-mcp:1.5.3"
]
}
}
}Memory Engine MCP tools 36
Erkannt aus dem READMErememberrecallworking_setsemantic_searchget_atomlist_atomsmerge_atomsexport_atomsearch_graphsuggest_bondssuggest_bonds_allcurator_run
| remember | — | |
| recall | — | |
| working_set | — | |
| semantic_search | — | |
| get_atom | — | |
| list_atoms | — | |
| merge_atoms | — | |
| export_atom | — | |
| search_graph | — | |
| suggest_bonds | — | |
| suggest_bonds_all | — | |
| curator_run | — |
Alle 36 Tools anzeigenWeniger Tools anzeigen
cognitive_statuslearning_rundecay_runcleanup_sessionscleanup_duplicatesreindex_embeddingserror_checkerror_logerror_listpreference_searchimport_markdownmemory_summarystatsversionrecall_sessionsession_summarymemory_contradictlist_contradictionsclassify_memory_tiermemory_impactbackup_databaserestore_databaseexport_allimport_data
| cognitive_status | — | |
| learning_run | — | |
| decay_run | — | |
| cleanup_sessions | — | |
| cleanup_duplicates | — | |
| reindex_embeddings | — | |
| error_check | — | |
| error_log | — | |
| error_list | — | |
| preference_search | — | |
| import_markdown | — | |
| memory_summary | — | |
| stats | — | |
| version | — | |
| recall_session | — | |
| session_summary | — | |
| memory_contradict | — | |
| list_contradictions | — | |
| classify_memory_tier | — | |
| memory_impact | — | |
| backup_database | — | |
| restore_database | — | |
| export_all | — | |
| import_data | — |
Konfiguration
MARKDOWN_SOURCEOptional directory for one-way markdown import.
MEMORY_API_TOKENMEMORY_DB_PATHSQLite database path inside the container.
MEMORY_PORTSSE server port. Default: 8085.
| Name | Beschreibung | Typ |
|---|---|---|
| MARKDOWN_SOURCE | Optional directory for one-way markdown import. | |
| MEMORY_API_TOKEN | — | |
| MEMORY_DB_PATH | SQLite database path inside the container. | |
| MEMORY_PORT | SSE server port. Default: 8085. |
Automatisierte Checks
Geluften am 12. Nov. 2026Vollständiger Bericht →Unsere automatisierten Checks bestanden. Das ist kein Security-Audit: Lies den Code und gib dem Server nur den minimal notwendigen Zugriff. Wie die Checks funktionieren
- Source Repository verknüpft und erreichbarBestanden
- Open Source Lizenz (OSI)Bestanden
- Commit oder Release im letzten JahrBestanden
- Package-Name ähnelt keinem populären PackageNicht geprüft
- Remote Endpoint nutzt HTTPSNicht geprüft
- Destruktive Tools sind markiertBestanden
- Keine versteckten Anweisungen an das ModellBestanden
- Keine kritischen Advisories im Paket oder seinen AbhängigkeitenNicht geprüft
README
Auf GitHub ansehenWhy Memory Engine?
Most MCP memory servers are either simple key-value stores or plain text search wrappers.
Memory Engine is different: it models memory as typed atoms connected by typed bonds, then retrieves context with a hybrid ranking pipeline that combines:
- full-text search (SQLite FTS5)
- semantic similarity via local Ollama embeddings
- confidence, recency, and weight
- graph expansion from related memories
The goal is not just storage. The goal is a memory system that can recall, connect, decay, curate, and learn over time.
Highlights
- Local-first — SQLite database, optional local embeddings via Ollama, no required cloud API.
- MCP-native — exposes 35 tools through FastMCP.
- Graph-aware recall — expands top hits through bidirectional bonds for richer context.
- Semantic search — meaning-based retrieval with
nomic-embed-text. - Markdown coexistence — import existing notes one-way without replacing your human-readable memory.
- Error memory — remembers mistakes and corrections, with auto-promotion to preferences after repeated failures.
- Cognitive curator — non-destructive maintenance pass for compaction, bond suggestions, duplicate detection, and isolated atom classification.
- Session watcher — canonical OpenClaw SQLite ingestion (schema 17), reset-aware digests, and JSONL legacy fallback.
- Backup & restore — full SQLite snapshots, JSON export/import, verified restores with automatic safety backups.
- Auth & hardening — optional API token, secure bind, input validation, rate limiting.
- Test suite — 144 tests covering CRUD, ranking, migrations, auth, backup, concurrency, and transcript ingestion.
- Benchmark — CLI recall quality suite with Precision@K, MRR, latency percentiles.
Architecture
AI assistant / MCP client
│
▼
FastMCP server — 35 tools
│
▼
Memory engine — hybrid ranking, graph recall, decay, learning
│
├── SQLite — atoms, bonds, FTS5, JSON metadata, versions
├── Ollama — optional local embeddings
├── Curator — conservative maintenance
└── Session watcher — OpenClaw SQLite + JSONL fallback
MCP Tools
Memory
| Tool | Purpose |
|---|---|
remember |
Create or update an atom |
recall |
Smart hybrid recall with graph expansion |
working_set |
Build a task-oriented context pack |
semantic_search |
Pure semantic search |
get_atom |
Read one atom with bonds |
list_atoms |
Browse atoms by domain/type/status |
merge_atoms |
Merge duplicate atoms |
export_atom |
Export one atom as markdown |
Knowledge graph
| Tool | Purpose |
|---|---|
link / unlink |
Create or remove typed bonds |
search_graph |
Traverse the graph from one atom |
suggest_bonds |
Suggest bonds for one atom |
suggest_bonds_all |
Suggest or create bonds in bulk |
Learning and maintenance
| Tool | Purpose |
|---|---|
curator_run |
Conservative curation pass |
cognitive_status |
Graph and memory health metrics |
learning_run |
Detect contradictions, weak atoms, merge candidates, gaps |
ask_pending / answer_human |
Human-in-the-loop clarification |
decay_run |
Run decay cycle |
cleanup_sessions |
Remove expired session atoms |
cleanup_duplicates |
Remove duplicate session atoms |
reindex_embeddings |
Rebuild embeddings |
Error memory and preferences
| Tool | Purpose |
|---|---|
error_check |
Check past failures before doing a task |
error_log |
Record a mistake and the correction |
error_list |
Browse unresolved/resolved errors |
preference_search |
Search structured preferences |
Import and introspection
| Tool | Purpose |
|---|---|
import_markdown |
Import markdown notes into atoms |
memory_summary |
3-level summary: global → domain → detail |
stats |
Database statistics |
version |
Server version |
recall_session |
Search one OpenClaw session |
session_summary |
Summarize one OpenClaw session |
memory_contradict |
Supersede an old atom with a newer contradictory one |
list_contradictions |
List explicit contradiction/supersession records |
classify_memory_tier |
Infer the 3-tier class (episodic/semantic/procedural) |
memory_impact |
Impact analysis: what depends on this atom |
Backup, restore & export
| Tool | Purpose |
|---|---|
backup_database |
Create, list, verify, or clean up SQLite snapshots |
restore_database |
Restore from a backup (with automatic safety backup) |
export_all |
Export all memory data as portable JSON |
import_data |
Import from JSON (merge or replace mode) |
Web UI (optional)
Memory Engine includes an optional web UI for graph exploration, atom inspection, contradiction browsing, and impact analysis.
# In docker-compose.yml, add:
# environment:
# - MEM_UI_PORT=6000
# expose:
# - "6000"
Or run standalone:
python3 web_ui.py
# Open http://localhost:6000
Quick start with Docker
Option A — Use the pre-built image (recommended)
# docker-compose.yml
services:
memory-engine:
image: ghcr.io/simoneb79/memory-engine-mcp:2.1.0
ports:
- "8085:8085"
volumes:
- memory-data:/data
restart: unless-stopped
volumes:
memory-data:
docker compose up -d
Pin the version. Use an explicit tag like
:1.7.0in production. Avoid:latest— it can change without notice.
Option B — Build from source
git clone https://github.com/SimoneB79/memory-engine-mcp.git
cd memory-engine-mcp
cp docker-compose.yml docker-compose.local.yml
# Edit volume paths in docker-compose.local.yml if needed
docker compose -f docker-compose.local.yml up -d --build
Default endpoint:
http://localhost:8085/sse
Example MCP client config:
{
"mcpServers": {
"memory-engine": {
"url": "http://localhost:8085/sse",
"transport": "sse"
}
}
}
See docs/INSTALL.md for Docker, local Python, Claude Desktop, Cursor, and OpenClaw examples.
Local Python
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python server.py
Configuration
Main configuration file: config.json
Important environment variables:
| Variable | Default | Purpose |
|---|---|---|
MEMORY_DB_PATH |
/data/memory.db |
SQLite database path |
MARKDOWN_SOURCE |
/workspace/memory |
Markdown directory for import |
MEMORY_HOST |
127.0.0.1 |
Server bind address (secure default) |
MEMORY_PORT |
8085 |
SSE port |
MEMORY_API_TOKEN |
(none) | Optional API token for auth (see Security) |
OPENCLAW_AGENT_DB |
(none) | Preferred per-agent OpenClaw SQLite DB (schema 17) |
OPENCLAW_SESSIONS_DIR |
/sessions |
Legacy JSONL fallback when no agent DB is configured |
SESSION_DIGEST_DIR |
/data/session_digests |
Optional session digest output |
For the SQLite mount, WAL/SHM handling, filtering, and security boundary, see OpenClaw transcript ingestion.
Semantic search requires Ollama reachable from the container or host. Default:
{
"ollama": {
"enabled": true,
"host": "http://ollama:11434",
"model": "nomic-embed-text"
}
}
If you do not use Ollama, set ollama.enabled to false; FTS recall still works.
Memory model
Atoms have:
titlebodytype:fact,decision,event,preference,log,procedure,note, etc.domain: project or topic namespaceconfidenceweighttags- optional TTL
Bonds connect atoms with relation types:
is_a · part_of · depends_on · contradicts · refines · derived_from · detail_of · related_to
Example usage
remember(
title="Use PostgreSQL for analytics",
body="SQLite is kept for local memory, PostgreSQL is used for multi-user analytics.",
type="decision",
domain="project:analytics",
confidence=0.9,
tags=["database", "architecture"]
)
recall(query="what database did we choose for analytics?", limit=5)
working_set(
query="continue the analytics backend work",
domain="project:analytics",
limit=8,
graph_depth=1
)
Security
By default, Memory Engine runs in open mode (no auth) — safe for stdio or trusted local environments.
To enable API token auth:
// config.json
{
"security": {
"api_token": "your-secret-token",
"allow_remote": false
}
}
Or via environment variable:
MEMORY_API_TOKEN=your-secret-token
When auth is enabled:
- MCP SSE requests must include
Authorization: Bearer <token> - Web UI API endpoints require
?token=<token>or Bearer header - Server binds to
127.0.0.1unlessallow_remote: true - Input validation (title/body size limits) and rate limiting are always active
See CHANGELOG.md for the full list of security features.
Publishing and registries
This repository is prepared for MCP discovery:
- MCP Registry name:
io.github.simoneb79/memory-engine-mcp - Registry metadata:
server.json - Docker/OCI verification label: included in
Dockerfile - Client config example:
mcp.json
See docs/PUBLISHING.md for the publication checklist.
Repository status
- Public GitHub repository: https://github.com/SimoneB79/memory-engine-mcp
- Existing listing: https://mcpmarket.com/server/memory-engine
- License: MIT
License
MIT — see LICENSE.
Memory Engine MCP Fragen
Wie füge ich Memory Engine MCP zu Claude Code hinzu?
Führe claude mcp add memory-engine-mcp -- docker run -i --rm ghcr.io/simoneb79/memory-engine-mcp:1.5.3 in deinem Terminal aus. Füge --scope user hinzu, damit der Server in jedem Projekt verfügbar ist.
Wie füge ich Memory Engine MCP zu Cursor hinzu?
Öffne ~/.cursor/mcp.json und füge den Server unter mcpServers hinzu, mit der Cursor-Config aus dem Installationsabschnitt oben.
Welche Tools bietet Memory Engine MCP?
Er stellt 36 Tools bereit, darunter remember, recall, working_set, semantic_search, get_atom.
Benötigt Memory Engine eine Cloud-API?
Nein, es ist ein Local-First-System, das eine SQLite-Datenbank und optional lokale Embeddings via Ollama nutzt, ohne dass eine Cloud-API erforderlich ist.
Kann ich meine bestehenden Markdown-Notizen verwenden?
Ja, du kannst bestehende Notizen einmalig in das Memory-System importieren, ohne deine für Menschen lesbaren Dateien zu ersetzen.
Gibt es eine Möglichkeit, den Memory-Graphen zu visualisieren?
Ja, es steht ein optionales Web-UI zur Verfügung, um den Graphen zu explorieren, Atome zu inspizieren und Impact-Analysen durchzuführen.