Memoria - Because AI Has Amnesia
A personal memory layer that makes AI think like me, talk like me, and actually remember what I told it yesterday.
Side Project
May 2025
v1 → v2 Rebuild
Python, Postgres, pgvector, MCP
Building in Public
THE IDEA
What if there was one memory layer that sat above all models?
Not ChatGPT's memory. Not Claude's memory. My memory.
A unified context layer that knows who I am, what I'm working on, how I think, and how I communicate — then passes the right context to whatever model I'm using.
One brain. Multiple models. No fragmentation.
6
AI tools I use daily
1hr
Time wasted daily re-explaining context
1
Memory layer to rule them all
THE REAL PROBLEM
I use ChatGPT, Claude, Cursor, Perplexity, Figma AI, Lovable — sometimes all in the same day.
Each one has memory. ChatGPT remembers things. Claude remembers things. Cursor has context.
But none of them talk to each other.
My ChatGPT knows I'm Head of Product at Neoflo. My Claude doesn't. My Cursor has no idea what I discussed in Perplexity. Every tool is a silo. Every memory is fragmented.
It's not that AI forgets. It's that AI remembers in isolated pockets that never connect.
I did the math. I waste roughly one hour a day re-explaining context that already exists somewhere. That's 365 hours a year — repeating myself to tools that technically "remember", just not together.
WHY EXISTING AI MEMORY FALLS SHORT
Most AI tools treat memory as:
App-specific
Model-specific
Implicit
Opaque
There are no clear rules for:
What's worth remembering vs noise
How memory updates when things change
How contradictions are handled
How history is preserved
How much context should be injected back
Memory behaves like a chat log or vector dump, not a dependable system.
And because memory lives inside each product, switching tools means starting over.
May 2025 — MVP v1
Built the first working version. It had a chat UI, memory stored in a database, vector embeddings, semantic search, and context retrieval injected into prompts.
It worked. But the extraction was dumb.
Everything went into the database — no filtering, no lifecycle, no relevance scoring, no update logic. Memory got noisy fast: too much context, not enough signal, duplicates, contradictions, outdated facts showing up in responses.
The failure wasn't semantic search. The failure was lack of memory governance.
The "Build Everything from Scratch" Phase
My next instinct was to formalize it as a full product: custom UI, direct model API usage, bring-your-own API keys, database + embeddings, retrieval-augmented prompting.
In short: Memoria becomes the app.
This approach is valid — but flawed for this problem.
Why it wasn't ideal:
It becomes a platform build, not a memory problem. I'd spend time rebuilding chat UX, auth, model switching, cost controls — things ChatGPT, Claude, and Cursor already do well.
Embeddings don't solve memory correctness. Vector search helps retrieval, but it doesn't answer: what's worth saving? How do preferences update? How do time-based facts change? How do we prevent contradictions?
The real problem wasn't better retrieval. It was knowing what to store, how to update it, and when to forget it.
The Shift in Thinking
That's when the core realization clicked:
Memory is not an LLM problem. It's a systems and policy problem.
LLMs are great at understanding language. They are terrible at being consistent, auditable decision-makers.
So I stopped trying to make the model "smart about memory" and instead designed memory as infrastructure.
THE SOLUTION — MEMORIA v2
Memoria is now a personal AI memory layer, not an app.
It sits above models and tools. It does two things deliberately and separately:
1. Saving Memory Correctly
Memoria uses a governed memory pipeline.
LLMs propose meaning. Deterministic code decides policy.
The pipeline:
Semantic chunking — extract atomic, reusable memory candidates
Worthiness decisions — decide what deserves long-term memory
Normalization — canonical names, neutral tense, explicit facts
Deduplication — prevent repetition and contradiction
Update vs append rules:
Preferences → single source of truth
Decisions → immutable history
Time-varying facts (e.g. jobs) → timelines with validity windows
Metadata & lifecycle — importance, timestamps, expiry
Forgetting — outdated memory is hidden, not deleted
Memory stops being a log. It becomes small, explainable, and trustworthy.
2. Passing Context Intelligently
Saving memory is only half the problem. Using it correctly matters just as much.
Skills: Skills define how the AI should think and respond — tone, structure, reasoning style, communication preferences. They are persistent and behavioral, not data.
MCP (Model Context Protocol): MCP exposes memory as a universal interface — model-agnostic, pull-based, structured, portable across tools. Instead of injecting giant prompts, models query exactly what they need.
Retrieval discipline:
Strict limits (top 5–7 items)
Profile memory separated from task memory
Relevance > importance > recency ordering
The result: new chats already know me, switching models doesn't reset context, relevant background is pulled automatically, and the AI sounds like me.
It never asks "Can you give me more context?"
WHAT MEMORIA IS (AND ISN'T)
Memoria is:
A personal memory system
Model-agnostic
Explainable
Long-term stable
Boring by design (that's good)
Memoria is not:
A chat app
An LLM deciding what to remember
A vector dump
A journal
WHERE THIS IS GOING
Phase 1: Personal Memory (Now) Use my website and work as seed data. Build a memory that understands who I am, how I work, and how I think.
Phase 2: Agent Access Expose memory via API. Automations and agents don't start from zero — they query my memory layer and get instant context.
Phase 3: Public Chatbot A chatbot on my website that sounds like me, answers in my voice, understands my work and thinking, and can schedule calls or route conversations. Not a generic bot — a system backed by my memory.
THE END STATE
I become the API.
My knowledge, my preferences, my way of thinking — accessible to any system that needs it.
THE CORE INSIGHT
The hard part isn't storing memory.
It's knowing what to store, how to update it, and when to forget it.
Memoria exists to solve exactly that.
Building in public. Breaking things weekly.