코드, 문서, PDF 및 연구 자료를 로컬에 인덱싱하여 AI 코딩 에이전트가 더 적은 API 호출로도 정확한 컨텍스트를 검색하고 가져올 수 있도록 합니다.
다른 이름 roomi-fields/rtfm, rtfm-ai
- 스타
- 27
- Tools
- 14
- 다운로드, 30일
- 1,816
- 최신 버전
- 1.0.0
- 마지막 커밋
- 2026년 11월 13일
- 라이선스
- MIT
RTFM MCP란?
코드, 문서, PDF 및 연구 자료를 로컬에 인덱싱하여 AI 코딩 에이전트가 더 적은 API 호출로도 정확한 컨텍스트를 검색하고 가져올 수 있도록 합니다. 14개 도구를 제공합니다. 예: rtfm_search, rtfm_context, rtfm_expand.
프로젝트 README에서 생성된 요약
RTFM MCP server 정보
대규모 프로젝트를 다루는 개발자는 RTFM을 사용하여 다양한 파일 형식으로부터 AI 코딩 에이전트에 즉각적이고 정확한 컨텍스트를 제공할 수 있습니다. 에이전트가 디렉토리를 수동으로 grep하게 만드는 대신, 이 도구는 코드, 문서, PDF, 연구 논문 및 법률 문서를 로컬 SQLite 데이터베이스에 인덱싱합니다. 이러한 접근 방식은 에이전트가 전문 검색(full-text), 시맨틱 또는 하이브리드 검색을 사용하여 순위가 매겨진 검색 결과를 가져올 수 있게 하여, 정보를 찾는 데 필요한 토큰 수와 API 호출을 크게 줄여줍니다.
서버는 Linux, macOS, Windows 또는 WSL에서 완전히 로컬로 실행되므로 클라우드 의존성이나 API 비용 없이 데이터 프라이버시를 보장합니다. Claude Code와 같은 MCP 클라이언트에서 플러그인 marketplace를 통해 설치하거나, Cursor 및 Claude Desktop과 같은 클라이언트를 위해 pip로 수동 설치하여 사용할 수 있도록 설계되었습니다. 사용자는 시맨틱 임베딩 또는 고급 PDF 파싱을 위한 선택적 구성 요소를 설치하여 기능을 확장할 수 있으며, 이러한 구성 요소는 시스템 충돌을 방지하기 위해 격리된 환경에서 관리됩니다.
활용 사례
- 1다양한 파일 형식에서 컨텍스트 검색AI 에이전트는 단일 쿼리를 사용하여 소스 코드, 마크다운 문서, PDF 연구 논문이 섞인 환경을 검색할 수 있습니다.
- 2비싼 컨텍스트 윈도우 사용량 절감파일 전체를 프롬프트에 쏟아붓는 대신, 에이전트는 어떤 섹션을 확장할지 결정하기 위한 작은 메타데이터 포인터를 전달받습니다.
- 3개인 지식 베이스 인덱싱개발자는 Obsidian vault를 wikilink를 지원하는 검색 가능한 지식 그래프로 변환할 수 있습니다.
- 4코딩 세션 간 메모리 유지이 도구는 Claude Code가 생성한 메모리 파일을 스냅샷하고 인덱싱하여 프로젝트 간 검색이 가능하도록 합니다.
프로젝트의 README를 바탕으로 작성되었습니다. 모든 활용 사례는 해당 내용의 인용문과 대조하여 확인합니다.
RTFM MCP 설치 방법
형식 확인: 2026년 11월 10일Cursor에 추가Goose에 추가Claude Code에 RTFM MCP 설치
$ claude mcp add rtfm -- uvx rtfm-aiCursor에 RTFM MCP 설치
~/.cursor/mcp.json
{
"mcpServers": {
"rtfm": {
"command": "uvx",
"args": [
"rtfm-ai"
]
}
}
}VS Code에 RTFM MCP 설치
.vscode/mcp.json
{
"servers": {
"rtfm": {
"type": "stdio",
"command": "uvx",
"args": [
"rtfm-ai"
]
}
}
}VS Code CLI에 RTFM MCP 설치
$ code --add-mcp '{"name":"rtfm","type":"stdio","command":"uvx","args":["rtfm-ai"]}'Claude Desktop에 RTFM MCP 설치
claude_desktop_config.json
{
"mcpServers": {
"rtfm": {
"command": "uvx",
"args": [
"rtfm-ai"
]
}
}
}Codex에 RTFM MCP 설치
$ codex mcp add rtfm -- uvx rtfm-aiCodex config.toml에 RTFM MCP 설치
~/.codex/config.toml
[mcp_servers.rtfm] command = "uvx" args = ["rtfm-ai"]
Gemini CLI에 RTFM MCP 설치
$ gemini mcp add -s user rtfm uvx -- rtfm-aiGemini settings.json에 RTFM MCP 설치
~/.gemini/settings.json
{
"mcpServers": {
"rtfm": {
"command": "uvx",
"args": [
"rtfm-ai"
]
}
}
}RTFM MCP 도구 14
README에서 감지됨rtfm_searchrtfm_contextrtfm_expandrtfm_discoverrtfm_booksrtfm_statsrtfm_syncrtfm_ingestrtfm_tagsrtfm_tag_chunksrtfm_removertfm_graph
| rtfm_search | — | |
| rtfm_context | — | |
| rtfm_expand | — | |
| rtfm_discover | — | |
| rtfm_books | — | |
| rtfm_stats | — | |
| rtfm_sync | — | |
| rtfm_ingest | — | |
| rtfm_tags | — | |
| rtfm_tag_chunks | — | |
| rtfm_remove | — | |
| rtfm_graph | — |
도구 14개 모두 보기도구 수 줄이기
rtfm_historyrtfm_coverage
| rtfm_history | — | |
| rtfm_coverage | — |
자동 검사
2026년 11월 13일에 실행됨전체 보고서 →자동 검사를 통과했습니다. 이는 보안 감사가 아닙니다. 코드를 직접 읽고 서버에 필요한 최소한의 권한만 부여하십시오. 검사 방식
- 소스 저장소 연결 및 접근 가능roomi-fields/rtfm is public and reachablegithub.com/roomi-fields/rtfm ↗통과
- 패키지가 이 저장소를 소스로 명시rtfm-ai names roomi-fields/rtfm as sourcepypi.org/project/rtfm-ai/ ↗통과
- 빌드 출처(Sigstore 증명)No build attestation published for this release검사되지 않음
- 오픈 소스 라이선스 (OSI)MITspdx.org/licenses/MIT.html ↗통과
- 최근 1년 내 커밋 또는 릴리스Last commit or release 2026-11-13github.com/roomi-fields/rtfm ↗통과
- OpenSSF Scorecard검사되지 않음
- 패키지 이름이 인기 패키지와 유사하지 않음No popular package one edit away from rtfm-ai통과
- 패키지 및 해당 종속성에 중요한 보안 권고 없음the package checked; no critical advisoryosv.dev ↗통과
- 모델에 대한 숨겨진 지침 없음14 tool descriptions and the README read; no override phrases, credential paths or hidden characters통과
- 파괴적인 도구에 라벨 표시됨No tool named like delete, drop or exec통과
- 원격 엔드포인트가 MCP 핸드셰이크에 응답검사되지 않음
README
GitHub에서 보기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 | Augment CE | Sourcegraph | Code-Index-MCP | MemPalace | |
|---|---|---|---|---|---|
| Code indexing | ✅ (AST-aware) | ✅ | ✅ | ✅ | Shallow (char-chunk) |
| Docs, specs, markdown | ✅ (header-parsed) | Partial | ❌ | Limited | Verbatim chunks |
| Legal / regulatory | ✅ (XML, BOFiP) | ❌ | ❌ | ❌ | ❌ |
| Research (LaTeX, PDF) | ✅ | ❌ | ❌ | ❌ | ❌ |
| Custom parsers | ✅ (~50 lines) | ❌ | ❌ | ❌ | ❌ |
| Knowledge graph | ✅ (file/code links) | ❌ | Partial | ❌ | Entity graph (people) |
| File version history | ✅ (unlimited) | ❌ | ❌ | ❌ | ❌ (purge-and-replace) |
| MCP native | ✅ | ✅ | ✅ | ✅ | ✅ |
| Runs locally | ✅ | Cloud | Enterprise | ✅ | ✅ |
| Open source | MIT | ❌ | Partial | ✅ | MIT |
| Price | Free | $20-200/mo | $$$/mo | Free | Free |
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 →
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.dbsees every~/.claude/projects/*/memory/directory on your machine. Askrtfm_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 <slug>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.
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.yamlmapping into.rtfm/mappings/. Each.jsonanswer file produces typed chunks withnotebook_id,source_name,citation_markerqueryable via SQL, pluscitesedge candidates between answers and sources.
Use Path A unless you specifically need to filter or graph by structured citation fields.
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, case law, and administrative doctrine. Same agent (Claude Code + Sonnet 4), same prompt, eight configurations tested.
| Configuration | Duration | Cost | Tokens |
|---|---|---|---|
| Baseline (no RTFM) | 8m 16s | $22.61 | 8.21 M |
| With RTFM (FTS default) | 6m 58s | $11.14 | 3.22 M |
Δ : −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.
Code task: FeatureBench (LiberCoders dataset)
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.
| Repo | Size | Where RTFM helps |
|---|---|---|
| metaflow | 620 files | Everyone resolves — RTFM adds no measurable gain |
| astropy | 1,119 files | All conditions 25–30 % F2P pass; none fully resolve |
| mlflow | 8,255 files | All conditions 0–5 % F2P pass; none fully resolve |
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.
The honest caveats
- Single model (Sonnet 4), single agent (Claude Code). Not statistically bullet-proof.
- On small repos (< 1k files),
grepis enough and RTFM adds overhead. - FeatureBench measures code modification, not information retrieval. It's the wrong benchmark for a retrieval tool — I'm running against it because it's what exists. Better-suited benchmarks (RepoQA, SWE-QA, LocAgent) are on the roadmap.
What this says
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.
Who it's for
RTFM works anywhere your project isn't just code:
- LegalTech — Code + tax law + regulatory specs. Ships with Legifrance XML and BOFiP parsers.
- Research — Code + LaTeX papers + datasets. Ships with LaTeX and PDF parsers.
- FinTech — Code + financial regulations + XBRL reports. Write an XBRL parser in 50 lines.
- HealthTech — Code + medical records (HL7/FHIR) + clinical guidelines.
- Solo devs with big projects — Stop watching your agent grep the same 8,000 files every session.
- Obsidian / PKM users — Make your vault actually searchable by your AI.
- Any regulated industry — If your project mixes code with domain documents, RTFM is for you.
Full feature list
Search & retrieval
- FTS5 full-text search — instant, zero-config, works out of the box
- Semantic search — optional embeddings (FastEmbed/ONNX, no GPU needed)
- Hybrid mode — combine both, rank by relevance score
- Metadata-first — results return file paths + scores (~300 tokens), not content dumps
- Progressive disclosure — agent expands only the chunks it actually needs
- Knowledge graph — wikilinks + Python imports resolved as graph edges, hub detection, centrality ranking
Multi-format indexing
- 24 parsers built-in — Markdown, Python (AST), LaTeX, YAML, JSON, TOML, Shell, PDF, XML, HTML, SQLite, Jupyter, CSV/TSV, XLSX, EPUB, MOBI/AZW, FB2, DJVU, DOCX, ODT, RTF, MIDI, audio tags (MP3/FLAC/OGG/M4A/WAV/AIFF…), plain text
- Extensible — add any format in ~50 lines of Python
- Auto-sync hooks — index stays fresh every prompt, zero manual work
- Incremental — only re-indexes what changed
Integration
- Native Claude Code plugin —
/plugin install rtfm@roomi-fields/rtfm, auto-init per project - Pure-Python MCP server — 0 external deps, no
mcpSDK /pydantic/ native binaries - Cross-platform — Linux, macOS, Windows, WSL (only requires Python ≥ 3.10 on PATH)
- 14 MCP tools — search, context, expand, graph, history, sync, tags, ...
- Manual install fallback —
pip install rtfm-aifor Cursor, Codex, Claude Desktop chat, any other MCP client - CLI + Python API — scriptable for pipelines
- Non-invasive — doesn't touch your code, doesn't replace your editor
The parser architecture
Need 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.
Two levels of JSON integration
For JSON-based formats specifically, RTFM offers a second extensibility path that doesn't need any Python:
| Level | What you do | What you get |
|---|---|---|
| 1. Generic | Nothing. Just index the file. | Each top-level key becomes a chunk. Full-text search works on values. |
| 2. Mapped | Drop a YAML mapping in .rtfm/mappings/ (~30 lines). |
Typed chunks with declared metadata, custom titles, foreach extraction over arrays, edge candidates. The producing project (NotebookLM, Linear, Notion, OpenAPI…) ships the mapping; RTFM stays generic. |
See JSON schema mappings for the full reference, and RTFM × NotebookLM for a concrete recipe.
Built-in parsers
| Parser | Extensions | Strategy |
|---|---|---|
| Markdown | .md |
Split by headers, YAML frontmatter extraction |
| Python | .py |
AST-based: each class/function = 1 chunk |
| LaTeX | .tex |
Split by \section, \chapter, etc. |
| YAML | .yaml, .yml |
Split by top-level keys |
| JSON | .json |
Split by top-level keys or array elements |
| TOML | .toml |
Top-level tables; emits depends_on edges (PEP 621, Cargo, Poetry) |
| Shell | .sh, .bash, .zsh |
Function-aware chunking |
.pdf |
Page-based (pip install rtfm-ai[pdf]) |
|
| Legifrance XML | .xml |
French legal codes (LEGI format) |
| BOFiP HTML | .html |
French tax doctrine |
| SQLite | .sqlite, .sqlite3, .db |
Schema + sample rows per table; FK edges (read-only) |
| Jupyter | .ipynb |
Group cells by markdown heading; outputs dropped |
| CSV / TSV | .csv, .tsv |
Header + sample rows + lightweight type inference |
| XLSX | .xlsx |
Per-sheet schema + sample (pip install rtfm-ai[xlsx]) |
| Plain text | .js, .ts, .rs, .go, ... |
Line-boundary chunks (~500 chars) |
MCP tools
| Tool | What it does |
|---|---|
rtfm_search |
Search the index (FTS, semantic, or hybrid) |
rtfm_context |
Get relevant context for a subject (metadata-only) |
rtfm_expand |
Show all chunks of a source with full content |
rtfm_discover |
Fast project structure scan (~1s, no indexing needed) |
rtfm_books |
List indexed documents |
rtfm_stats |
Library statistics |
rtfm_sync |
Sync a directory (incremental) |
rtfm_ingest |
Ingest a single file |
rtfm_tags |
List all tags |
rtfm_tag_chunks |
Add tags to specific chunks |
rtfm_remove |
Remove a file from the index |
rtfm_graph |
Show dependency graph for a source (imports, links) |
rtfm_history |
File version history and memory snapshots |
rtfm_coverage |
What the index holds against what is on disk |
CLI reference
# 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
Python API
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()
Where RTFM fits
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.
Contributing
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.
RTFM MCP 질문
RTFM MCP를 Claude Code에 추가하려면 어떻게 하나요?
터미널에서 claude mcp add rtfm -- uvx rtfm-ai를 실행합니다. 모든 프로젝트에서 사용할 수 있게 하려면 --scope user를 추가합니다.
RTFM MCP를 Cursor에 추가하려면 어떻게 하나요?
~/.cursor/mcp.json를 열고 mcpServers 아래에 서버를 추가합니다. 위 설치 섹션에 표시된 Cursor 구성을 사용합니다.
RTFM MCP는 어떤 도구를 제공하나요?
14개 도구를 제공합니다. 예: rtfm_search, rtfm_context, rtfm_expand, rtfm_discover, rtfm_books.
RTFM을 사용하려면 API 키나 클라우드 서비스가 필요한가요?
아니요. RTFM은 API 키나 클라우드 비용 없이 단일 SQLite 파일로 로컬에서 실행됩니다.
RTFM은 어떤 파일 형식을 인덱싱할 수 있나요?
24개의 포맷 파서를 사용하여 코드, 문서, PDF, 법률 문서, 연구 논문 및 데이터를 인덱싱합니다.
Claude Code에서 RTFM을 어떻게 설치하나요?
Claude Code 플러그인 marketplace를 통해 설치하면 pip install 없이 각 프로젝트를 자동으로 초기화합니다.
AI 에이전트가 여러 프로젝트의 메모리 파일을 가로질러 검색할 수 있나요?
네, RTFM은 ~/.rtfm/memory.db에 프로젝트 간 메모리 인덱스를 구축하여 머신에 있는 모든 Claude 메모리 디렉토리를 탐색합니다.
RTFM은 시맨틱 검색을 지원하나요?
네, 선택 사항인 임베딩 설치를 통해 시맨틱 및 하이브리드 검색을 사용할 수 있습니다.