mimirs

local-rag

Persistent project memory for AI coding agents. One command to set up, nothing to maintain.

Your agent starts every session blind — it guesses filenames, greps for keywords, burns context reading irrelevant files, and forgets everything you discussed yesterday. On a real project, that meant 380K tokens per prompt and 12-second response times. After indexing with local-rag: 91K tokens, 3 seconds.

No API keys. No cloud. No Docker. Just bun and SQLite.

What it gives your agent

Find code by meaning, not filename. "Where do we handle authentication errors?" doesn't map to any symbol name — but local-rag finds middleware/session-guard.ts anyway. Hybrid vector + BM25 search, boosted by dependency graph centrality. 100% recall across codebases up to 8.7K files.

Remember past sessions. Conversation transcripts are indexed in real time. Three days later, your agent can search for "why did we switch to JWT?" and get the exact discussion — no re-explaining.

Know what changed since last time. git_context shows uncommitted changes and recent commits in one call, so agents don't propose edits that conflict with in-progress work.

Leave notes for future sessions. annotate attaches persistent caveats to files or symbols — "known race condition", "blocked on auth rewrite" — that surface automatically in search results.

Mark decisions, not just code. Checkpoints capture milestones, direction changes, and blockers. Searchable across sessions so context doesn't evaporate.

Understand codebase structure. Dependency graphs, reverse-dependency lookups, and find_usages show the blast radius before any refactor.

Generate a project wiki. generate_wiki produces a structured, cross-linked markdown wiki — architecture docs, module pages, entity pages, guides, and Mermaid diagrams — all built from the semantic index. Supports incremental updates when source files change.

Expose documentation gaps. Analytics log every query locally — nothing leaves your machine. Zero-result and low-relevance queries reveal what's missing from your docs.

Quick start

Works with Claude Code, Cursor, Windsurf, and VS Code Copilot.

1. Install SQLite (macOS)

Apple's bundled SQLite doesn't support extensions:

brew install sqlite

2. Set up your editor

bunx @winci/local-rag init --ide claude   # or: cursor, windsurf, copilot, all

This creates the MCP server config, editor rules, .rag/config.json, and .gitignore entry. Run with --ide all to set up every supported editor at once.

3. Try the demo (optional)

bunx @winci/local-rag demo

Claude Code plugin

For deeper integration, local-rag is also available as a Claude Code plugin. In a Claude Code session:

/plugin marketplace add https://github.com/TheWinci/local-rag.git
/plugin install local-rag

The plugin adds SessionStart (context summary), PostToolUse (auto-reindex on edit), and SessionEnd (auto-checkpoint) hooks. No CLAUDE.md instructions needed — the plugin's built-in skill handles tool usage.

Search quality

Benchmarked on four codebases with known expected files per query. Full details in BENCHMARKS.md.

Codebase	Language	Files	Queries	Recall@10	MRR	Zero-miss
local-rag (this project)	TypeScript	97	20	100.0%	0.651	0.0%
Express.js	JavaScript	161	15	100.0%	0.922	0.0%
Excalidraw	TypeScript	676	20	100.0%	0.366	0.0%
Kubernetes	Go	8,691	20	100.0%*	0.496	0.0%*

*With config tuning. At default top-10, Recall is 80%. See BENCHMARKS.md for details.

How it works

1. Parse & chunk — Splits content using type-matched strategies: function/class boundaries for code (via tree-sitter across 24 languages), headings for markdown, top-level keys for YAML/JSON. Chunks that exceed the embedding model's token limit are windowed and merged.

2. Embed — Each chunk becomes a 384-dimensional vector using all-MiniLM-L6-v2 (in-process via Transformers.js + ONNX, no API calls). Vectors are stored in sqlite-vec.

3. Build dependency graph — Import specifiers and exported symbols are captured during AST chunking, then resolved to build a file-level dependency graph.

4. Hybrid search — Queries run vector similarity and BM25 in parallel, blended by configurable weight. Results are boosted by dependency graph centrality and path heuristics. read_relevant returns individual chunks with entity names and exact line ranges (path:start-end).