>> the map and the memory
Working on a codebase with an AI assistant exposes a gap that has nothing to do with the model. The assistant is fluent, but it starts every session blind. It has to rediscover how the code is wired, and it has no recollection of why anything was decided the way it was. Two different problems, two different memory layers. CodeGraph answers the first. mqobsidian answers the second.
CodeGraph is an index. It reads a repository and builds a graph of its symbols — functions, types, the call paths between them — so that a question about the code can be answered by query rather than by grep. Instead of scanning files and guessing at names, you ask for a symbol and get its source back along with its callers and the paths that reach it. The map already exists; you read it instead of redrawing it every time.
The point is not speed for its own sake. It is that a graph holds the shape of the code as a structure you can traverse. "Where is this called from" and "what does this touch" become single lookups. The index is read-only and local — building it is a deliberate act, not something that runs behind your back. If a repository has not been indexed, nothing happens; the tool simply is not there.
mqobsidian is the other half. Where CodeGraph remembers structure, mqobsidian remembers narrative — the decisions, the reviews, the small learning records that explain why a thing is the way it is. It is an architecture memory layer built on an Obsidian vault: plain Markdown notes, linked to one another, that persist across sessions and survive the end of any single conversation.
A graph cannot tell you why a boundary was drawn where it was, or which approach was tried and abandoned, or what a review concluded six weeks ago. That knowledge is narrative, and it belongs in prose. Keeping it as linked notes means it can be recalled the same way it was written — by following references — rather than reconstructed from commit messages and memory.
Together they form a pair. The map answers where and how: how the code is connected, where a change will land. The memory answers why: why the decision was made, what was learned, what to avoid repeating. Structure on one side, intent on the other. An assistant with both does not start blind.
Both are read-first, local, and inspectable. The index never leaves the machine without an explicit call; the vault is just files you can open and read. That is the constraint that keeps the pair honest — memory you can audit, not memory you have to trust.