RLM - Infinite Memory for Claude Code
Your Claude Code sessions forget everything after
/compact. RLM fixes that.
Potencia tu agente
Instalación del publicador. No es un endpoint de PlugMCP.
Host a copy with our keys and logs.
Aún no hay una versión empaquetada en el registro. Sigue el README del repositorio.
¿URL remota o un comando en tu máquina? En qué se diferencian las dos instalaciones
Ejecutar en PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirClaude Code has a context window limit. When it fills up:
/compact wipes your conversation historyRLM is an MCP server that gives Claude Code persistent memory across sessions:
You: "Remember that the client prefers 500ml bottles"
→ Saved. Forever. Across all sessions.
You: "What did we decide about the API architecture?"
→ Claude searches its memory and finds the answer.
3 lines to install. 14 tools. Zero configuration.
Requirements: Python 3.10+ (download), Claude Code CLI
pip install mcp-rlm-server[all]
The hooks and templates ship inside the package. Since a pip install gives you no repo checkout, ask the package where they landed:
python -m mcp_server --hooks-dir # e.g. .../site-packages/mcp_server/hooks
python -m mcp_server --templates-dir
Point your ~/.claude/settings.json hook commands at that path (see
Hook Configuration), or copy them to ~/.claude/rlm/hooks/.
uv tool install mcp-rlm-server[all] --python 3.12
git clone https://github.com/EncrEor/rlm-claude.git
cd rlm-claude
./install.sh
docker build -t rlm-server .
# Or pull from registry (when published):
# docker pull ghcr.io/encreor/rlm-claude
Then configure Claude Code to use the Docker container (see Docker setup below).
Restart Claude Code. Done.
v0.9.1 moved the source code from mcp_server/ to src/mcp_server/ (PyPA best practice). A compatibility symlink is included so existing installations keep working, but we recommend re-running the installer:
cd rlm-claude
git pull
./install.sh # reconfigures the MCP server path
Your data (~/.claude/rlm/) is untouched. Only the server path is updated.
┌─────────────────────────┐
│ Claude Code CLI │
└────────────┬────────────┘
│
┌────────────▼────────────┐
│ RLM MCP Server │
│ (14 tools) │
└────────────┬────────────┘
│
┌──────────────────┼──────────────────┐
│ │ │
┌─────────▼────────┐ ┌──────▼──────┐ ┌──────────▼─────────┐
│ Insights │ │ Chunks │ │ Retention │
│ (key decisions, │ │ (full conv │ │ (auto-archive, │
│ facts, prefs) │ │ history) │ │ restore, purge) │
└──────────────────┘ └─────────────┘ └────────────────────┘
Chunking is a deliberate act: RLM never writes a chunk on its own. What it does is make sure an unsaved session cannot go unnoticed:
/compact: a manual /compact is blocked when nothing was chunked in the last 15 minutes. Chunk, re-run it, it passes. Auto-compact is never blocked (that would strand a full session), only warned.rlm_remember - Save decisions, facts, preferences with categories and importance levelsrlm_recall - Search insights by keyword (multi-word tokenized), category, or importance
critical rule outranks today's medium noterlm_forget - Remove an insightrlm_status - System overview (insight count, chunk stats, access metrics)rlm_chunk - Save conversation segments with typed categorization (snapshot, session, debug; insight redirects to rlm_remember)rlm_peek - Read a chunk (full or partial by line range)rlm_grep - Regex search across all chunks (+ fuzzy matching for typo tolerance)rlm_search - Hybrid search: BM25 + semantic cosine similarity (FR/EN, accent-normalized, chunks + insights)rlm_list_chunks - List all chunks with metadatarlm_sessions - Browse sessions by project or domainrlm_domains - List available domains for categorizationrlm_retention_preview - Preview what would be archived (dry-run)rlm_retention_run - Archive old unused chunks, purge ancient onesrlm_restore - Bring back archived chunksrlm_search still matches them by summary and tags and returns them under archived_matches — rlm_peek(chunk_id) restores one in full/compact with no chunk in the last 15 minutes; warns (never blocks) on auto-compact. It never creates a chunk itselfsession_id and transcript_path in the index)~/.claude/rlm/sessions/<session_id>.jsonl the paths a session edits and the basenames of allow-listed programs it runs. Never a command line: it can carry passwordspython3 ~/.claude/rlm/hooks/session_orphans.py --ack <session_id> "reason"Top-5 result overlap between providers: ~1.6/5 (different results in 7/8 queries). FastEmbed captures more semantic meaning while Model2Vec leans toward keyword similarity. The hybrid BM25 + cosine fusion compensates for both weaknesses.
Recommendation: Start with Model2Vec (default). Switch to FastEmbed only if you need better semantic accuracy and can afford the slower startup.
# Model2Vec (default) — fast, ~35 MB
pip install mcp-rlm-server[semantic]
# FastEmbed — more accurate, ~230 MB, slower
pip install mcp-rlm-server[semantic-fastembed]
export RLM_EMBEDDING_PROVIDER=fastembed
# Compare both providers on your data
python3 scripts/benchmark_providers.py
# Backfill existing chunks (run once after install)
python3 scripts/backfill_embeddings.py
Embedding is best-effort: a chunk is always written, even when the provider is unavailable. That chunk is then invisible to semantic search until it gets a vector, so the gap is reported rather than left to be discovered later.
rlm_status warns whenever coverage is incomplete, names the reason when the
provider failed to load, and echoes the most recent entries of rlm.log (an
append-only log in your context directory). To heal a gap:
# Dry-run first: lists chunks that would be embedded
python3 scripts/reconcile_stores.py
# Re-embed everything missing, with timestamped backups
python3 scripts/reconcile_stores.py --apply
Both honour RLM_CONTEXT_DIR. Use the same RLM_EMBEDDING_PROVIDER as your
server — the script refuses to mix vector dimensions.
/rlm-analyze - Analyze a single chunk with an isolated sub-agent/rlm-parallel - Analyze multiple chunks in parallel (Map-Reduce pattern from MIT RLM paper)— = not assessed. The claude-mem column reflects its documentation as of October 2026.
claude-mem and RLM make opposite bets. claude-mem records everything automatically and spends model calls to compress it; RLM stores only what you decide to keep, at no model cost, and makes sure a session you forgot to save is pointed out to you instead of silently lost.
# Load universal rules (apply regardless of topic).
# Pass a limit above your critical count — the default is 10, and a recall
# that returns 10 of 34 rules looks exactly like a complete one.
rlm_recall(importance="critical", limit=50)
# Load context for current topic
rlm_recall(query="deployment")
# Check memory status
rlm_status()
# Save a universal rule (loaded every session)
rlm_remember("Always deploy LOCAL → VPS, never direct",
category="decision", importance="critical",
tags="deploy,workflow")
# Save a topic-specific insight
rlm_remember("WeasyPrint requires inline CSS for PDF rendering",
category="finding", importance="high",
tags="weasyprint,pdf")
# Find insights later
rlm_recall(query="source of truth")
rlm_recall(category="decision")
rlm_recall(importance="critical", limit=50) # all universal rules (mind the default limit of 10)
Test: "Does this rule apply even when working on a completely different topic?" If yes → critical.
# Save important discussion (typed)
rlm_chunk("Discussion about API redesign... [long content]",
summary="API v2 architecture decisions",
tags="api,architecture",
chunk_type="session") # or "snapshot", "debug"
# Search across all history
rlm_search("API architecture decisions") # BM25 ranked
rlm_grep("authentication", fuzzy=True) # Typo-tolerant
# Read a specific chunk
rlm_peek("2026-01-18_MyProject_001")
# Filter by project
rlm_search("deployment issues", project="MyApp")
rlm_grep("database", project="MyApp", domain="infra")
# Browse sessions
rlm_sessions(project="MyApp")
rlm-claude/
├── src/mcp_server/
│ ├── server.py # MCP server (14 tools)
│ └── tools/
│ ├── memory.py # Insights (remember/recall/forget)
│ ├── navigation.py # Chunks (chunk/peek/grep/list)
│ ├── search.py # BM25 search engine
│ ├── tokenizer_fr.py # FR/EN tokenization
│ ├── sessions.py # Multi-session management
│ ├── retention.py # Archive/restore/purge lifecycle
│ ├── embeddings.py # Embedding providers (Model2Vec, FastEmbed)
│ ├── vecstore.py # Vector store (.npz) for semantic search
│ ├── diagnostics.py # Warning log (rlm.log) — degraded ops stay visible
│ └── fileutil.py # Safe I/O (atomic writes, path validation, locking)
│
├── hooks/ # Claude Code hooks
│ ├── i18n.py # Translations (EN/FR/JA) for hook messages
│ ├── pre_compact_chunk.py # Guard before /compact (PreCompact hook)
│ ├── memory_write_redirect.py # Redirect auto-memory writes to RLM (PostToolUse hook)
│ ├── reset_chunk_counter.py # Last-chunk time + chunk ↔ session link (PostToolUse hook)
│ ├── session_trace.py # What a session touches, metadata only (PostToolUse hook)
│ ├── session_orphans.py # Unsaved past sessions at startup, --ack (SessionStart hook)
│ └── session_common.py # Shared paths, config and lock-safe index update
│
├── templates/
│ ├── hooks_settings.json # Hook config template
│ ├── CLAUDE_RLM_SNIPPET.md # CLAUDE.md instructions
│ └── skills/ # Sub-agent skills
│
├── context/ # Storage (created at install, git-ignored)
│ ├── session_memory.json # Insights
│ ├── index.json # Chunk index
│ ├── chunks/ # Conversation history
│ ├── archive/ # Compressed archives (.gz)
│ ├── embeddings.npz # Semantic vectors (Phase 8)
│ └── sessions.json # Session index
│
├── install.sh # One-command installer
└── README.md
The installer automatically configures hooks in ~/.claude/settings.json:
{
"hooks": {
"PreCompact": [
{
"matcher": "manual",
"hooks": [{ "type": "command", "command": "python3 ~/.claude/rlm/hooks/pre_compact_chunk.py" }]
},
{
"matcher": "auto",
"hooks": [{ "type": "command", "command": "python3 ~/.claude/rlm/hooks/pre_compact_chunk.py" }]
}
],
"PostToolUse": [
{
"matcher": "mcp__rlm-server__rlm_chunk",
"hooks": [{ "type": "command", "command": "python3 ~/.claude/rlm/hooks/reset_chunk_counter.py" }]
},
{
"matcher": "Write",
"hooks": [{ "type": "command", "command": "python3 ~/.claude/rlm/hooks/memory_write_redirect.py" }]
},
{
"matcher": "Edit",
"hooks": [{ "type": "command", "command": "python3 ~/.claude/rlm/hooks/memory_write_redirect.py" }]
},
{
"matcher": "Edit|Write|MultiEdit|NotebookEdit|Bash",
"hooks": [{ "type": "command", "command": "python3 ~/.claude/rlm/hooks/session_trace.py" }]
}
],
"SessionStart": [{
"matcher": "",
"hooks": [{ "type": "command", "command": "python3 ~/.claude/rlm/hooks/session_orphans.py" }]
}]
}
}
The same block lives in templates/hooks_settings.json, which the installer reads.
Optional ~/.claude/rlm/session_trace.json (every key optional):
{
"notable_commands": ["ssh", "scp", "rsync", "psql", "kubectl", "terraform", "ansible-playbook", "deploy.sh"],
"min_edits": 5,
"idle_hours": 2,
"retention_days": 30,
"max_listed": 5
}
notable_commands: programs whose basename is recorded when a session runs them (arguments never are). One notable run is enough for a session to count.min_edits: a session with more Edit/Write than this counts.idle_hours: a session idle for less than this is presumed still running (parallel sessions are left alone).retention_days: traces older than this are deleted. Keep it aligned with Claude Code's cleanupPeriodDays (30 by default): past it the transcript is gone and the session cannot be recovered anyway.Hook messages default to English. Set RLM_LANG=fr for French or RLM_LANG=ja for Japanese:
# Option 1: Set globally in your shell profile (~/.zshrc, ~/.bashrc)
export RLM_LANG=fr # or ja
# Option 2: Set per-hook in ~/.claude/settings.json
# Replace the command with:
"command": "RLM_LANG=fr python3 ~/.claude/rlm/hooks/pre_compact_chunk.py"
Supported languages: en (default), fr, ja.
RLM stores data in ~/.claude/rlm/context/ by default. Override with RLM_CONTEXT_DIR:
export RLM_CONTEXT_DIR=/path/to/custom/storage
This is particularly useful for Docker deployments (see below).
Organize chunks by topic with custom domains:
{
"domains": {
"my_project": {
"description": "Domains for my project",
"list": ["feature", "bugfix", "infra", "docs"]
}
}
}
Edit context/domains.json after installation.
pip install -e ".[all]"
claude mcp add rlm-server -- python3 -m mcp_server
uv tool install mcp-rlm-server[all] --python 3.12
claude mcp add rlm-server -- ~/.local/bin/mcp-rlm-server
The ./install.sh script handles this automatically. For manual installs:
# Get hook scripts from the repo
git clone https://github.com/EncrEor/rlm-claude.git /tmp/rlm-setup
# Install hooks and i18n
mkdir -p ~/.claude/rlm/hooks
cp /tmp/rlm-setup/hooks/*.py ~/.claude/rlm/hooks/
chmod +x ~/.claude/rlm/hooks/*.py
# Install skills (optional)
mkdir -p ~/.claude/skills/rlm-analyze ~/.claude/skills/rlm-parallel
cp /tmp/rlm-setup/templates/skills/rlm-analyze/skill.md ~/.claude/skills/rlm-analyze/
cp /tmp/rlm-setup/templates/skills/rlm-parallel/skill.md ~/.claude/skills/rlm-parallel/
# Cleanup
rm -rf /tmp/rlm-setup
Then configure hooks in ~/.claude/settings.json (see Hook Configuration above).
Build the image:
git clone https://github.com/EncrEor/rlm-claude.git
cd rlm-claude
docker build -t rlm-server .
Configure Claude Code MCP to use Docker:
claude mcp add rlm-server -- docker run -i --rm -v ~/.claude/rlm/context:/data rlm-server
Or manually in ~/.claude/settings.json:
{
"mcpServers": {
"rlm-server": {
"type": "stdio",
"command": "docker",
"args": ["run", "-i", "--rm", "-v", "~/.claude/rlm/context:/data", "rlm-server"]
}
}
}
The Docker image uses RLM_CONTEXT_DIR=/data internally, and the volume mount maps it to your local storage.
./uninstall.sh # Interactive (choose to keep or delete data)
./uninstall.sh --keep-data # Remove RLM config, keep your chunks/insights
./uninstall.sh --all # Remove everything
./uninstall.sh --dry-run # Preview what would be removed
RLM includes built-in protections for safe operation:
[a-zA-Z0-9_.-&]), and resolved paths are verified to stay within the storage directoryfcntl.flock exclusive locksAll I/O safety primitives are centralized in mcp_server/tools/fileutil.py.
claude mcp list # Check servers
claude mcp remove rlm-server # Remove if exists
claude mcp add rlm-server -- python3 -m mcp_server
cat ~/.claude/settings.json | grep -A 10 "PreCompact" # Verify hooks config
ls ~/.claude/rlm/hooks/ # Check installed hooks
chunk_type parameter (snapshot/session/debug/insight redirect)The repository is maintained in English. User-facing files can be translated to your language:
Code, comments, and commit messages stay in English.
MIT License - see LICENSE
Recursive Language Models for Claude Code - Infinite memory solution inspired by MIT CSAIL paper
Herramientas
Aún no hay lista de herramientas. Los servidores remotos la reciben tras la primera comprobación de estado.
Preguntas frecuentes
Copia en esta página la configuración stdio para Cursor, Claude Desktop, Claude Code o VS Code. Usa la instalación del publicador, no un proxy de PlugMCP.
Este registro no indica ninguna variable de entorno obligatoria.
Rlm Claude se ejecuta localmente por stdio.
Última comprobación: 2026-10-28. Recursive Language Models for Claude Code - Infinite memory solution inspired by MIT CSAIL paper