🧠 RMS Memory MCP

Persistent, local-first memory for your AI coding agents.

Stop re-explaining your architecture to Cursor, Zed, and Claude Code every single session.

Features • Install • Quick Start • CLI • MCP Tools • Architecture

The Problem

You're developing a single project but switching between different agents — Cursor, Zed, Claude Code, OpenCode. Every one of them loses context of architectural decisions, system requirements, and user preferences the moment you close the tab. You end up re-explaining the same things over and over, or copy-pasting a stale CLAUDE.md between tools.

RMS Memory MCP bridges this gap: a single, isolated, centralized Markdown vault — perfectly structured for LLM consumption — that any MCP-compatible IDE can read from and write to.

✨ Key Features


🗂️ Global Centralized Vaults	Project context lives outside your repo — zero `.mcp` file pollution.
🔍 Hybrid Retrieval (LanceDB)	Embedded Vector Search + Tantivy Full-Text Search for zero-fail context hits.
🌐 Multilingual Semantic Parsing	`fastembed-rs` + `multilingual-e5-small` — native Russian & English understanding.
🌳 AST Markdown Chunker	`pulldown-cmark`-based chunking keeps code blocks and lists bound to their parent heading.
⚙️ Dynamic Auto-Installer	`rms-memory install` scans your system and wires itself into every supported IDE.
📜 Rules-as-Code Patching	Non-destructive AST patching of `.cursorrules`, `.zed/assistant.md`, etc. Opt-in by default.
🧪 Dry-Run & Auditing	`--dry-run` everywhere. Every write gets a rolling `.bak` backup.
🛡️ Ten-Point Resiliency	GC, background sync, write-guard snapshots, macOS sandbox bypass, `llms.txt` export, path traversal + injection protection, zombie prevention, graceful shutdown.

📦 Installation

Option 1: Cargo (Recommended)

If you have Rust installed, simply install from crates.io:

cargo install rms-memory-mcp

Option 2: Build from Source

# 1. Clone the repository
git clone https://github.com/max-ramas/rms-memory-mcp.git
cd rms-memory-mcp

# 2. Build the optimized release binary
cargo build --release

# 3. Add the binary to your global PATH
cp target/release/rms-memory-mcp ~/.cargo/bin/

Prebuilt binaries for x86_64-unknown-linux-gnu, x86_64-pc-windows-msvc, and aarch64-apple-darwin (Apple Silicon) are published on every release. One-line installers (install.sh / install.ps1) auto-detect your architecture.

🚀 Quick Start

The fastest way to get every IDE on your machine connected:

rms-memory install

This scans ~/.config/ and ~/Library/Application Support/ and hooks rms-memory directly into Cursor, Zed, Claude Code, OpenCode, and others — no manual JSON editing.

Configure your vault

The simplest way to configure the server is to run the interactive setup wizard. You don't need to memorize any CLI flags — just run:

rms-memory config

(Alternatively, you can pass flags directly: rms-memory config --vault-path ~/MyVaults/ --auto-add true)

The next time you open a project in a connected IDE, the server reads the rootUri from the MCP initialize handshake and provisions a clean, structured vault:

~/MyVaults/
  └── <ProjectHash>/
      ├── rules/
      ├── decisions/
      ├── architecture/
      ├── artifacts/
      ├── docs/
      └── api/

🛠 CLI Commands

Command	Description
`rms-memory serve`	Starts the JSON-RPC stdio server (auto-triggered by your IDE).
`rms-memory init`	Registers a project into the global registry. `--dry-run` supported. `--full` forces creation of all IDE rule templates.
`rms-memory import`	Scans for existing docs (`README.md`, `docs/`, `ADR/`) and imports them — interactively or via `--auto-import`.
`rms-memory install`	Hooks the server into supported IDEs. `--dry-run` supported.
`rms-memory config`	Interactive setup wizard for global settings (`vault-path`, `auto-add`, `inject-rules`, etc).
`rms-memory reindex`	Forces a full re-index of the current project vault.
`rms-memory sync`	Incremental LanceDB delete-then-insert sync (also runs automatically during `serve`).
`rms-memory gc`	Prunes orphaned LanceDB indices belonging to deleted vaults.
`rms-memory log`	Tails the telemetry log (`~/.rms-memory/rms.log`).
`rms-memory export-llms`	Compiles the current vault into a single `llms.txt` payload.

🔌 MCP Tools Exposed

Tool descriptions are written to be action-oriented, so agents use the vault proactively without being asked.

Tool	Purpose	Input
`rms-memory_rms_search`	Semantic search across the vault. Agents are instructed to call this first, before making any changes.	`{ query, limit, include_content }`
`rms-memory_rms_read`	Reads the full contents of a document found via `rms_search`.	`{ path }`
`rms-memory_rms_write`	Persists new decisions, constraints, or rules. Agents are prompted to call this proactively after solving a tricky bug or learning a preference.	`{ path, content, mode: replace\|append\|create }`

🏗 Architecture Highlights

Unified Configuration & Knowledge Isolation

A central ~/.rms-memory/registry.toml routes every project to an isolated vault, computed from a hash of the project path. No .mcp files, no per-repo config — global MCP entries (e.g. Zed's settings.json) can target any workspace automatically.

Linked Documents (zero-copy import)

Instead of duplicating existing docs into the vault, rms-memory import can create lightweight Link Files — Markdown stubs with a link: <path> frontmatter property. Reads/writes are transparently redirected to the source file, while the vector index still respects the vault's directory structure.

Hybrid Search (LanceDB + Tantivy)

Embedded LanceDB (~/.rms-memory/dbs/) combines vector similarity with full-text search, so a query never comes back empty just because the exact keywords didn't match.

AST-Aware Chunking

pulldown-cmark parses the Markdown AST directly. Chunks are built by walking up to the parent heading, with a strict 1500-character boundary and ~200-character overlapping window for oversized code blocks — no mid-sentence truncation.

Ten-Point Production Resiliency

Path traversal + filter injection prevention
Zombie process prevention (watcher shutdown on EOF + std::process::exit(0))
Graceful shutdown (SIGINT/Ctrl+C handler)
macOS sandbox bypass for fastembed model downloads
rms-memory gc — orphaned vector store pruning
Background incremental sync (Delete-then-Insert on mtime)
Real-time file watcher with 3s debounced re-sync
Write-guard snapshotting with rolling .bak backups (default: 5)
Isolated telemetry logging (~/.rms-memory/rms.log)
llms.txt export for flat, decoupled LLM ingestion

🧩 Supported IDEs

IDE	Auto-Install	Rules Injection
Cursor	✅	`.cursorrules`
Zed	✅	`.zed/assistant.md`
Claude Code	✅	`.claude/CLAUDE.md`
OpenCode	✅	—
VS Code	✅	—
Antigravity	✅	—

📄 License

MIT License — see LICENSE for details.

_{Built by Maksim Ramzaev · RMS Digital Services}