sabmemory

Lightweight Rust MCP memory server. Near-zero RAM alternative to embedding-based memory systems.

~6 MB RAM in production. Single 4.1 MB static binary. No Python, no Node.js, no ML runtime, no external dependencies. Built-in web dashboard with knowledge graph visualization.

Why sabmemory?

Every other MCP memory server requires a heavy runtime (Python/Node.js), ML models for embeddings, or cloud API calls. sabmemory uses SQLite FTS5 full-text search instead of vector embeddings -- achieving fast, relevant search at a fraction of the resource cost.

Comparison with other MCP memory servers

Overview

*Stars shown for the modelcontextprotocol/servers monorepo, not the memory package specifically.

Features

Runtime and Dependencies

Search Quality Tradeoffs

sabmemory trades semantic similarity for resource efficiency. FTS5 + BM25 performs keyword-aware ranked search rather than meaning-aware vector search. In practice, this works well for the MCP memory use case because:

1. Memories are short, atomic notes with explicit keywords and tags
2. The agent writing the memory is the same agent searching for it -- it uses consistent terminology
3. Importance score boosting surfaces the most relevant results regardless of lexical match
4. Auto-linking via FTS5 similarity captures related concepts at write time

For use cases requiring true semantic search (finding "automobile" when searching "car"), an embedding-based server like mcp-memory-service or Forgetful is more appropriate.

Measured on a 2 GB VPS (Ubuntu 24.04). sabmemory RSS: 6.5 MB Pss under active use with 19 memories, 2 entities, 2 projects, and 1 document. Idle instances drop to ~2 MB.

Features

• 49 native MCP tools — memories, entities, projects, documents, code artifacts, relationships, profiles, versioning
• FTS5 full-text search with BM25 ranking + importance score boosting
• Memory versioning — version chains with relationship types (updates/extends/derives), inspired by supermemory
• Auto-forget — set forget_after date for automatic expiry; soft-forget vs obsolete distinction
• Container scoping — container_tag field for namespace isolation
• Auto-linking — new memories are automatically linked to similar existing memories via FTS5
• Token-budgeted search — results bounded by configurable token budget (default 8000)
• Knowledge graph — entities with typed relationships, bidirectional memory links
• Documents & code artifacts — store long-form content and reusable code snippets
• User profiles — auto-generated from high-importance memories (static + dynamic facts)
• Built-in migration — import data from forgetful-ai databases

Install

From source

git clone https://github.com/Sablinova/sabmemory.git
cd sabmemory
cargo build --release
cp target/release/sabmemory ~/.local/bin/

Requirements

• Rust 1.70+ (uses edition 2021)
• No other dependencies — SQLite is bundled via rusqlite

Usage

MCP Server (stdio)

sabmemory serve
# or just:
sabmemory

The server communicates over stdin/stdout using the MCP protocol. Configure it in your MCP client.

OpenCode configuration

{
  "mcp": {
    "sabmemory": {
      "type": "local",
      "command": ["/path/to/sabmemory", "serve"],
      "enabled": true
    }
  }
}

Migration from forgetful-ai

sabmemory migrate --from ~/.local/share/forgetful/forgetful.db

Migrates: projects, entities, memories, documents, code artifacts, relationships, and all associations. FTS indexes are rebuilt automatically after migration.

Data Storage

Database: ~/.local/share/sabmemory/sabmemory.db

The database is created automatically on first run. All data is stored in a single SQLite file with FTS5 virtual tables for full-text search.

Architecture

Search Strategy

1. Natural language query is tokenized into FTS5 search terms
2. FTS5 MATCH with BM25 ranking scores relevance
3. Post-filters: obsolete, forgotten, expired, project, tags, container, min_importance
4. Importance score boosting applied to final ranking
5. Token budget enforcement limits result size
6. Linked memory expansion adds connected knowledge

Memory Model

Memories follow Zettelkasten (atomic note) principles:

• Title: Short, searchable (max 200 chars)
• Content: Single concept (max 2000 chars)
• Context: Why this matters (max 500 chars)
• Keywords: For search clustering (max 10)
• Tags: For categorization (max 10)
• Importance: 1-10 score affecting search ranking and profile generation

Versioning (supermemory-inspired)

Memories can form version chains via parent_memory_id:

• updates: New version contradicts/replaces the parent
• extends: New version enriches the parent
• derives: System-inferred relationship

Only the latest version (is_latest=true) appears in search results.

Auto-Forget

Set forget_after (ISO 8601 date) on a memory. Expired memories are automatically marked as forgotten before each query. Forgotten memories are excluded from search but preserved for audit.

Tools Reference

Memory Tools (13)

Entity Tools (15)

Project Tools (5)

Document Tools (5)

Code Artifact Tools (5)

User & Profile Tools (4)

Meta Tools (2)

Web Dashboard

sabmemory includes a built-in web dashboard for visualizing your knowledge graph, browsing memories, and exploring entities/projects/documents.

Running the dashboard

sabmemory dashboard --port 3080

The dashboard is served at http://localhost:3080 and provides:

• Knowledge graph -- interactive Three.js WebGL 3D visualization of all memories, entities, and their connections
• Memory browser -- searchable list of all memories with importance, tags, and metadata
• Entity explorer -- view entities, their types, aliases, and relationships
• Project view -- projects with associated memory counts
• Document view -- stored long-form documents
• Search -- full-text search across all memories
• Detail modal -- click any memory to see full content, links, and associations

Dashboard API

The dashboard exposes a REST API at /api/:

Running as a systemd service

# Create user service
mkdir -p ~/.config/systemd/user
cat > ~/.config/systemd/user/sabmemory-dashboard.service << 'EOF'
[Unit]
Description=sabmemory web dashboard
After=network.target

[Service]
ExecStart=%h/.local/bin/sabmemory dashboard --port 3080
Restart=on-failure
RestartSec=5

[Install]
WantedBy=default.target
EOF

# Enable and start
systemctl --user daemon-reload
systemctl --user enable --now sabmemory-dashboard

Reverse proxy (nginx)

To serve the dashboard behind a reverse proxy with HTTPS:

server {
    listen 443 ssl;
    server_name memory.yourdomain.com;

    location / {
        proxy_pass http://127.0.0.1:3080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Credits

sabmemory is inspired by and builds upon ideas from:

• supermemory — Memory versioning chains, auto-forget with expiry, container-based scoping, auto-generated user profiles, memory type classification
• forgetful-ai — Knowledge graph architecture (entities, relationships, memory-entity associations), document and code artifact storage, project-based organization, atomic memory principles

License

MIT