Every new Claude Code terminal opens with amnesia unless you wire persistent memory outside the prompt window. You end up paying twice: once in tokens burned re-reading the same core files, and again in mental energy re-explaining architectural constraints after every /compact cycle.
Three open-source memory architectures now dominate the Claude Code ecosystem: Obsidian Markdown wikis, Graphify AST knowledge graphs, and local SQLite FTS5/WAL memory servers. Each solves a completely different retrieval bottleneck, yet most guides mash them together under vague “infinite context” slogans.
Here is the real architectural breakdown, the verified public benchmarks alongside their actual methodology caveats, and the exact setup pattern for pairing them without creating a stale-cache mess.
In this article
- Why 200k Context Windows Still Break Without Memory
- Architecture Breakdown: Obsidian vs Graphify vs SQLite
- Attributed Benchmark Numbers and Methodology Caveats
- Setup Pattern: SQLite WAL Memory for Multi-Session Teams
- The Hybrid Stack: Pairing AST Graphs, Vault Notes, and SQLite
- Failure Modes That Corrupt Agent Memory Over Time
- Architecture Decision Matrix and Weekly Rollout Plan
1.Why 200k Context Windows Still Break Without Memory
A 200,000-token context window looks huge until you watch an active coding session degrade halfway through a sprint. When an agent dumps dozens of raw source files, terminal logs, and stack traces into one rolling buffer, attention spreads thin over irrelevant boilerplate and critical invariants quietly slip out during auto-compaction.
Even before you hit a rate limit, repeating discovery work across separate worktrees drains your quota fast. In our earlier breakdown on how to stop hitting your Claude limit, session restarts proved to be one of the steepest hidden token multipliers—every cold start forces grep loops across config files, database models, and deployment notes that already sat in yesterday’s terminal.
External memory splits state into two jobs:
- Live scratchpad: Keep only active diffs, current test failures, and open tasks inside the rolling session context window.
- Persistent index: Store symbol relationships, architectural decisions (ADRs), and solved edge cases locally on disk so Claude fetches narrow slices on demand instead of ingesting whole folders.
Treat persistent memory as a structured lookup index rather than a passive trash bin of old chat transcripts, and even multi-week refactors keep their speed from turn one.
2.Architecture Breakdown: Obsidian vs Graphify vs SQLite
Picking a memory tool blindly leads to frustration when your actual bottleneck sits in another layer. An Obsidian Markdown vault excels at human-readable architecture specs, whereas Graphify builds deterministic symbol maps from source syntax, and SQLite manages fast concurrent tool logs across multiple agent terminals.
| Architecture | Representative Tools (Nov 2026) | Storage & Retrieval Engine | Build Token Cost | Multi-Session Concurrency | Best Fit |
|---|---|---|---|---|---|
| AST Knowledge Graph | Graphify-Labs/graphify (148.8k stars) |
Tree-sitter AST (~40 langs) + Leiden clusters in graph.json |
0 LLM tokens (default AST mode) |
Static artifact; rebuild via hooks or graphify update |
Navigating cross-file calls, imports, and god nodes |
| Markdown LLM Wiki | AgriciDaniel/claude-obsidian (16.5k stars) |
Plain local .md notes + [[wikilinks]] + local BM25 + SHA-256 lock |
Uses LLM turns during ingest/lint | Optimistic lock guards local agents; external editors skip lock | Human-editable decisions, specs, PKM, and project wikis |
| SQLite Hook & MCP Memory | thedotmack/claude-mem (117.6k stars), sqlite-memory-mcp, memcp |
SQLite WAL + FTS5 BM25 + optional Chroma or sqlite-vec vectors |
Background observer model or zero-LLM SQL writes | High (10+ concurrent sessions under WAL mode) |
Cross-session bugfixes, tool timelines, RLM variable storage |

Notice the fundamental contrast in how Graphify handles code versus how Obsidian or SQLite handle team knowledge. Graphify parses source code locally via tree-sitter without sending your codebase to an LLM, tagging every edge explicitly as EXTRACTED (explicit import/call syntax) or INFERRED (resolved cross-file reference). That confidence label matters because you can inspect graphify path or GRAPH_REPORT.md knowing the weakest hop in a trace.
Obsidian-based systems like claude-obsidian follow Andrej Karpathy’s LLM Wiki pattern instead: plain Markdown files stay legible to humans, version cleanly in Git, and preserve nuance that code ASTs never capture—such as why a billing webhook intentionally avoids an upstream retry queue.
Install the Graphify CLI cleanly with the official PyPI package name (graphifyy, spelled with a double y) before running any workspace extraction command:
Bash
uv tool install graphifyy
graphify install --platform claude
Wait for graphify install to write ~/.claude/skills/graphify/SKILL.md before calling /graphify . inside an active Claude Code session. Keeping structural code mapping separate from prose docs ensures neither database bloats with noise from the other.
3.Attributed Benchmark Numbers and Methodology Caveats
Viral screenshots claiming “500x fewer tokens” almost always hide what the baseline actually measured. Before wiring a memory layer into your production setup, check published benchmark numbers directly against each repository’s declared evaluation suite so you budget tokens realistically.
| Source & Benchmark Suite | Metric Measured | Reported Memory Result | Baseline Compared Against | Key Methodology Caveat |
|---|---|---|---|---|
Graphify (BENCHMARKS.md, LOCOMO n=300) |
recall@10 / QA accuracy |
0.497 recall@10 / 45.3% QA |
mem0 (0.048), supermemory (0.149 / 49.7% QA) |
Blind-judge scoring (0.81 Cohen’s kappa); strong structural recall, trails specialized cloud memory slightly on raw LOCOMO QA |
Graphify (LongMemEval-S n=50) |
QA accuracy | 76% |
Tied with dense vector RAG | Shows graph traversal matches dense embeddings on conversational QA without standing up a vector index |
Graphify (ERPNext cross-tool n=6) |
Key-fact coverage | 82.0% (0 AST build credits) |
70.8% grep/read baseline |
Small sample (n=6), though directly models multi-file repository discovery tasks |
MemCP (benchmark_report.md, SQLite RLM) |
Token load on 50K doc / 50 insights | 231 tokens (50K doc) / 167 tokens (50 insights) |
50,460 tokens / 896 tokens native dump |
Repository explicitly notes native baseline models worst-case full-context stuffing, whereas real Claude Code uses targeted Read/Grep |
Obsidian + Graphify (claude-code-memory-setup) |
Historical query ratio (~280 vs ~20,000 tokens) |
71.4x per lookup (499x extreme claim) |
Full raw source loading | Author-reported README caveat confirms historical 71.5x and 499x ratios reflect selective snippet lookups rather than whole-session savings |
When readers ask whether external memory magically cuts monthly Claude API bills by 98%, the answer is clear from those footnotes: per-lookup snippet savings do not equal whole-session savings. System prompts, tool responses, test runner logs, and multi-file edits still consume context tokens during active engineering work.
What Graphify, memcp, and claude-obsidian consistently achieve in verified tests is higher key-fact recall (82.0% vs 70.8% grep baseline on ERPNext, 92% cross-session recall vs 0% cold-start native reload in MemCP) while stopping unnecessary cold-start re-reads across restarts. You can see our deeper walkthrough on configuring Graphify + Obsidian side by side in the ultimate Claude Code setup.
4.Setup Pattern: SQLite WAL Memory for Multi-Session Teams
Running two or three parallel git worktrees inside Claude Code exposes the first fatal flaw of naive JSON or basic SQLite wrappers: file-locking collisions. Once a second agent writes an observation while the first searches history, uncoordinated stores drop writes or raise database is locked exceptions.

Modern SQLite memory servers eliminate lock contention using Write-Ahead Logging (WAL) paired with built-in FTS5 BM25 full-text search. Claude-Mem (v15.19.0) wires automatic lifecycle hooks via a background worker into ~/.claude-mem, priming each new session with a three-layer progressive index (compact catalog -> timeline -> full observation details) rather than dumping prose blobs at startup. Meanwhile, lightweight pure-Python MCP alternatives like sqlite-memory-mcp run directly on stdlib sqlite3 under WAL concurrency for 10+ simultaneous sessions and support optional sqlite-vec hybrid Reciprocal Rank Fusion (RRF) ranking alongside deterministic SQL reflect_audit consolidation—requiring zero background LLM calls to dedupe old rows.
To add persistent SQLite hook capture across every Claude Code project in one step, run the official interactive installer (avoid bare npm install -g claude-mem, which only drops the SDK library without hooks):
npx claude-mem install
Follow the terminal prompt to choose your storage provider mode (use non-interactive or local flags if you want observations kept strictly off external observers), restart Claude Code, and wrap any sensitive local credentials or .env blocks in <private> tags so the hook worker skips persisting them.
If you prefer MCP-driven memory with explicit recall and document chunking (memcp) instead of automatic lifecycle hooks, pair this lightweight recall check in your session prompt after launching your server:
Keeping startup retrieval pinned to critical constraints prevents token bloat on trivial bugfixes while still preserving multi-session memory. Explore the full Claude Code hub if you want prebuilt starter workflows covering skills, hooks, and terminal configs alongside your memory layer.
5.The Hybrid Stack: Pairing AST Graphs, Vault Notes, and SQLite
No single backend dominates every memory workload. Code call graphs change on git commits and deserve deterministic AST updates; human product trade-offs evolve weekly and belong in readable Markdown; ephemeral session breadcrumbs and tool diagnostics change every minute and fit naturally inside indexed SQLite rows.
Teams shipping complex codebases get the cleanest reliability by dividing responsibilities strictly across three layers instead of duplicating project lore across three competing tools:
- Structural Code Layer (Graphify): Parse application code locally with tree-sitter (
graphify-out/graph.json) so Claude resolves imports, class inheritance, and high-degree god nodes in zero build tokens. - Architectural Wiki Layer (Obsidian /
claude-obsidian): Store human-approved ADRs, API quirks, design rationales, and stakeholder constraints as[[wikilink]]-connected Markdown notes. - Ephemeral Session & Log Layer (SQLite WAL /
claude-memorsqlite-memory-mcp): Record resolved stack traces, session snapshots, and active task states via FTS5 BM25 retrieval.
Enforce that routing order inside your project’s root CLAUDE.md so the agent knows which tier to check first rather than scanning your entire disk blindly:
## Memory Lookup Order
1. Structural code questions -> query `graphify-out/graph.json` or `GRAPH_REPORT.md` first. Do not manually edit files inside `graphify-out/`.
2. Product specs, ADRs, and vendor caveats -> inspect linked Markdown notes inside `docs/wiki/` via `[[wikilinks]]`.
3. Cross-session bugfixes and recent command outcomes -> query your active SQLite MCP / `claude-mem` index by project tag.
Separating lookup paths takes five minutes to standardize in CLAUDE.md, prevents Graphify AST rebuilds from overwriting handwritten ADRs, and stops SQLite logs from accumulating thousand-line dumps of static helper code. Ready-made prompt packs and CLAUDE.md boilerplate templates are also organized inside the Artimind workflow shop if you want pre-tested team starters.
6.Failure Modes That Corrupt Agent Memory Over Time
Unmaintained agent memory rots faster than unmaintained documentation. Unlike human wikis, an AI coding assistant treats stale retrieved notes as high-confidence truth and builds buggy abstractions on top of deprecated endpoints or renamed helper functions.
Watch for four concrete failure modes across Obsidian, Graphify, and SQLite setups—and lock down their defenses on day one:
- Silent AST Staleness (Graphify): If you build
graph.jsononce and never refresh it after refactors,graphify pathwill point Claude to deleted modules. Fix this immediately by runninggraphify hook install(which rebuilds delta changes on git commits) or runninggraphify update .before major feature sprints. - External Sync Write Collisions (Obsidian): Tools like
claude-obsidianverify SHA-256 note fingerprints before writing, which stops concurrent agent races locally, yet iCloud Drive, Obsidian Sync, or external editors do not share that lock. Always commit vault notes to Git on a short cadence so conflict copies are trivial to merge. - Credential Leaks Inside Observation Logs (SQLite): Hook-based recorders watch shell output and tool results continuously, risking API keys or bearer tokens entering
~/.claude-memSQLite rows. Use<private>delimiters during sensitive terminal steps, or opt for servers likememcpthat enforce built-in regex secret blocking before persistence. - Chroma & Vector Bloat on Modest Hardware: Adding heavy neural embedding pipelines on top of small personal repositories introduces Python dependency breakage and slow startup indexing. Start with SQLite’s zero-dependency FTS5 BM25 keyword search first, and only enable
sqlite-vecsemantic fusion once exact symbol queries stop finding conceptual notes.
Pruning dead observations and stale graph caches once a month keeps recall precision sharp without requiring heavyweight enterprise vector clusters.
7.Architecture Decision Matrix and Weekly Rollout Plan
You do not need to deploy all three systems on Monday morning. Start with the architecture that solves the exact friction slowing down your active repositories right now, verify retrieval quality on real tasks, and layer a second backend only when the gap shows up in daily logs.
| Developer Profile & Repo Size | Recommended Day-One Stack | Why This Stack Wins | Suggested Rollout Step |
|---|---|---|---|
| Solo Creator / Micro-SaaS (<50 files) | Obsidian + CLAUDE.md |
Plain .md notes, zero background daemons, complete human visibility |
Adopt claude-obsidian (wiki-mode) and enforce 2+ [[wikilinks]] per ADR |
| Multi-Worktree Active Sprint | SQLite WAL (claude-mem or sqlite-memory-mcp) |
Eliminates lock errors across parallel terminals; low-latency FTS5 recall | Run npx claude-mem install and pin <private> redaction rules |
| Monorepo / Cross-Module Refactor | Graphify + Obsidian Vault | Zero-LLM tree-sitter AST finds god nodes while Markdown preserves specs | Install graphifyy, run /graphify ., and enable graphify hook install |
| Team / Multi-Agent Engineering Pipeline | 3-Layer Hybrid (Graphify + Obsidian + SQLite WAL) | Strict separation of code topology, human ADRs, and session timelines | Copy the 3-step CLAUDE.md routing order and schedule monthly wiki-lint |
7.1Frequently Asked Questions
Does Graphify upload my proprietary source code to external LLMs?
No—Graphify’s default code pass parses source files 100% locally via tree-sitter ASTs across roughly 40 languages with zero LLM tokens or network calls. External backends only trigger if you explicitly request semantic passes over PDFs, diagrams, or unstructured docs.
Why did my SQLite MCP tool fail with file locks across parallel terminals?
Standard JSON stores or default rollback-journal SQLite modes lock the entire file during writes. Choose a server explicitly configured with SQLite Write-Ahead Logging (WAL), such as sqlite-memory-mcp or claude-mem, whenever two or more sessions read and write concurrently.
Can I switch memory tools without losing past engineering decisions?
Yes—keep durable architectural decisions in plain local Markdown inside your repo or Obsidian vault, and treat SQLite caches and graphify-out/ artifacts as disposable, rebuildable indexes. Markdown specs survive every IDE or model migration untouched.


