Memory Engine

by SimoneB79

277 downloads

Not rated

GitHub

About

Atomic memory model — knowledge stored as atoms (facts, decisions, events, preferences, logs, procedures, notes, session messages)

Details

Author: SimoneB79
Downloads: 277
Categories: AI, Knowledge Base

- Atomic memory model with typed knowledge atoms
- Multi-factor ranking combining FTS relevance, confidence, recency, and weight
- Organic decay of unused atoms with review flags for critical ones
- Learning engine that detects contradictions, gaps, weak atoms, and merge candidates
- Session watcher that ingests OpenClaw session messages as atoms with TTL

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:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Memory Engine

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

From the repository

—

Claude Desktop / Cursor

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

{
    "mcpServers": {
        "memory engine": {
            "memory-engine": {
                "url": "http://localhost:8085/sse",
                "transport": "sse"
            }
        }
    }
}

McpServers

{
    "memory-engine": {
        "url": "http://localhost:8085/sse",
        "transport": "sse"
    }
}

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

Most MCP memory servers are either simple key-value stores or plain text search wrappers.

Memory Engine is different: it models memory astyped atomsconnected bytyped 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 canrecall, connect, decay, curate, and learnover time.

- 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 withnomic-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— optional OpenClaw JSONL ingestion with short-lived raw messages and permanent session digests.
- 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— 135 tests covering CRUD, ranking, migrations, auth, backup, concurrency.
- Benchmark— CLI recall quality suite with Precision@K, MRR, latency percentiles.

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 — optional OpenClaw session ingestion

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"

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

Web UI: interactive graph, atom details, contradiction browser, stats dashboard

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

# docker-compose.yml services: memory-engine: image: ghcr.io/simoneb79/memory-engine-mcp:1.7.0 ports: - "8085:8085" volumes: - memory-data:/data restart: unless-stopped volumes: memory-data:

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

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

{ "mcpServers": { "memory-engine": { "url": "http://localhost:8085/sse", "transport": "sse" } } }

Seedocs/INSTALL.mdfor Docker, local Python, Claude Desktop, Cursor, and OpenClaw examples.

python -m venv .venv source .venv/bin/activate pip install -r requirements.txt python server.py

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, setollama.enabledtofalse; FTS recall still works.

- 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:

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

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 )

By default, Memory Engine runs inopen mode(no auth) — safe for stdio or trusted local environments.

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

- MCP SSE requests must includeAuthorization: Bearer <token>
- Web UI API endpoints require?token=<token>or Bearer header
- Server binds to127.0.0.1unlessallow_remote: true
- Input validation (title/body size limits) and rate limiting are always active

SeeCHANGELOG.mdfor the full list of security features.

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.mdfor the publication checklist.

- Public GitHub repository:https://github.com/SimoneB79/memory-engine-mcp
- Existing listing:https://mcpmarket.com/server/memory-engine
- License: MIT

Local Work Model for AI agents that learns from real outcomes.

Auditable, self-improving knowledge & memory for AI agents over MCP — citation-enforced answers and a replayable why-trace, self-hosted on Postgres.

Self-hosted MCP server giving AI agents persistent memory — Markdown source of truth, hybrid BM25+embedding search, typed graph relations.

MCP (Model Context Protocol) server that exposes 70 tools spanning cognitive memory, working memory, sessions, agents, the L0–L3 knowledge hierarchy, orchestration tasks, and training pipelines. The server speaks stdio and is consumed by Claude Desktop, Claude Code, OpenCodex, and any MCP-aware client.

Set up a private AI memory vault in about a minute. No migration, no setup call, no card required.

mem0-mcp-server — exposes Mem0 persistent semantic memory as an MCP HTTP server; supports add/search/read/update/delete operations and semantic search for agent memory.

Personal memory layer for AI assistants. Store, search and recall preferences, decisions and facts — available from any MCP-compatible client.

Hosted MCP memory across Claude Code, Cursor, ChatGPT and any MCP client. Community-hosted instance of the MIT-licensed MemPalace engine. EU-hosted, GDPR-compliant. Free tier with 200 memories.

Long-term memory system for AI agents with semantic search, context management, and multi-format storage.

Persistent AI memory: store, search, and recall knowledge across sessions

No reviews yet — be the first

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

Email sign in

No reviews posted yet.

Memory Engine

About

Details

Jump to

Setting up with Highlight

Setting up with Cursor

JSON

JSON

JSON

Setting up with Claude Desktop

JSON

JSON

JSON

Setting up with Windsurf

JSON

JSON

JSON

Setting up with Cline

JSON

JSON

JSON

Setting up with Goose

JSON

JSON

JSON

From the repository

Claude Desktop / Cursor

McpServers

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

Install

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

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

Install

More like this

Aws Kb Retrieval Server

Memory

Context 7

1Panel

🔎 GPT Researcher

Serena