grove indexes your folders, notes, and team exports into a navigable tree-of-contents forest that Claude Code, Cursor, and other AI clients query over MCP. No vector database. No mandatory cloud indexing. Bring your own model.
The default RAG recipe chops every document into chunks and embeds them into a vector database. The folder hierarchy, the backlinks, the table of contents — the shape that told you where things are — is gone. You traded a map for a pile of index cards.
And it's a whole new piece of infrastructure to run and keep in sync, that only pays off when your questions and documents use different words. For a tidy, well-organized corpus, that's solving a problem you didn't have.
grove takes the other path: keep the structure and navigate it first — then fold in keyword and semantic search as fused signals, without a separate vector database to run.
grove's bet is the local, source-native forest — navigated first, then fused with keyword and semantic search. Four ideas it's built around.
Rather than chopping documents into chunks, grove builds a navigable tree and lets a model descend it like a table of contents. Descent leads — then it's fused with keyword and document-level semantic search, so each retriever covers the others' blind spots.
Your knowledge already has shape: folder hierarchies, Obsidian backlinks, headings. grove preserves that as a forest of trees and layers semantic cross-links on top, rather than dissolving it into a pile of chunks.
Indexing and answering are separate model choices. Build the index with a free local model; query it with Claude for quality or a local model for privacy. grove speaks the OpenAI-compatible API plus Anthropic and Ollama.
The index lives on your disk as SQLite plus plain JSON — content-addressed, diffable, and yours. Not an invisible SaaS index you rent. Nothing leaves your machine unless you point grove at a cloud model on purpose.
Four verbs. Indexing and querying are separate model choices, so you can build with a free local model and query with whatever fits the task.
Point grove at a source — a folder or an Obsidian vault (Drive and Confluence later). It walks the files, respects .gitignore and globs, extracts text from Markdown, PDF, and DOCX, and stores content-addressed payloads.
grove mirrors each source's native hierarchy into a tree, clusters loose notes into topics, and writes an LLM-generated title and summary per node. Every node is cached by content — an unchanged rebuild makes zero model calls.
An ensemble: keyword (FTS) + semantic (bge-m3) by default, fused with RRF. `--mode` picks the work: fast (no model), balanced (+ sub-query decompose), quality (+ graded rerank), deep (+ tree descent). Cited answer with a retrieval trace; --correct turns on CRAG abstention.
`grove serve --mcp` exposes the forest to Claude Code, Cursor, Cline, and any MCP client — list trees, navigate nodes, read docs, semantic search, follow cross-links. Or `grove serve` for a local web UI with a force-directed forest graph that lights up the retrieval path on each ask.
A thin core API behind the CLI; adapters (CLI, MCP, HTTP) hold no business logic and never touch the store directly. Build and query are model-agnostic — grove speaks the OpenAI-compatible API plus Anthropic and Ollama, with cost and token accounting per call.
Every tree node is content-addressed by (content hash, prompt version, build model), so an unchanged rebuild hits the cache 100% and makes zero model calls — and a sync only regenerates the branches that actually changed.
60 hard multi-doc questions over 1,668 Kubernetes docs, with bge-m3 embeddings on every row — the same embedder across grove and the vector-RAG baselines, so the comparison is apples-to-apples. Headline metric is docRecall@12: ground truth is multi-doc, so "found one of four" isn't success.
| Pipeline | docRecall@12 | hit@12 | MRR | Latency | Needs a model? |
|---|---|---|---|---|---|
| grove fast (keyword + embeddings) | 0.72 | 97% | 0.749 | ~0.1s | no |
| grove balanced (+ decompose) | 0.85 | 98% | 0.823 | ~1.5s | any (8b ok) |
| grove quality (+ graded rerank) | 0.86 | 98% | 0.743 | ~2.4s | strong only |
| vanilla vector RAG (embeddings only) | 0.55 | 88% | 0.547 | ~0.1s | no |
| advanced RAG (embeddings + rerank) | 0.62 | 90% | 0.669 | ~2.4s | strong only |
grove balanced and quality clear vanilla vector RAG by roughly 1.5× on recall — and balanced beats reranked vector RAG without needing a strong model. The win is coverage (keyword + tree + sub-query decomposition), not reranking. LLM-stage rows used DeepSeek; quality's MRR dips because the reranker reorders within an already-recovered set. Full methodology, model-class caveats, and the runs that came out negative are in documents/benchmark-findings.md.
Several tools solve parts of this. grove's wedge is the local, source-native forest — structure-first retrieval, with no chunking and no separate vector database.
Chunks everything and makes embeddings the whole system, in a vector DB you run. grove keeps the structure and navigates it first, with embeddings as one fused signal — no chunking, and no separate vector store (vectors sit in local SQLite).
Tree retrieval over a single long document. grove is multi-source connector infrastructure with a source-native forest across heterogeneous sources. Complementary.
Local CLI search over one collection (BM25 + vectors). grove adds source connectors and a forest abstraction across many sources.
Hosted, managed knowledge AI. grove is local-first, open source, bring-your-own-model — no SaaS, no lock-in.
Prerequisites: Go 1.25+. A local model via Ollama is enough to build and query end to end — no cloud key required. grove is a single static Go binary; while it's pre-release, build from source.
# clone and buildgit clone \ https://github.com/dhruv1794/grovecd grovemake build # → ./bin/grove # create a workspacegrove initgrove connect local ~/Documents/work
# build with a free local modelgrove build \ --model ollama/qwen2.5:32b # add semantic embeddings (bge-m3)grove embed # rebuild is free — content-addressedgrove build # 0 model calls # keep it current as notes changegrove sync --watch
# cited answer (balanced is the default)grove ask "what's our auth flow?" \ --model anthropic/claude-sonnet-4-6 # pick the work: fast | balanced | quality | deepgrove ask "jwt" --mode fast --retrieve-only # interactive TUIgrove repl # serve to Claude Code / Cursor / Cline over MCPgrove serve --mcp # or a local web UI with a forest graphgrove serve
Every v0.1 milestone is built — connectors, tree build, ensemble query with citations, incremental sync, the REPL TUI, a web UI with a force-directed forest graph, and the MCP server. The benchmark is published. v0.1.0 packaging, the Homebrew tap, and launch are the remaining work.
Numbers are published with the full methodology, including the runs that came out negative — see benchmark-findings.md. Follow the build in Writing.
Open source. No vector database, no SaaS — your documents stay on your machine.