Skip to content
Trove

Docs / Documentation

Trove

Repository memory for LLMs: a Rust index engine and a Claude Code memory plugin

On this page
  1. First principles
  2. Two layers, one system
  3. Who it is for
  4. A minimal example
  5. What it does
  6. What it does not do
  7. Release status
  8. Where to go next

Trove gives a coding agent a memory that lasts between sessions and context that fits its window. It indexes a repository once into layered summaries, keeps the decisions, conventions and gotchas your team learns as plain files, and hands an agent only what a task needs, within a token budget.

Everything is plain files in your repository or home folder. Retrieval runs locally and offline. It is MIT licensed.

First principles

An agent starts every session without two things: the structure of the repository and its history. Structure can be rebuilt by reading code, but every file read costs tokens the task needed. History, meaning what was decided and why, cannot be rebuilt from code at all.

So Trove stores history as one small file per fact with a one-line index that is cheap to load every session, and stores structure as layers that shrink as they widen (symbols, files, subsystems, one architecture summary) so the top layers fit any budget. Retrieval starts at the top and stops when the budget is spent. How it works follows this reasoning through the whole design.

Two layers, one system

  • Engine. A Rust command line interface (CLI), trove, built from the crates/ workspace. It indexes a repository into .trove/ (symbols, module summaries, subsystems, an architecture summary and a dependency graph) and retrieves from it: trove query walks the layers top-down within a budget, and trove ask ranks your troves, repository docs, the code index and installed tools together and cites each hit as file:line. It also writes memory (trove remember), browses installed tools (trove tools) and builds redacted handoff docs (trove ship).
  • Plugin. A Claude Code plugin in plugins/trove. It keeps memory as plain files in a project trove (./.claude/trove, split into conventions, memory and context sections, each rendered as a skill) or a personal trove (~/.claude/trove). A SessionStart hook loads the indexes into every new session.

The engine answers “what is in this codebase and where?”. The plugin answers “what did we decide and why?”. They share files: trove ask and trove remember read and write the same troves the plugin uses, and an AGENTS.md block points Codex, Cursor and pi at them too.

Who it is for

  • Developers using Claude Code, Codex, Cursor or pi who want decisions and conventions to persist between sessions without re-explaining them.
  • Teams that want that memory reviewed and shared through Git, like code.
  • Anyone who wants retrieval over a large repository from a small, inspectable index on disk instead of a hosted service.

A minimal example

Engine, from a clone of the repository (requires Rust):

git clone https://github.com/anishfyi/trove
cd trove && cargo install --path crates/trove-cli
cd /path/to/your/repo
trove index
trove ask "where is the retry logic"

Plugin, typed one line at a time inside Claude Code:

/plugin marketplace add anishfyi/trove
/plugin install trove@velofy-trove
/reload-plugins
/trove:init

What it does

  • Indexes Rust, Python, JavaScript, TypeScript, Go and Bash source with tree-sitter, and writes a summary for every readable text file.
  • Retrieves context top-down, architecture to subsystems, modules and symbols, within a per-query token budget (trove query).
  • Answers questions with ranked, cited sources from every trove, repository docs, the code index and installed tools, offline by default (trove ask). A written answer from Anthropic, Ollama or any command is opt-in.
  • Captures one fact per file, routes it to the right section, and refuses entries that look like secrets (trove remember, /trove:remember).
  • Renders project trove sections into Claude Code skills that load on intent, and keeps them in sync on every session start.
  • Builds developer handoff docs from a project and its trove with secrets and private details removed, and refuses to write if a secret survives (trove ship).

What it does not do

  • It does not summarize code with a language model. Index summaries come from fixed rules over the source text.
  • It does not compute embeddings. Matching is lexical, so it misses synonyms.
  • It does not make network calls unless you ask it to: trove ask --provider anthropic or ollama, a provider command you configure, or trove ship --agent.
  • It does not ship prebuilt binaries. Build the engine from source with Cargo.
  • The original design in VISION.md describes more than is built today. See Memory hierarchy for what exists and Roadmap for what is open.

Release status

The latest release is v0.2.0, from 2026-07-21. Everything since then, including project troves, ask, remember, tools and ship, is merged on the main branch but not yet released; the README calls this work v0.3. Building from a clone gives you main. The binary still reports version 0.2.0. See the Changelog.

Where to go next