I had a tool called aide memoire, a scratchpad of memory and context for an AI coding assistant, built the way everyone builds these: a local vector database, embeddings of everything, semantic recall. It worked, more or less, and then it bit-rotted into something I no longer trusted. So I brought it back from scratch as aide, and the thing I was most certain about going in was that the vector database wasn't coming with it.
That sounds like a step backwards. Embeddings-in-a-vector-store is the default for coding-assistant memory. But the more I'd lived with the old design, the more the vector DB felt like the wrong tool for this job, so the resurrection drops it. aide runs on lexical full-text search (BBolt + Bleve, BM25-style) and a tree-sitter symbol index instead, and I think it's better for it.
Why no vector DB
The pitch for embeddings is semantic recall: find the chunk that's vibes-similar to your query. But what an agent needs from a project usually isn't vibes; it's facts. Where is this symbol defined? What calls it? What did we decide about retries, and why? What's the convention here? Those are exact, structural questions, and answering them with nearest-neighbour search over a cloud of floats is a fuzzy tool aimed at a precise target. aide's bet is that the power is in factual context, not semantic similarity, and once you take that bet, the wins stack up:
- No model in the loop. Embeddings have to be generated, so you end up piggybacking on an LLM just to remember things: tokens and latency to store, more to recall, a whole model dependency for what should be a database lookup. A lexical index and a tree-sitter parse need no model at all. aide remembers without asking anyone's API for permission.
- Accuracy. A factual lookup returns the answer, not the five chunks that scored closest. "Where is
Foodefined" has a correct result; cosine similarity only has a ranking. For code, exact beats approximate nearly every time. - Fewer tokens. Because the answer is precise it's also small: the one symbol, the one decision, the actual call sites, instead of a wad of semantically-adjacent text padded out to fill the context window. Token reduction and better answers turn out to be the same lever, not a trade-off.
- Context as code. Everything aide knows (memories, decisions, findings) lives as plain records in a per-project
.aide/directory and exports to markdown you can commit. It's PR-reviewable, diffable, and you can read why something surfaced. A blob of floats is none of those. - And it's where the field went. Native harnesses converged on a small always-loaded index plus on-demand file reads, not local-vector RAG: no model to run, nothing leaving the machine, an index measured in megabytes, the same behaviour on every box.
For finding code, a tree-sitter symbol index gives you definitions, references and call graphs across a dozen languages with zero setup and no compiler in the loop: error-tolerant, precomputed, whole-repo. For finding knowledge, full-text over short human-written records beats cosine similarity over chunks. Neither needs a GPU.
What it actually does
aide is an MCP plugin that gives an assistant (Claude Code today; more shortly) the things a new contributor would kill for:
- Memory + decisions: preferences, context and architectural choices that persist across sessions, injected at startup and enforceable when you write code that contradicts them.
- Code intelligence: tree-sitter symbol search, references and call graphs.
- Findings: static analysis for complexity, coupling, secrets, duplication and dead code.
- Survey: a map of modules, entry points, tech stack and churn hotspots.
- Skills + multi-agent orchestration: keyword-triggered workflows, and parallel agents working in isolated git worktrees.
The throughline is that it serves compact, token-budgeted answers instead of whole files, so a long-running agent spends its context window on the work rather than rediscovering the project every session.
It's early and opinionated, which is the way I like a v0. Repo and docs on GitHub. More on the individual pieces, and the opinions behind them, to come.