“The hardest commit I ever pushed wasn’t a feature. It was the one that said: done.”
I built Synapse to solve a problem I personally felt every single day.
AI agents forget. They forget what you told them yesterday. They forget the architecture decision you made last sprint. They forget the context that took you 20 minutes to explain — and next session, you explain it again. And again. And again.
So I built something to fix that.
Persistent memory. Knowledge graph. Semantic recall. 74 MCP tools. Local-first. Pure SQLite. Zero cloud.
I called it Synapse — after the biological synapse, the gap between neurons where memory actually happens. Felt right.
What I Actually Built 🔬
This wasn’t a weekend project.
Synapse was a full MCP server that gave AI agents a working long-term memory system. Not a simple key-value store. An actual knowledge graph with relationships, temporal awareness, and hybrid search — BM25 + vector + ripgrep — running entirely on SQLite.
No cloud. No third-party APIs. No data leaving your machine.
The architecture had three layers:
- Memory layer — stores facts, decisions, preferences, and project context across sessions
- Knowledge graph layer — maps relationships between entities so the AI understands how things connect, not just what they are
- Code search layer — semantic + keyword hybrid search so the agent could actually find relevant code in your project without you having to tell it where to look
I shipped it to npm as synapse-cortex. Wrote docs obsessively. Added a .clauderules and .cursorrules so Claude Code and Cursor could use it natively. Built a full test suite. Maintained a proper CHANGELOG.
I was proud of it. Genuinely.
Then I Rebranded It 😅
About three months in, I renamed it.
Synapse → Loci. After the Method of Loci — the ancient memory technique where you store information inside imagined locations and walk through them to recall. A memory palace.
It felt poetic. The concept fit perfectly. I rewrote the README. Updated the npm package. Made new docs.
And somewhere in that rebrand, I think I knew.
You don’t rename something twice when it’s going well. You rename it when you’re hoping a new identity fixes the problems the old one couldn’t.
The Honest Problems 🔍
Let me just say it clearly.
Problem 1: Setup friction was brutal.
Getting Synapse running required configuring the MCP server, wiring it into Claude or Cursor, setting up the SQLite paths correctly, and understanding how the tools mapped to actual memory operations. For developers already comfortable with MCP — fine. For anyone else — too much.
I knew this. I kept telling myself I’d fix it “in the next release.”
Problem 2: The knowledge graph was manual.
The memory system worked. But the knowledge graph — the relationships between entities — required explicit commands to build. The AI wouldn’t automatically connect “this function” to “this architectural decision.” You had to tell it to. That broke the promise of it feeling intelligent.
Problem 3: Schema migration didn’t exist.
Every time I changed the database schema — which happened a lot in early development — existing users’ data silently broke. No migration path. No warning. Just broken state that was hard to debug.
I patched this. Multiple times. But the underlying issue was that I’d built the schema fast, before fully understanding what the memory model needed to be. And that technical debt compounded.
Problem 4: The MCP ecosystem moved incredibly fast.
When I started building Synapse, the MCP tooling was young. By the time I had something stable, the ecosystem had shifted. New patterns emerged. New servers launched with better abstractions. What felt like a clear gap six months ago started filling up — and I was still solo, still maintaining, still finding new edge cases.
At some point I stopped asking “what should I build next?” and started asking “can I even keep up?”
The Decision 🧭
I didn’t wake up one morning and decide to kill it.
It was more like… I kept postponing the hard fixes. The schema migration. The automatic knowledge graph. The setup simplification. Every sprint they were on the list. Every sprint something more urgent pushed them down.
And then I looked at the list one day and realized — if I haven’t fixed these in six months, I’m not going to fix them. Not because I can’t. But because I’m one person, actively job hunting, writing, building other things. The time wasn’t there. And shipping a half-broken memory server to people who trust it with their project context isn’t fair to them.
So I made the call.
Active development on Synapse ends here.
What’s Staying 🗃️
The repo stays public. Forever.
If you want to study how to build a hybrid search system in SQLite — it’s there. If you want to see how MCP tool definitions map to a memory architecture — it’s there. If you want to fork it and take it somewhere I couldn’t — please do.
The npm package (synapse-cortex) stays up too. If you're using it and it's working for you — nothing changes today.
But I’m not shipping new features. I’m not fixing new bugs. The issues will stay open. The PRs will go unreviewed.
That’s the honest version of “archived.”
What I’m Taking With Me 📦
A lot, actually.
I understand persistent AI memory at a level I couldn’t have learned any other way. The knowledge graph design taught me how relational data models break down when you try to represent context instead of records. The SQLite architecture forced me to think carefully about query performance at a level Flutter databases never required.
And the hardest lesson — shipping something and maintaining it are two completely different skills. I’m a good builder. I’m a mediocre long-term solo maintainer. That’s useful self-knowledge.
Also: naming a project twice doesn’t save it from scope creep. Lesson logged. 😅
To Everyone Who Starred, Used, or Asked Questions 🙏
There weren’t many of you.
But the few developers who tried Synapse, asked questions in issues, sent feedback — that meant more than the star count suggests. You were early. You took a chance on something rough and unfinished because the idea made sense to you.
The idea was right. The execution just ran out of runway.
One Last Thing
I still believe the problem Synapse tried to solve is real.
AI agents should have persistent memory. They should build knowledge graphs of your project over time. They should get smarter the longer they work with you — not reset every session.
I just won’t be the one building that solution this time.
Maybe next time. Or maybe someone reading this will.
The repo is there. The architecture docs are there. The ideas are open source.
Go build something better. I mean that.
Synapse (2024–2026) → Rest easy. 🧠
Tags: Open Source, MCP, AI, Developer Life, Build In Public, Lessons Learned