the open, user-sovereign memory layer for AI.
Memory has become the lock-in of the AI era. Every chatbot, every assistant, every agent now learns who you are — your preferences, your projects, your patterns — and stores it on servers you don't run, in schemas you can't read, locked to a product you might want to leave. mneme is the structural inverse: an open protocol for memory that lives on your device, encrypted with keys only you hold, and synced through whichever backend you trust.
We extract memories from real conversation transcripts, then check whether the right things were extracted. Two matchers run on every sample: a strict keyword check (does the extracted memory mention the expected facts?) and an independent LLM judge (does the extracted memory mean the same thing as the expected one?). Both numbers are reported every run.
Against Mem0 v3.0.3 — the open-source memory system most often cited as state of the art — we tie on semantic F1 and dominate on strict F1 by 53.9 points. The semantic tie means we extract roughly the same underlying facts. The strict gap is structural: Mem0 paraphrases inputs into its own canonical form; mneme preserves the user's source language.
| metric | method | mneme | Mem0 v3.0.3 | Δ |
|---|---|---|---|---|
| semantic F1 | LLM judge | 78.1% | 78.5% | tied |
| strict F1 | keyword match | 62.4% | 8.5% | +53.9 pts |
Every surfaced memory traces back to what was actually said. The user can inspect the source line in their own store, with cryptographic provenance.
Compliance teams can verify the encrypted store against the original transcript. Paraphrased canonical forms break that chain.
Strict keyword matching is deterministic. Semantic similarity drifts as judge models improve — useful, but not load-bearing for a regression test.
Every existing memory system — Mem0, Letta, Zep, ChatGPT Memory, Claude Projects — chose the same model: your data on their servers, in their schema, available only inside their product. mneme is the structural inverse. Six principles, in order of how much they constrain every decision.
The store is a SQLite file on your machine. Sealed on disk with AES-256-GCM, signed with Ed25519, queryable in milliseconds. No round trip to a server for a single recall. No subpoena risk we can satisfy in plaintext — we never have it in plaintext.
Master keys derive from your passphrase via Argon2id — slow on purpose. A 24-word BIP-39 phrase recovers the same store if the passphrase is lost. The server, when there is one, sees only encrypted envelopes.
remember, recall, forget, supersede, export, sync. Five verbs and a schema. Anyone can implement it — Python next, then Go, then Rust. Conformance tests in the same repo as the reference SDK.
The MCP server ships today; HTTP and SSE adapters follow. The same protocol speaks to every host — no model-specific schema, no provider lock-in.
One verb to export the whole file. The format is the same one we use internally — no proprietary wrapper. If a better memory system ships tomorrow, copy your file there. Our advantage is quality and neutrality, not friction.
Postgres. SQLite. Bun. tsdown. Apache 2.0. Tested against real backends, not mocks. The novelty budget goes to the genuinely hard problems — encrypted semantic retrieval, CRDT sync across devices, cross-provider portability. The rest is meant to be unremarkable.
A cross-section, top to bottom. The app surface is where users see memory; the protocol is what apps speak; the encryption layer is where keys do their work; the store is the single SQLite file on your device. The server, when there is one, never holds plaintext.
The server is just another SyncPeer. WebSocket ships today (LAN-only, no auth); HTTP+JSON with bearer-token auth ships with Mneme Cloud in v0.2. Self-host the same code if you'd rather. The boundary between you and us is encryption, not trust.
$ bun add @mnemehq/sdk
$ bun add @mnemehq/embedder-local # optional, on-device search
$ bun add @mnemehq/sync-websocket # optional, multi-device$ claude mcp add mneme -- npx -y @mnemehq/mcp-serverimport { Mneme } from '@mnemehq/sdk'
import { LocalEmbedder } from '@mnemehq/embedder-local'
const { mneme, recoveryPhrase } =await Mneme.initialize({
path: './mneme.sqlite',
passphrase: 'correct horse battery staple',
embedder: new LocalEmbedder(),
})
// body sealed AES-256-GCM, signed Ed25519
await mneme.remember({
kind: 'preference',
body: 'Prefers concise code review comments',
})
const matches = await mneme.recall('feedback style on pull requests')
for (const { record, score } of matches) {
console.log(score.toFixed(2), record.kind, '—', record.body.data)
}Mem0 helps agents remember users.
mneme helps users own their memory.