🧠 RMS Memory MCP

Latest release: see GitHub Releases · rms-memory update installs it · the optional companion GUI is released separately

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

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

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

🔒 Privacy promise

RMS does not collect your data or usage statistics. RMS Memory MCP has no accounts, license checks or analytics, and your notes, code, queries and settings stay on your machine (local-first). The only requests that reach RMS carry no content and no personal identifier:

• Update check: rms-memory doctor (and the rms_doctor tool) asks update.rms-ds.com for the newest version, at most once a day: your OS, CPU architecture and the version, no ID. If that server is unreachable it falls back to GitHub*. Turn it off with RMS_MEMORY_NO_UPDATE_CHECK=1.

• Downloads you ask for: rms-memory update, rms-memory gui and the install scripts fetch signed files from update.rms-ds.com, which counts downloads per release and source; its analytics store no IP addresses or user agents.

• Embedding model: on first use it is downloaded once from Hugging Face*.

Embeddings are computed on your machine (the bundled model, or a local Ollama), so your notes never leave your computer for any AI service.

If an online service is ever introduced, we will tell you clearly beforehand.

The Problem

You're developing a single project but switching between different agents — Cursor, Zed, Claude Code, OpenCode, etc. 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.

🖥️ Prefer a GUI over raw Markdown?

RMS Memory GUI turns your vault into a visual workspace — full graph editor, per-project Git & GitHub sync, one-click Doctor repair, and an AI-assisted Wiki generator (bring your own key). One-time desktop app, works on top of everything below. The MCP server stays 100% free and standalone either way.

Related MCP server: io.github.oleksiijko/pmb-ai

✨ Key Features

📥 Download

RMS Memory MCP (command-line server, free)

Also as: macOS .tar.gz · Windows .zip · Linux x64 .tar.gz / .rpm · Linux ARM64 .tar.gz / .rpm

The installers put rms-memory on your PATH (/usr/local/bin on macOS, Program Files\RMS Memory MCP on Windows). Always the newest stable release. The macOS installer and binary are signed with an Apple Developer ID and notarized, so macOS opens them without a warning. The Windows installer is not code-signed yet, so SmartScreen may warn before the .msi runs.

Prefer a one-line installer? It picks the right build, verifies the signature and puts the binary on your PATH:

curl -fsSL https://raw.githubusercontent.com/max-ramas/rms-memory-mcp/master/scripts/install.sh | bash

irm https://raw.githubusercontent.com/max-ramas/rms-memory-mcp/master/scripts/install.ps1 | iex

With an archive: unpack, put rms-memory (rms-memory.exe on Windows) on your PATH and run rms-memory install to register it in your IDEs. Already installed? rms-memory update fetches the release from the same server, verifies its signature and checksum, and keeps the previous binary for rms-memory update --rollback. The signed manifest of the latest release is at /v1/rms-memory-mcp/latest. Downloads through this server are counted per release; no IP addresses or user agents are stored.

RMS Memory GUI (optional desktop app, trial included)

The MCP server never needs the GUI. From a terminal, rms-memory gui installs it for your OS (signature and checksum verified) and opens it.

Homebrew, .deb/.rpm packages of the MCP and older versions: GitHub Releases.

📦 Installation

Option 1: Homebrew (macOS Apple Silicon & Linux)

brew tap max-ramas/tap
brew install rms-memory-mcp

Installs a prebuilt binary — no Rust toolchain required. The formula updates automatically with every release.

Not covered by Homebrew: macOS Intel (dropped as of v1.0.1) and Windows (Homebrew doesn't run there — use Option 2 or the .zip below).

Option 2: GitHub release binary

Prebuilt binaries for aarch64-apple-darwin (Apple Silicon), x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, and x86_64-pc-windows-msvc are published on every release, along with .deb/.rpm packages for Linux. One-line installers auto-detect your architecture:

curl -fsSL https://raw.githubusercontent.com/max-ramas/rms-memory-mcp/master/scripts/install.sh | bash

irm https://raw.githubusercontent.com/max-ramas/rms-memory-mcp/master/scripts/install.ps1 | iex

Option 3: 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 ~/.cargo/bin/

crates.io (cargo install)

As of 1.1.0+, tag push publishes only the umbrella crate rms-memory-mcp to crates.io. Internal workspace members (rms-memory-core / index / vault / cli) stay publish = false (path deps for local builds and the companion GUI). Release packaging flattens those crates into a staging tree via scripts/flatten-for-crates-io.py before cargo publish (as of 1.1.1 the staging tree also inlines rms-memory-cli) — see docs/crate-split.md.

cargo install rms-memory-mcp
# Prefer Homebrew or a GitHub release binary if you want a pinned installer.

Optional RMS Memory GUI installers

The companion RMS Memory GUI is a paid, optional Tauri desktop control plane: a visual Markdown/graph editor, per-project and Vault-wide Git/GitHub sync, a Doctor dashboard with one-click repair, an AI-assisted organizer and Wiki generator (bring your own key, proposal-only), and cross-tool spend tracking. The MCP server remains fully standalone: it does not require the GUI, an AI provider, or a GUI license to index, search, sync or serve MCP clients.

See GUI-README.md for the full feature breakdown, supported platforms, installer verification and release-distribution policy.

GUI source is private, but desktop installers are published as binary assets on this repository's GitHub Releases under the matching v<version> tag. macOS builds are signed with Developer ID and notarized; Windows builds are not signed yet — see GUI-README.md. The private GUI workflow transfers only the completed .dmg, .msi/.exe, .AppImage, .deb, and .rpm installer files (plus SHA256SUMS.txt when present). With updater signing enabled, the GUI pipeline mirrors signed latest.json, companion .sig files, and macOS *.app.tar.gz onto this public release (URLs rewritten to rms-memory-mcp; in-app Install reads …/releases/latest/download/latest.json). It never mirrors GUI source, build logs, credentials, or private GUI release archives. The same publication flow runs for a v* GUI tag and for a manually dispatched, version-validated GUI release.

🚀 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.

Generated Wiki namespace

The optional desktop GUI writes human-readable Wiki pages to <vault>/wiki/. RMS Memory MCP remains AI-free and treats this directory as generated output rather than canonical memory. A shared case-insensitive path policy (src/path_policy.rs, also reused by the GUI) excludes the entire namespace from Markdown/code indexing, vector and full-text retrieval, watchers, the durable graph and Wiki context packs. Write isolation matches that policy: rms_write requires .md and rejects wiki/**; canonical DocumentService list/read/write APIs exclude or reject wiki; Wiki page mutations use wiki-safe methods that skip memory audit-frontmatter injection. Linked-document link: resolution always re-checks that the canonical target stays inside the vault. Full or incremental sync removes legacy Wiki-derived records by path without deleting the files, and doctor reports the isolation state explicitly.

For virtual projects without a filesystem path (threads, leads, etc.), use --scope:

rms-memory --scope "thread:abc-123" serve

Use multiple isolated scopes

A scope is an isolation boundary for a vault and its index. Without --scope, RMS Memory uses the canonical current working directory; an explicit filesystem path addresses that same kind of project vault. Any other non-empty identifier creates an isolated virtual vault:

rms-memory serve                                      # current project scope
rms-memory --scope "/home/user/my-project" serve     # explicit project scope
rms-memory --scope "thread:abc-123" serve             # virtual thread scope
rms-memory --scope "product:acme" serve                # virtual product scope

For project knowledge plus per-thread history, query each scope explicitly and merge the results in the caller. RMS Memory intentionally does not mix scopes implicitly. Scope IDs may not be empty or exceed 512 characters; absolute and .//../ values are resolved as paths, while all other values are opaque identifiers.

When using min_confidence, start with an unfiltered search. Use 0.3–0.5 for broad refinement and reserve 0.7+ for verified canonical facts; records without a confidence value remain visible.

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, set the vault root directly with rms-memory config --vault-path ~/MyVaults/, then run rms-memory init in each repository you want to register.)

Register a repository explicitly from its root before connecting IDE agents:

cd /path/to/project
rms-memory init

This creates the project mapping in ~/.rms-memory/registry.toml and provisions its isolated, structured vault. Routine MCP discovery is read-only and fail-closed: it never creates a project from /, never falls back to a shared global vault, and never guesses between multiple registered projects.

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

Optional semantic code memory

Markdown memory remains the default corpus. Semantic source indexing is separate, supports all bundled language adapters, and never changes source files:

rms-memory reindex --code  # build/update only derived code memory
rms-memory reindex --all   # refresh Markdown vault + code memory

Registered projects support code_index_mode = "off" | "manual" | "watch"; the default is off. Set it from the project root with rms-memory config --code-index-mode watch (or add --scope <project-path>). watch is explicitly opt-in, coalesces supported source saves for three seconds, and reindexes only the dirty paths (try_index_code_paths) with a full-walk fallback when the index is cold, the dirty set is empty/oversized (>200), or the watcher channel overflows. Concurrent IDE processes share a completion marker so an unchanged workspace stays idle. Code search results include their source language.

Perf smoke for large fixtures: ./scripts/bench_large_vault.sh [notes] [code_files].

Language selection is project-scoped and defaults to every bundled adapter:

rms-memory config --code-languages auto
rms-memory config --code-languages go,typescript,tsx,vue

Supported names are rust, go, javascript, jsx, typescript, tsx, python, c, cpp, java, ruby, swift, vue, csharp, php, kotlin, sql, html, and css. Generated paths (node_modules, .next, .nuxt, target, vendor, and coverage) are always excluded. Ambiguous .h files are indexed as C exactly once; use .hpp, .hh, or .hxx for C++ headers. Vue indexes only inline JavaScript/TypeScript <script> contents and maps results back to the .vue host file; templates, styles, script setup macros, and external src scripts remain outside v1.0.5 semantic extraction. HTML files contribute inline JavaScript <script> blocks (mapped back to the .html file) and elements with an id; CSS files contribute rule sets by selector and @keyframes. SQL files contribute CREATE TABLE / VIEW / TYPE / FUNCTION / PROCEDURE / TRIGGER statements.

Use an existing Obsidian vault

rms-memory projects attach-obsidian ~/Obsidian/Notes --key notes   # in place, read-only
rms-memory import --obsidian ~/Obsidian/Notes --dry-run             # or copy into this project's vault

An attached vault is indexed and searchable (pass project: "notes"), but RMS Memory never creates, edits, moves or deletes files in it: rms_write, checkpoints, prune and hooks refuse, and projects remove only drops the registration. The index lives under ~/.rms-memory/dbs/ like any other. Obsidian links ([[Note]], [[Note|label]], [[Note#Heading]], ![[image.png]], frontmatter aliases) resolve in the graph, the index and doctor.

Embedding model and retrieval eval

The default model is multilingual-e5-small (384 dimensions, downloaded once). To compare it with others on your own notes and switch:

rms-memory embedding list
rms-memory embedding eval --models multilingual-e5-small,bge-m3 --show-misses
rms-memory embedding use bge-m3              # or: ollama:nomic-embed-text (local Ollama)

eval turns each note's first heading into a query (or reads --queries file.jsonl with {"query": "...", "expect": ["path.md"]} lines) and reports hit@1, hit@k and MRR for embeddings alone and for hybrid search. Each model keeps its own index under the project's dbs/ folder, so switching back reuses the old one. After use, restart running MCP servers (IDE, GUI); the next sync builds the new index. Ollama URLs must be loopback (http://127.0.0.1:11434 by default).

🛠 CLI Commands

🔌 MCP Tools Exposed

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

MCP resources (1.3.0): rms://<project>/overview, rms://<project>/instructions, rms://<project>/checkpoint/<name> and rms://<project>/note/<path> are read-only views for clients that attach context by URI. MCP prompts: session_start, save_progress (name) and record_decision (topic).

The server resolves an explicit scope or legacy rootUri, then negotiates MCP roots/list. If a client exposes neither (or opens several registered roots), pass the short registry key in project; injected agent rules contain the correct key for that repository. rms_projects lists valid keys without requiring a bound workspace. An explicit project on any tool call always wins and rebinds the active vault — one long-lived MCP process can serve every registered project. Without project, ambiguity stays fail-closed (no silent pick-first).

To remove an accidental registration without deleting its Markdown vault:

rms-memory projects remove <key>

If the repository folder was moved or renamed, do not recreate .git or re-run init from scratch. Plan and apply a migrate instead:

rms-memory projects migrate --project <key> --to /new/path/to/repo --dry-run
rms-memory projects migrate --project <key> --to /new/path/to/repo
rms-memory projects resolve-key --path /new/path/to/repo

The CLI command projects remove is intentionally non-destructive. The companion GUI exposes a separate Delete project and data action for permanent cleanup of the registration, Markdown vault, and derived index. It requires typing the exact project key and accepts only a dedicated child of the configured master vault; the repository source path is explicitly excluded from deletion.

🏗 Architecture Highlights

Implementation lives in path-only crates under crates/ (rms-memory-core, rms-memory-index, rms-memory-vault, rms-memory-cli for cycle-free gc/prune). The published product remains the root umbrella rms-memory-mcp (binary + MCP server + tools + rules injector + serve), which re-exports every former rms_memory_mcp::<module> path so the companion GUI keeps stable imports. Heavy deps (lancedb, ort, fastembed, tree-sitter) concentrate in rms-memory-index. Details: docs/crate-split.md.

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.

The transport-neutral ProjectService is the single implementation used by the CLI and companion GUI. Registry mutation remains revisioned through ConfigManager; deletion validates canonical paths before unregistering and returns structured warnings if filesystem cleanup cannot be completed.

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.

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.

Human-authored Markdown and derived Rust code live in separate tables. Code chunks carry stable symbol identities, line ranges, and preambles; unchanged chunks reuse their vectors. corpus=all fuses independently ranked result sets with Reciprocal Rank Fusion, avoiding any assumption that distances from the two corpora are comparable.

Graph nodes and edges are deliberately independent of retrieval chunk boundaries. Markdown links, Rust imports, trait implementations, and lexical call hints can be reconciled as derived relationships; user-created edges and suppress/restore overrides persist across reindexing. Current Rust call edges are syntax-level hints, not a compiler-accurate call graph.

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.

1. Path traversal + filter injection prevention

2. Zombie process prevention (watcher shutdown on EOF + std::process::exit(0))

3. Graceful shutdown (SIGINT/Ctrl+C handler)

4. macOS sandbox bypass for fastembed model downloads

5. rms-memory gc — orphaned vector store pruning

6. PID-aware per-project writer lock and read-only background synchronization across IDE processes

7. Markdown watcher plus an explicitly opt-in, 3s-debounced code watcher with path-scoped reindex and shared-generation suppression

8. Write-guard snapshotting with rolling .bak backups (default: 5)

9. Isolated telemetry logging (~/.rms-memory/rms.log)

10. llms.txt export for flat, decoupled LLM ingestion

Live MCP requests have been verified for rms_search(corpus=vault|code|all) and rms_code_search. On this repository, reindex --code indexed 43 Rust files into 298 semantic items and 438 segments with all vectors reused on an unchanged run. An isolated five-server watcher run coalesced rapid saves into one shared completion-marker update; a later real-project stress gate completed concurrent GeoMail, License Server, RMS Monitoring, and GeoTax Site indexing, then seven MCP servers (after four IDE restarts) stayed at 0.0% CPU with no background reindex.

🧩 Supported IDEs

📄 License

MIT License — see LICENSE for details.

* Contacted directly by the tool for your convenience (a fallback update lookup on GitHub, the one-time embedding model download from Hugging Face). RMS does not take part in that exchange.