RTFM

RTFM

*Retrieve The Forgotten Memory*

The open retrieval layer your AI agent was missing

Index everything in your project — code, docs, PDFs, legal texts, research, data — and your agent finds the right context instantly. No hallucinations. No cloud. No API costs.

Fewer calls per search: one query returns ranked hits across code, docs and PDFs — a few hundred tokens of pointers — instead of a chain of grep, glob and whole-file reads.

`Free · Local · Open Source · MIT`

---

The problem

Your AI agent is flying blind.

It greps through thousands of files, misses the doc that answers the question, invents modules that don't exist, forgets what you decided last session. The bigger the project, the worse it gets. You've added a smarter model. It didn't help. Because the bottleneck isn't intelligence — it's retrieval.

Code indexers (Augment, Sourcegraph, Cursor) only see code. But your project isn't just code. It's specs, PRs, architecture decisions, research papers, PDFs, regulations, vault notes — the context your agent needs to stop guessing.

Why I built this

I was writing a French tax article (~50 pages of regulatory text, cross-references between code articles, case law, administrative doctrine). Claude Code kept grep-ing the same directories in loops, running out of context, and producing confidently wrong citations. I'd added more memory, better prompts, a smarter model. None of it worked, because the agent wasn't reasoning badly — it just couldn't *find* the right paragraph in a 2,000-file legal corpus. So I stopped trying to make the model smarter and built the layer it was missing. That's RTFM.

The solution

RTFM indexes everything. One command, one SQLite file, one retrieval layer your agent queries before grepping.

pip install rtfm-ai && cd your-project && rtfm init

30 seconds. Claude Code now searches your indexed knowledge base — code *and* docs *and* PDFs *and* whatever else you drop in — with full-text, semantic, or hybrid search. The agent sees 300 tokens of metadata first, then expands only what's relevant. Progressive disclosure instead of context dumps.

Free. Runs locally. No API keys. No cloud. Your data stays yours.

What it looks like

$ rtfm search "authentication flow" --limit 3

[1] src/auth/handlers.py > authenticate_user (p.2) score 9.12 src/auth/handlers.py:147 42 lines [2] docs/architecture/auth.md > SSO flow (p.1) score 7.84 docs/architecture/auth.md:1 23 lines [3] docs/ADR/0007-oauth.md > Decision (p.1) score 6.90 docs/ADR/0007-oauth.md:12 18 lines

Three results, ~300 tokens. The agent decides what to read next with rtfm_expand(source, target_section) — not a context dump, a conversation.

---

Quick start

Recommended — Claude Code plugin

In Claude Code (CLI or Desktop Code tab) :

/plugin marketplace add roomi-fields/claude-plugins

/plugin install rtfm@roomi-fields

RTFM is distributed via the roomi-fields/claude-plugins marketplace, which also ships notebooklm-mcp for citation-backed Q&A. To grab both at once:

/plugin install notebooklm@roomi-fields

That's it. The plugin auto-initializes each project on first use:

• Creates .rtfm/library.db (one SQLite file)
• Injects search instructions into CLAUDE.md
• Pre-grants permission for the MCP tools (no prompt every search)
• Indexes the project on the first prompt, re-indexes incrementally on every prompt

No `pip install` required. Pure Python, runs on Linux / macOS / Windows / WSL with Python 3.10+ already on PATH. The plugin bundles its own MCP server (no mcp SDK dep) and resolves python3 / python / py automatically.

Then say to Claude: *"Find the authentication flow"* — it uses rtfm_search instead of grepping.

Optional extras (semantic search, PDF parsing)

The core plugin is dependency-free. Heavier optional extras (embedding model, PDF parsers) install on demand into an isolated venv inside the plugin's data directory — no pollution of your system Python, no PEP 668 conflicts:

/rtfm:install-embeddings    # FastEmbed ONNX (~85 MB), semantic + hybrid search

/rtfm:install-pdf # pdftext only (~50 MB), fast text extraction /rtfm:install-pdf-full # + marker-pdf + CPU-only torch (~1.5 GB), complex layouts

The pdf-full install uses PyTorch's CPU-only index (no CUDA, no GPU needed) to stay around 1.5 GB instead of 5 GB.

Restart Claude Code after install for the extras to be picked up.

Manual install (Cursor, Codex, Claude Desktop chat, other MCP clients)

For clients without Claude Code's plugin system :

pip install rtfm-ai

cd /path/to/your-project rtfm init

Then point your MCP client at rtfm-serve (the entry exposed by the pip package). Optional extras via pip install rtfm-ai[embeddings,pdf].

---

How it compares

RTFM is the only open-source option that indexes multi-domain content with structural parsing, a code-level knowledge graph, and unlimited per-file history. That's the niche.

Different from MemPalace specifically: MemPalace is an entity-level memory for conversations (who/project/decision triples in SQLite, plus verbatim chunks in ChromaDB). RTFM is a retrieval layer for *artefacts* — parsed by format, linked at the file level, versioned over time. The two are stackable, not competing.

For a deeper breakdown of the design choices behind any RAG (chunking, retrieval, augmentation, integration, freshness, storage), see [RAG Fundamentals — the 6 axes →](docs/rag-fundamentals.md)

---

Memory that survives sessions

Between sessions, most agents forget. RTFM indexes Claude Code's own memory files across every project on your machine, with full version history.

rtfm memory                    # Manual snapshot

rtfm memory --install-hook # Auto-snapshot on every SessionEnd

• Cross-project index — one DB at ~/.rtfm/memory.db sees every ~/.claude/projects/*/memory/ directory on your machine. Ask rtfm_search("OAuth auth decisions") and get hits from all 18 of your projects.
• Unlimited version history — every change to a memory file is snapshotted (no prune). rtfm_history returns the full evolution.
• Auto-snapshot on `SessionEnd` — one command installs a global Claude Code hook. Every session you close captures a new snapshot.
• Curated, not verbatim — RTFM indexes the notes the agent already curated itself during the session (small, structured, signal-dense). Different philosophy from MemPalace, which indexes the full conversation transcripts in ChromaDB (large, noisy, needs aggressive semantic filtering).

---

Obsidian vault mode

RTFM is the retrieval layer for the Karpathy LLM Wiki pattern. Karpathy himself wrote: *"at small scale the index file is enough, but as the wiki grows you want proper search."* This is proper search.

cd /path/to/your-obsidian-vault

rtfm vault

• Detects .obsidian/, proposes a folder → corpus mapping
• Resolves [[wikilinks]] following Obsidian rules → stored as graph edges
• Generates _rtfm/ with Obsidian-native navigation (index, graph with Mermaid, hubs, orphans, Dataview frontmatter)
• Tested on a 1,700-note research vault

_rtfm/

├── index.md # Hub: corpus list, top connected documents ├── graph.md # Hub documents, orphans, broken links, Mermaid ├── recent.md # Recently modified files └── corpus/ # Per-corpus indexes

The LLM still writes your wiki. RTFM handles the retrieval that index.md can't scale to.

[Full Obsidian guide →](docs/obsidian-vault-guide.md)

---

NotebookLM integration

RTFM pairs naturally with notebooklm-mcp. NotebookLM caps you at 50 queries/day per notebook; RTFM removes that ceiling by indexing answers locally — ask once, retrieve forever, offline, in milliseconds.

notebooklm-mcp's /batch-to-vault endpoint writes citation-backed Q&A as {slug}.md (markdown with frontmatter) plus {slug}.json (structured nblm-answer-v1 sidecar). Both are guaranteed to coexist. Two integration paths, both ship today:

• Path A — Markdown (zero config): drop the vault into RTFM and rtfm sync. The default markdown parser slices each answer into question / answer / per-citation chunks automatically. No mapping, no schema, no code.
• Path B — JSON sidecar (typed metadata): drop a nblm-answer.yaml mapping into .rtfm/mappings/. Each .json answer file produces typed chunks with notebook_id, source_name, citation_marker queryable via SQL, plus cites edge candidates between answers and sources.

Use Path A unless you specifically need to filter or graph by structured citation fields.

[Full NotebookLM recipe →](docs/notebooklm-integration.md)

---

What I measured

I ran two kinds of benchmarks. The honest picture is nuanced — retrieval helps most on tasks that are actually solvable and where the agent is spending time *looking for things*.

Document-heavy task: French tax article generation (B10)

Writing a ~50-page regulated article from a corpus of legal code, c