90. Why You Must Install a Memory System
Understand why long projects need an external memory system, and why Graphify and Obsidian working as a tandem is the recommended way to give every new session an accurate picture of the project.
By Jacques Botte, founder of Toptronic®. Last updated 19 September 2026.
The lesson
An LLM session has no memory of yesterday. When the session ends, everything it learned about your project — the architecture, the decisions, the reasons a file was written that way — evaporates with it. The next session starts from zero, and if you rely on the model "picking things up" by re-reading the code, you pay for that rediscovery in tokens, time, and errors. An external memory system exists to close that gap: facts about the project are written down, outside the model, in a place the next session can be pointed at.
Why external, rather than a big summary file pasted into each prompt? Because context windows are finite and attention is not perfect. A project's full knowledge — structure, decisions, history, open questions — quickly exceeds what you can paste, and a single flat summary hides the relationships between things. Tools built for the job solve both problems: they hold far more than a context window can carry, and they let a session retrieve exactly the slice it needs instead of everything at once.
Graphify is the structural half of the tandem. It turns the codebase and its documents into a queryable knowledge graph: modules, functions, and concepts as nodes, their calls, imports, and dependencies as labelled edges. A new session can ask "what connects authentication to the database?" and receive a small, precise subgraph instead of re-reading hundreds of files. The command is local — the core code analysis runs entirely on your machine — and refreshing the graph after significant changes keeps the map true. Graphify is an external tool: TPEE itself never runs it and never calls any service, strictly offline as always.
Obsidian is the narrative half. It is a free, local-first Markdown note app: your notes are plain files you own, linked with wikilinks and browsable as a graph. This is where decisions, meeting notes, plans, and lessons learned live in human-readable form. Obsidian's value for project memory is that the knowledge is written in a durable, open format that both people and LLM sessions can read directly — no lock-in, no cloud, no account. Like Graphify, it runs entirely outside TPEE; the app never opens, syncs, or calls it.
The tandem works because the two halves answer different questions. Graphify answers "how is it built?" — structure, connections, and hot spots, kept fresh by re-running the extraction after changes. Obsidian answers "why is it this way and what happened?" — decisions with their reasons, session logs, and plans. The bridge between them is the export step: `graphify export obsidian` writes the graph as linked Markdown notes and a canvas inside your vault, so the machine-generated structure and your human notes sit side by side in one place a session can be pointed at.
The payoff shows up at the start of every session. Instead of a cold start, your opening prompt says: "the project lives at this path, the knowledge graph is at that folder, the project vault is here — read those first." Within seconds the session has an accurate, current picture: what the architecture is, what was decided, what remains open. That converts the most error-prone phase of a session (improvising a mental model of the project) into a cheap retrieval step.
There is a discipline cost, and it is worth paying. Memory systems only help if they are maintained: refresh the graph when the code changes, write the note when the decision is made, the same evening it happens. A stale memory system is worse than none, because the next session will trust it. The Toptronic® conventions handle this by making the updates part of the end-of-session routine — the same routine that produces the handover, which is the subject of the next lesson.
One rule to keep firmly in mind, as with every lesson about external tools: TPEE never connects to Graphify, Obsidian, or any other service. The app is strictly offline; you run these tools yourself, in your own environment, on your own files, and TPEE's role is limited to documenting and preparing the prompts and conventions that make the tandem effective.
Check yourself
Question 1: Why can't a large LLM session serve as the project's own memory?
- Because LLM sessions refuse to store text
- Because a session's knowledge ends when the session ends, context windows are finite, and attention over a huge pasted summary is unreliable — correct
- Because memory requires a paid subscription
- Because code files cannot be read twice
Answer: Because a session's knowledge ends when the session ends, context windows are finite, and attention over a huge pasted summary is unreliable
Session knowledge evaporates at the end; external memory holds more than a context window and lets a session retrieve exactly the slice it needs.
Question 2: How do Graphify and Obsidian divide the work in the recommended tandem?
- Graphify stores notes and Obsidian stores code
- Graphify answers "how is it built?" with a queryable knowledge graph; Obsidian answers "why is it this way and what happened?" with linked human-readable Markdown notes — correct
- Graphify works in the cloud and Obsidian works offline
- They are two names for the same tool
Answer: Graphify answers "how is it built?" with a queryable knowledge graph; Obsidian answers "why is it this way and what happened?" with linked human-readable Markdown notes
Graphify maps structure and connections; Obsidian holds decisions, plans, and history — and the graph export bridges the two inside one vault.
Question 3: What is TPEE's relationship to Graphify and Obsidian?
- TPEE runs Graphify in the background and syncs the vault automatically
- TPEE calls both tools through its built-in MCP server
- None: TPEE is strictly offline and never calls external services — you run Graphify and Obsidian yourself, outside the app — correct
- TPEE embeds a copy of Obsidian's editor
Answer: None: TPEE is strictly offline and never calls external services — you run Graphify and Obsidian yourself, outside the app
Both are external tools that run entirely outside TPEE; the app makes zero network calls and never invokes them — it only documents the prompts and conventions for using them.
← Previous lesson · All 91 lessons · Next lesson →
The full course — 91 lessons and 273 quiz questions — ships inside the app. Get TPEE to study it offline.