Trove - Índice de Memória Pessoal para Claude Code
anishfyi/trove
Memória persistente baseada em arquivos para acelerar fluxos de Claude Code
Ver no GitHubSkill que constrói e mantém uma camada semântica baseada em arquivos, armazenando decisões, convenções, gotchas e referências do seu trabalho. Recarrega automaticamente a cada sessão, eliminando a necessidade de re-explicar contextos. Portável, pesquisável e sem dependências externas.
Instalação
npx convez-ai anishfyi/trove1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Manter registro de decisões arquiteturais e rationale do projeto
- Documentar convenções, padrões e gotchas específicos do codebase
- Eliminar re-explicações de contexto entre sessões do Claude Code
- Criar referências estruturadas (configs, schemas, mappings) em JSON
Veredito

Ferramenta prática que resolve um problema real: perda de contexto entre sessões. Implementação limpa baseada em arquivos, sem lock-in. Ideal para projetos que exigem memória acumulada, especialmente equipes ou work-in-progress de longa duração.
README
A tradução para o português deste README ainda está na fila.
Trove - a personal memory index for Claude Code
Install once, and Claude Code keeps a personal, file-based trove of your decisions, gotchas, conventions and references as you work, and reloads it into context at the start of every session.
Live page: https://anishfyi.github.io/trove/
Every fact is one file, and Claude picks the format that fits it: Markdown for prose (decisions, gotchas, conventions) or JSON for structured context (mappings, lists, config, schemas). The trove is portable, greppable, diffable, and yours. No database, no service, no lock-in.
Install
Plugin (recommended)
Run these one at a time inside Claude Code, top to bottom.
1. Add the marketplace. A marketplace is just a Git repo that lists installable plugins. This points Claude Code at Trove's repo. Nothing is installed yet.
/plugin marketplace add anishfyi/trove
Hit an SSH
Permission denied (publickey)error? You have no SSH key on GitHub, so use the HTTPS URL instead:/plugin marketplace add https://github.com/anishfyi/trove.git
2. Install the plugin. Pulls the Trove plugin (its three skills plus the SessionStart hook) from
that marketplace. Read it as plugin@marketplace.
/plugin install trove@anishfyi-trove
3. Reload so it activates. A freshly installed plugin is not live until you reload. This
activates the skills and hook in your current session (verify with /plugin list). The auto-load
hook starts firing from your next new session onward.
/reload-plugins
4. Create your trove. Scaffolds ~/.claude/trove with an INDEX.md and an entries/ folder.
/trove:init
Done. From here, say "remember this" or run /trove:remember to capture, and /trove:recall to
search it back.
Manual (skills only, no auto-load hook)
git clone https://github.com/anishfyi/trove /tmp/trove
cp -r /tmp/trove/plugins/trove/skills/* ~/.claude/skills/
This gives you /init, /remember, and /recall. The automatic session-load hook ships only with
the plugin install above.
Usage
| Command | What it does |
|---|---|
/trove:init | Create the trove at user scope (~/.claude/trove) or project scope (./.claude/trove). |
/trove:remember | Distill a durable learning into one atomic entry and add it to the index. |
/trove:recall | Search the trove and answer grounded in the relevant entries. |
The skills also auto-trigger on intent: say "remember this in my trove" or "what do I know about X"
and the right skill fires without typing the command. Every new session, the SessionStart hook loads
your INDEX.md into context so Claude starts aware of what it already knows.
Why it speeds you up
Every Claude Code session normally starts from zero: you re-explain the codebase, the conventions, the decisions you already made. Trove ends that. What you teach it once it knows for good, so each session begins further ahead than the last.
It paces up your work
- Stop re-explaining. Claude opens each session already aware of your decisions, conventions and gotchas. No daily "here is how this repo works" preamble.
- Stop repeating mistakes. A footgun you hit once is written down, so Claude does not walk into it a second time.
- Decide faster. Past decisions and their rationale are one recall away, so you do not re-litigate or contradict yourself.
- Onboard instantly. A new machine, or a teammate on a project-scope trove, inherits all the accumulated knowledge at once.
- Compounding returns. Teach it once, benefit every session after. The longer you use it, the more leverage it has.
Why the index is the engine
The INDEX.md is the part that actually loads into context at session start, one compact line per
entry, so Claude knows everything it has without paying to load every full file. Recall stays fast
and cheap: Claude scans the index, then opens only the handful of entries that matter instead of
dumping the whole trove into the prompt. It is also your human-readable map, skimmable and prunable
like a notebook's table of contents, and each one-line hook is written to match intent. The index is
the difference between a pile of files and a memory you can actually use.
What the trove looks like
Each entry is one file. Claude picks the format by the shape of the content: Markdown for prose, JSON for structured data. The index lists both, side by side.
~/.claude/trove/
├── INDEX.md # one line per entry, newest first
└── entries/
├── use-pgx-not-orm.md # prose -> Markdown
├── service-ports.json # structured -> JSON
└── staging-db-mirror.md
A Markdown entry (prose: decisions, gotchas, conventions):
---
title: Use pgx + sqlc, not a heavy ORM, in Go services
slug: use-pgx-not-orm
type: decision
created: 2026-06-13
tags: [go, postgres, data-layer]
---
We standardised on pgx for the driver and sqlc to generate type-safe query code
from plain SQL. GORM was rejected for hiding query cost behind reflection.
**Why it matters:** reach for this on any new Go service.
**Related:** [[deploy-single-binary]]
A JSON entry (structured context: mappings, lists, config, schemas, the payload lives under data):
{
"title": "Local service ports",
"slug": "service-ports",
"type": "reference",
"created": "2026-06-14",
"tags": ["infra", "ports"],
"summary": "which service runs on which port",
"data": { "web": 8000, "trove-ui": 8010, "partners": 8011 }
}
Both carry the same top-level fields (title, slug, type, created, tags). Entry type is one
of: decision, gotcha, preference, reference, project, snippet.
What is worth remembering
Save: decisions and their rationale, gotchas and footguns, conventions you expect Claude to follow, external references (URLs, dashboards, tickets), and project constraints that are not obvious from the code.
Skip: secrets, transient task state, and anything trivially re-derivable from the codebase or git history. If a fact is one of those, capture what was non-obvious about it instead.
Repository layout
trove/
├── .claude-plugin/
│ └── marketplace.json # lists the trove plugin
├── plugins/
│ └── trove/
│ ├── .claude-plugin/
│ │ └── plugin.json
│ ├── skills/
│ │ ├── init/SKILL.md
│ │ ├── remember/SKILL.md
│ │ └── recall/SKILL.md
│ ├── hooks/
│ │ └── hooks.json # SessionStart: load the index
│ └── scripts/
│ ├── load-trove.sh # hook body (read-only, defensive)
│ └── trove.sh # tiny CLI helper (path/init/list/grep)
├── index.html # AlpineJS landing page
├── PRD.md # product requirements
├── ENGINEERING.md # engineering design
└── LICENSE
Docs
Built by anishfyi. MIT licensed.