Power your agent
คำสั่งของผู้เผยแพร่เอง ไม่ใช่เอนด์พอยต์ของ PlugMCP
Host a copy with our keys and logs.
uvx rtfm-ai==1.0.0Claude Code ไม่มีลิงก์ติดตั้งสำหรับคำสั่งแบบโลคัล ให้คัดลอกคำสั่งด้านล่างแล้วรันในเทอร์มินัล
claude mcp add io.github.roomi-fields-rtfm -- uvx rtfm-ai==1.0.0รันในเทอร์มินัล
{ "mcpServers": { "io.github.roomi-fields-rtfm": { "command": "uvx", "args": [ "rtfm-ai==1.0.0" ] } }}claude_desktop_config.json
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน 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.
เปิดจากผู้เผยแพร่
Retrieve The Forgotten Memory
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.
Local retrieval for AI agents: index code, docs, PDFs, data in SQLite; 24 parsers, served via MCP.
Free · Local · Open Source · MIT
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.
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.
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.
$ 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.
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:
.rtfm/library.db (one SQLite file)CLAUDE.mdNo 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.
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.
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].
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 →
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
~/.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.rtfm_history <slug> returns the full evolution.SessionEnd — one command installs a global Claude Code hook. Every session you close captures a new snapshot.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
.obsidian/, proposes a folder → corpus mapping[[wikilinks]] following Obsidian rules → stored as graph edges_rtfm/ with Obsidian-native navigation (index, graph with Mermaid, hubs, orphans, Dataview frontmatter)_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.
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:
rtfm sync. The default markdown parser slices each answer into question / answer / per-citation chunks automatically. No mapping, no schema, no code.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.
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.
Writing a ~50-page regulated article from a corpus of legal code, case law, and administrative doctrine. Same agent (Claude Code + Sonnet 4), same prompt, eight configurations tested.
Δ : −51 % cost, −61 % tokens, −16 % duration — with better factual accuracy. This is the use case RTFM was built for: navigating a large multi-domain corpus where grep misses the right paragraph.
11 tasks, 3 repos of varying size, 4 conditions (A = standard prompt with file paths; B = discovery, no paths; C = RTFM FTS; D = RTFM hybrid), 3 runs each.
On a single smaller-scope run (test_stub_generator on metaflow), RTFM cut agent time by −37 % vs the no-paths baseline. On the larger repos, the tasks themselves were too hard for Sonnet 4 to resolve inside a 20-minute timeout regardless of retrieval.
grep is enough and RTFM adds overhead.RTFM measurably wins when the bottleneck is "find the right paragraph in a 2,000-file corpus". It doesn't magically make unsolvable tasks solvable. The model still has to do the work — RTFM just makes sure it has the right context to do it with.
RTFM works anywhere your project isn't just code:
/plugin install rtfm@roomi-fields/rtfm, auto-init per projectmcp SDK / pydantic / native binariespip install rtfm-ai for Cursor, Codex, Claude Desktop chat, any other MCP clientNeed to index a format nobody supports? Write a parser in ~50 lines.
from rtfm.parsers.base import BaseParser, ParserRegistry
from rtfm.core.models import Chunk
import json
from uuid import uuid4
@ParserRegistry.register
class FHIRParser(BaseParser):
"""Parse HL7 FHIR medical records."""
extensions = ['.fhir.json']
name = "fhir"
def parse(self, path, metadata=None):
data = json.loads(path.read_text())
for entry in data.get('entry', []):
resource = entry.get('resource', {})
yield Chunk(
id=resource.get('id', str(uuid4())),
content=json.dumps(resource, indent=2),
book_title=f"FHIR {resource.get('resourceType', 'Unknown')}",
book_slug=resource.get('id', 'unknown'),
page_start=1,
page_end=1,
)
Drop it in your project, restart Claude Code, your medical AI agent now understands FHIR records.
For JSON-based formats specifically, RTFM offers a second extensibility path that doesn't need any Python:
See JSON schema mappings for the full reference, and RTFM × NotebookLM for a concrete recipe.
# Search
rtfm search "authentication flow"
rtfm search "article 39" --corpus cgi --limit 5
# Sync
rtfm sync # All registered sources
rtfm sync /path/to/docs --corpus docs # Specific directory
rtfm sync . --force # Force re-index
# Source management
rtfm add /path/to/docs --corpus docs --extensions md,pdf
rtfm sources
# Obsidian vault
rtfm vault # Initialize for cwd vault
rtfm vault /path/to/vault # Specific vault
rtfm vault --regenerate # Regenerate _rtfm/ files
# Cross-project Claude memory
rtfm memory # Manual snapshot
rtfm memory --install-hook # Auto-snapshot on SessionEnd
# Status & info
rtfm status
rtfm books
rtfm tags
rtfm history path/to/file.md # Memory version history
# Semantic search
rtfm embed # Generate embeddings (one-time)
rtfm semantic-search "tax deductions" --hybrid
# MCP server
rtfm serve
from rtfm import Library
lib = Library("my_library.db")
# Index
stats = lib.ingest("documents/article.md", corpus="docs")
result = lib.sync(".", corpus="my-project") # SyncResult(+3 ~1 -0 =42)
# Search
results = lib.search("depreciation", limit=10, corpus="cgi")
results = lib.hybrid_search("amortissement fiscal", limit=10)
# Export for LLM
prompt_context = results.to_prompt(max_chars=8000)
lib.close()
RTFM isn't a task manager. It's not an agent framework. It's the knowledge layer your agent needs underneath whatever you're already using.
┌─────────────────────────────────┐
│ GSD / Taskmaster / Claude Flow │ ← Orchestration
├─────────────────────────────────┤
│ RTFM │ ← Knowledge (you are here)
├─────────────────────────────────┤
│ Claude Code │ ← Execution
└─────────────────────────────────┘
Without RTFM, your orchestrator drives an agent that hallucinates. With RTFM, the agent knows what it's building on.
Adding a parser is the easiest way to contribute — and the most impactful. See CONTRIBUTING.md.
Found a bug? Have an idea? Open an issue.
@AVeryTastyRaspberry made RTFM
run on native Windows. RTFM is developed on Linux, and every command was
broken there — the CLI died at import time before it could parse an argument.
The report (#8) named the
line; the testing that followed, on a real Windows 11 machine and checked
against tasklist rather than against RTFM's own claims, found five more
defects behind it and confirmed each fix. #9
then traced the console windows that kept popping up. That is a platform this
project could not otherwise support.
MIT — use it, fork it, extend it, ship it.
Romain Peyrichou — @roomi-fields
Code indexers see your code. RTFM sees everything.
⭐ Star on GitHub if RTFM saves your agent from hallucinating.
Curious how it works under the hood? See the Architecture — SQLite + FTS5, the parser registry, and the priority-queue worker (ingest → embed → OCR).
Local retrieval for AI agents: index code, docs, PDFs, data in SQLite; 24 parsers, served via MCP.
{ "mcpServers": { "io.github.roomi-fields-rtfm": { "command": "uvx", "args": [ "rtfm-ai==1.0.0" ] } }}เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
RTFM ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-11-15 Local retrieval for AI agents: index code, docs, PDFs, data in SQLite; 24 parsers, served via MCP.