Memory Engine MCP

io.github.SimoneB79Published by GitHub account SimoneB79v1.5.3Updated Oct 24, 2026

Local-first graph memory for AI assistants with SQLite, semantic search, and MCP tools.

The publisher's own server: Memory.fit

VerifiedSTDIODesktop onlyDatabasesKnowledge & Memory

Overview

AI-generated overview

Local-first long-term memory for AI assistants, storing typed atoms and bonds in SQLite with hybrid full-text and semantic recall.

What you can do
Exposes 35 MCP tools for creating and updating memory atoms, hybrid recall with graph expansion, semantic search, and task-oriented working sets. It also manages a typed knowledge graph with bonds, curation and decay passes, error memory with corrections, markdown import, session ingestion, and SQLite backup, restore, and JSON export. Retrieval combines SQLite FTS5, optional local Ollama embeddings, confidence, recency, weight, and graph expansion.
When to use it
Useful when an assistant needs persistent memory across sessions or projects, or when you want a local knowledge graph with semantic recall rather than a simple key-value store. It fits workflows that need continuity, contradiction tracking, and curated long-term context.
Requirements
Runs as a local process, typically via the Docker/OCI image ghcr.io/simoneb79/memory-engine-mcp, or from local Python. Needs a SQLite database path via MEMORY_DB_PATH and an SSE port via MEMORY_PORT. Semantic search needs a reachable Ollama instance with nomic-embed-text; without it, full-text recall still works. Optional MARKDOWN_SOURCE sets a markdown import directory.
Before you install
Runs in open mode with no authentication by default; enable MEMORY_API_TOKEN and keep the secure bind unless the environment is trusted. The server writes, merges, decays, and deletes memory data, and restore_database replaces the database, so back up first. Import and session ingestion read local markdown and OpenClaw session data. If Ollama is enabled, memory text is sent to that embedding endpoint.

Installation

In SourceWeft

  1. Open Memory Engine MCP in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

[Version] [License: MIT] [Python] [MCP Registry Ready] [Docker]

[Memory Engine Logo]

🧠 Memory Engine MCP

Local-first, graph-aware long-term memory for AI assistants.
SQLite + semantic search + knowledge graph + MCP tools for agents that need continuity.

Works with Claude Desktop · Claude Code · Cursor · Cline · Windsurf · OpenClaw · any MCP client

Why 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

text
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

ToolPurpose
rememberCreate or update an atom
recallSmart hybrid recall with graph expansion
working_setBuild a task-oriented context pack
semantic_searchPure semantic search
get_atomRead one atom with bonds
list_atomsBrowse atoms by domain/type/status
merge_atomsMerge duplicate atoms
export_atomExport one atom as markdown

Knowledge graph

ToolPurpose
link / unlinkCreate or remove typed bonds
search_graphTraverse the graph from one atom
suggest_bondsSuggest bonds for one atom
suggest_bonds_allSuggest or create bonds in bulk

Learning and maintenance

ToolPurpose
curator_runConservative curation pass
cognitive_statusGraph and memory health metrics
learning_runDetect contradictions, weak atoms, merge candidates, gaps
ask_pending / answer_humanHuman-in-the-loop clarification
decay_runRun decay cycle
cleanup_sessionsRemove expired session atoms
cleanup_duplicatesRemove duplicate session atoms
reindex_embeddingsRebuild embeddings

Error memory and preferences

ToolPurpose
error_checkCheck past failures before doing a task
error_logRecord a mistake and the correction
error_listBrowse unresolved/resolved errors
preference_searchSearch structured preferences

Import and introspection

ToolPurpose
import_markdownImport markdown notes into atoms
memory_summary3-level summary: global → domain → detail
statsDatabase statistics
versionServer version
recall_sessionSearch one OpenClaw session
session_summarySummarize one OpenClaw session
memory_contradictSupersede an old atom with a newer contradictory one
list_contradictionsList explicit contradiction/supersession records
classify_memory_tierInfer the 3-tier class (episodic/semantic/procedural)
memory_impactImpact analysis: what depends on this atom

Backup, restore & export

ToolPurpose
backup_databaseCreate, list, verify, or clean up SQLite snapshots
restore_databaseRestore from a backup (with automatic safety backup)
export_allExport all memory data as portable JSON
import_dataImport 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.

bash
# In docker-compose.yml, add:#   environment:#     - MEM_UI_PORT=6000#   expose:#     - "6000"

Or run standalone:

bash
python3 web_ui.py# Open http://localhost:6000

[Memory Engine Web UI — graph explorer]
Web UI: interactive graph, atom details, contradiction browser, stats dashboard

Quick start with Docker

Option A — Use the pre-built image (recommended)

yaml
# docker-compose.ymlservices:  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:
bash
docker compose up -d

Pin the version. Use an explicit tag like :1.7.0 in production. Avoid :latest — it can change without notice.

Option B — Build from source

bash
git clone https://github.com/SimoneB79/memory-engine-mcp.gitcd memory-engine-mcpcp docker-compose.yml docker-compose.local.yml# Edit volume paths in docker-compose.local.yml if neededdocker compose -f docker-compose.local.yml up -d --build

Default endpoint:

text
http://localhost:8085/sse

Example MCP client config:

json
{  "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

bash
python -m venv .venvsource .venv/bin/activatepip install -r requirements.txtpython server.py

Configuration

Main configuration file: config.json

Important environment variables:

VariableDefaultPurpose
MEMORY_DB_PATH/data/memory.dbSQLite database path
MARKDOWN_SOURCE/workspace/memoryMarkdown directory for import
MEMORY_HOST127.0.0.1Server bind address (secure default)
MEMORY_PORT8085SSE 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/sessionsLegacy JSONL fallback when no agent DB is configured
SESSION_DIGEST_DIR/data/session_digestsOptional 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:

json
{  "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:

  • title
  • body
  • type: fact, decision, event, preference, log, procedure, note, etc.
  • domain: project or topic namespace
  • confidence
  • weight
  • tags
  • optional TTL

Bonds connect atoms with relation types:

text
is_a · part_of · depends_on · contradicts · refines · derived_from · detail_of · related_to

Example usage

python
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"])
python
recall(query="what database did we choose for analytics?", limit=5)
python
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:

json
// config.json{  "security": {    "api_token": "your-secret-token",    "allow_remote": false  }}

Or via environment variable:

bash
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.1 unless allow_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

License

MIT — see LICENSE.

Made with 🧠 by SimoneB79

Source: README.md at commit b48c69e

Tools

0
SourceWeft has not started this package in its sandbox yet, so its tools are not known.

Version history

1
  1. v1.5.3LatestSep 16, 2026

Score

50% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 days25 pts

    Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.

  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

Other Memory integrations

Memory.fit

fit.memoryOfficial publisher

Hosted Memory.fit server that lets an AI read your training, sleep, recovery and nutrition data and write back weekly plans, targets and meal plans.

Streamable HTTPWeb executableAuth
Location & LifestyleCredential requiredOct 29, 2026

pg.ddx.io: the PostgreSQL community's memory

io.ddx.pgOfficial publisher

pg.ddx.io: the PostgreSQL community's memory's hosted MCP server, published by pg.ddx.io; no sign-in required; Streamable HTTP; 29 tools.

Streamable HTTPWeb executable
Databases29 toolsOct 24, 2026

var.gg Naming Memory

gg.varOfficial publisher

Remote MCP server that suggests and searches code identifier names from domain concepts in Korean, Japanese, Chinese, Vietnamese and English, and exposes ERD…

Streamable HTTPWeb executable
Databases7 toolsOct 27, 2026

Counterparts

ai.counterparts

Local-first long-term memory for Claude Code and Claude Desktop: the assistant writes notes about you and your projects and recalls them in later sessions.

STDIODesktop only
AI & MLNot validated yetNov 7, 2026

LAHZE - Persian AI Memory Platform

Published by GitHub account pedramgholizadeh

LAHZE - Persian AI Memory Platform's hosted MCP server; no sign-in required; Streamable HTTP; 13 tools.

Streamable HTTPWeb executable
Location & Lifestyle13 toolsNov 3, 2026