Fully local memory for AI agents: zero-LLM ingest, semantic recall, air-gapped, auditable.
Model Context Protocol (MCP) Server: io.github.NORTHTEKDevs/genome
The io.github.NORTHTEKDevs/genome MCP server provides fully local memory for AI agents. It emphasizes zero-LLM ingest, semantic recall, and offline (air-gapped) operation, with an auditable record. It is presented as an alternative to Mem0, focused on retrieval and long-term agent memory.
🛠️ Key Features
Fully local memory for AI agents
Zero-LLM ingest
Semantic recall
Air-gapped/offline operation
Auditable record
Mem0-alternative positioning (as described)
🚀 Use Cases
Agent memory and retrieval workflows
Local-first, offline semantic recall
Benchmarking related to retrieval (topics include benchmarks and longmemeval)
RAG-related development (topic: rag)
⚡ Developer Benefits
Runs fully offline (air-gapped)
Auditable memory records
Semantic recall support for agents
Python-focused project (topic: python)
⚠️ Limitations
Only based on the provided excerpt; specific MCP tools, integrations, or configuration details are not included in the source data.
Most agent-memory tools (like Mem0) call an LLM on every message to decide what to
remember. That's the slow, expensive part - and GENOME's bet is that you don't need it.
GENOME just embeds each message locally: no LLM, no API, no network in the write path.
Benchmarked honestly on public datasets (LoCoMo, LongMemEval), GENOME answers just as
accurately as Mem0 - while storing memories for a tiny fraction of the cost and running
completely offline.
Honest up front: on answer accuracy, GENOME ties Mem0 - we do not claim to beat
it there (six independent benchmark configurations confirm parity, none significant in
either direction). The advantage is cost, speed, offline operation, and a
temporal/auditable record Mem0 can't produce.
The interesting part is step 3. The same question gets three different correct answers
depending on when you ask about, because the store keeps when each fact became true
rather than overwriting it:
Question
Answer
What was Priya's city in May 2023?
Boston [Mar 2023 - Jan 2024]
What was Priya's city in March 2024?
Seattle [Jan 2024 - Feb 2025]
What is Priya's city now?
Austin [Feb 2025 - present]
The "thinking about maybe moving to Denver, nothing decided" turn is stored but never
becomes an answer: it is a plan, not a durable fact.
How it works
The write path is deliberately dumb and cheap. All the intelligence happens at read time,
when there is a query to focus it.
flowchart LR
M["incoming message"] --> E["local embedder<br/>all-MiniLM-L6-v2"]
E --> S[("local store<br/>SQLite or Postgres")]
M -. "optional, opt-in" .-> B["belief extraction<br/>(the only LLM call)"]
B --> K[("bi-temporal<br/>fact log")]
Q["query"] --> R["exact cosine search<br/>over this tenant's rows"]
S --> R
R --> RR["optional cross-encoder<br/>rerank"]
RR --> A["context for the agent"]
Q --> PIT["as-of resolution<br/>facts_valid_at(entity, T)"]
K --> PIT
PIT --> A
style E fill:#0A84FF,color:#fff
style S fill:#1c2530,color:#fff
style K fill:#1c2530,color:#fff
style B fill:#3a3a3a,color:#fff
Write: embed locally, store. About 10 ms, zero LLM calls, zero network calls. The
embedding is deterministic -- the same text always yields the same vector, with no
sampled extraction step deciding what matters -- so what gets stored is a function
of the input, and replaying a journal reproduces that store exactly. (Ids and
timestamps are stamped per write, so two independent ingests of the same
conversation agree on content and vectors, not on record ids.)
Read: exact cosine search within the tenant's scope (no ANN index to build or update),
with an optional local cross-encoder reranker.
Bi-temporal layer (opt-in): records each fact at its domain time, the moment it became
true in the world, not the moment it was ingested. That is what makes point-in-time
questions answerable even when facts arrive out of order.
Why the record can be re-derived
flowchart TB
subgraph LLM["LLM-extraction memory"]
A1["message"] --> A2["LLM decides what matters<br/>(sampled, non-deterministic)"]
A2 --> A3[("store")]
A3 --> A4["replaying the same input<br/>can produce a different store"]
end
subgraph GEN["GENOME"]
B1["message"] --> B2["local embedding<br/>(deterministic)"]
B2 --> B3[("store")]
B3 --> B4["replaying the same input<br/>reproduces the same store"]
end
style A4 fill:#5c1f1f,color:#fff
style B4 fill:#1f4d33,color:#fff
A record that cannot be re-derived is difficult to audit. That property, not accuracy, is
the actual argument for this design.
Don't believe it? Prove it yourself
The cost, speed, and offline claims need no API key - measure them on your machine in 60 seconds:
The first run downloads the local embedding model (~90 MB, one time) before printing
anything, so expect 30-120 seconds of apparent silence on a cold machine. Every run after
that is instant.
It writes memories with your outbound network physically blocked and prints a live
pass/fail receipt - 0 network calls, 0 LLM calls, single-digit-ms writes, retrieval that works:
code
[PASS] Air-gapped write path: wrote 200 memories with every outbound socket blocked -> 0 network attempts, 0 LLM calls
[PASS] Write latency: 7.1 ms/message (Mem0's measured write path: ~2,055 ms + 1 LLM call/message)
[PASS] Retrieval works: top hit score 0.598
That receipt covers the cost/speed/offline story only. The accuracy-parity with Mem0 claim
is a separate, larger check that needs an LLM key - reproduce it head-to-head on the same
questions with your own key via python benchmarks/head_to_head.py (one OpenRouter key works;
see benchmarks/RESULTS.md for the n=90 / n=205 runs, the paired
significance tests, and the published nulls). The full test suite runs in public CI (badge
above). The pitch isn't "trust me" - it's "run it."
Add persistent memory to your agent in one line (MCP)
GENOME ships a fully-local MCP server - cross-session memory for Claude Desktop, Claude
Code, or Cursor with no API key and no data leaving your machine:
Or zero-install via uv: { "command": "uvx", "args": ["--from", "genome-memory[mcp]", "genome-mcp"] }
Tools the agent gets: remember, recall, forget, reset_memories.
Memories persist locally in ~/.genome/memories.db. Full MCP details ↓
GENOME vs Mem0 at a glance
GENOME
Mem0
Answer accuracy (LoCoMo, LongMemEval)
tied
tied
LLM calls to store one message
0
1+
Write speed
~10 ms
~2,000 ms
Runs offline / air-gapped
yes
no (needs an LLM API)
Ingest cost (10k-user deployment)
~$190 / yr
$159k-$1.6M / yr
"What was true in March?" (point-in-time)
yes
no
Deterministic, auditable memory
yes
no
Every number is measured within one harness - same responder, judge, embedder, and top-k;
only the memory layer changes - with paired significance tests. Full detail and per-number
provenance: benchmarks/RESULTS.md. Formatted report:
benchmarks/GENOME-LoCoMo-Report.pdf.
Why it's ~1,000× cheaper: it never calls an LLM to remember
Storing one message costs one LLM call in Mem0, zero in GENOME (just a local embedding).
That's not a benchmark you can argue with - it's arithmetic, and it holds no matter which
LLM you price it against. At 10,000 users × 50 messages/day (15M messages/month):
Model Mem0 uses to extract
Mem0's yearly ingest bill
GENOME
Claude Haiku
$1,601,757
$190
gpt-4o-mini
$238,596
$190
cheapest hosted model
$159,064
$190
The gap survives the cheapest model and grows in production (Mem0 re-sends stored memories
to the LLM as the store fills). Reproduce: python benchmarks/tco_project.py (no API key).
It runs air-gapped
GENOME's default embedder is local. We proved the write path is genuinely offline by
blocking all network during writes - they still succeed:
Mem0 can't do this - it needs an LLM API call to ingest.
That makes GENOME usable on-prem, in regulated environments, or fully offline. It's a yes/no
capability, not a price point.
How it works
Write: embed the message locally and store it. No LLM, no network. (~10 ms)
Read: vector search over your memories, with an optional local cross-encoder reranker
for harder queries.
Optional bi-temporal layer: track how facts change over time and answer "what was true
at time T" - see below.
What determinism buys you
Because nothing on the write path interprets your content, GENOME can do things an
LLM-ingest memory system cannot do in principle:
Memory firewall (genome.firewall): tag every write with where it came from
(user, agent, tool, web), quarantine low-trust origins from recall, and
enforce origin-bound authority - web content can never UPDATE or DELETE what your
user said, even when a prompt-injected conflict resolver asks for it. There is
also no extraction step for injected content to attack: the write path has no LLM.
python
from genome import Memory
from genome.firewall import TrustPolicy
m = Memory(trust_policy=TrustPolicy(recall_min_trust=1))
m.add("I live in Anchorage", user_id="u1", provenance="user")
m.add(scraped_page_text, user_id="u1", provenance="web") # quarantined
Explainable recall (genome.explain): explain_search() reports every
candidate's dense score, BM25 rank, fused score, and - when it was not returned -
the exact reason (parent-filtered, quarantined, beyond the limit). Two runs agree,
so a recall bug can be committed as a regression test instead of a shrug.
Journal + replay (genome.journal): record every mutation and provably
reproduce the store - verify_journal() replays the history and compares
canonical hashes. Replay a prefix to roll back; replay into different storage to
branch a memory for a what-if run. The journal sits after extraction, so replay
is deterministic even if you configured an LLM extractor. Each line chains to its
predecessor, so a removed or edited line is detected even when the change cancels
out in the final state.
python
# Tamper-EVIDENT by default. Pass a key (kept outside the journal's directory)# to make it tamper-PROOF: an unkeyed chain can be recomputed by anyone with# write access, an HMAC chain cannot.
m = Memory(journal="mem.journal", journal_key=os.environb[b"GENOME_JOURNAL_KEY"])
Multi-agent belief attribution (record_fact(..., believed_by="agent-a")):
agents sharing a store keep their own belief timelines - agent B disagreeing does
not clobber agent A's fact - and belief_conflicts() surfaces disagreements for
deliberate resolution instead of silently picking a winner.
A neutral benchmark harness (benchmarks/neutral/): run GENOME, Mem0, and a
full-context baseline through the same responder, judge, and embedder, with a
pairwise McNemar matrix and a full-disclosure block. GENOME is one row in the
table, not the house.
Install
bash
pip install genome-memory
The default embedder is local (sentence-transformers/all-MiniLM-L6-v2) - no API key,
works offline; the first run downloads the ~90 MB model once. OpenAI embeddings are
optional for higher-dimensional retrieval.
Dependency footprint, honestly: the core install is numpy, sentence-transformers,
scikit-learn, and rank-bm25. Local embeddings run on PyTorch (pulled in by
sentence-transformers), so it isn't a tiny install - that's the deliberate tradeoff for
offline, zero-cost embedding. Plotting/benchmark-chart deps live in an optional [viz]
extra, not the core. Migrating from Mem0? See
docs/migrating_from_mem0.md.
Quickstart (fully local, no API key)
python
from genome import Memory
mem = Memory(storage="genome.db") # local embedder by default; ":memory:" for ephemeral# Store a message -- embedded locally, no LLM call, no network
mem.add("Ada met Lin at the robotics summit in Berlin.", user_id="u1")
mem.add("They are collaborating on an open-source planning library.", user_id="u1")
# Retrieve the most relevant memoriesfor hit in mem.search("Where did Ada meet Lin?", user_id="u1", limit=5):
print(f"{hit.score:.3f}{hit.content}")
Memory mirrors Mem0's API (add / search / get / delete / reset) - a near
drop-in swap. To use OpenAI embeddings instead (set OPENAI_API_KEY):
python
from genome import Memory, EmbeddingProvider
mem = Memory(storage="genome.db",
embedding_provider=EmbeddingProvider(model_name="openai:text-embedding-3-small"))
Use it as an MCP server (fully-local memory for any agent)
GENOME ships an MCP server, so any MCP client (Claude Desktop, Claude Code, Cursor, ...) gets
persistent cross-session memory that runs entirely on the local machine - no LLM calls,
no API keys, no data leaves the box. Most memory MCPs can't say that.
Install with the mcp extra, then add it to your client's config:
Tools the agent gets: remember (store a fact/preference, local + 0 LLM), recall
(semantic search), forget (delete the memory matching a query), reset_memories
(clear a user's memories). Memories persist in ~/.genome/memories.db (override with the
GENOME_MCP_DB env var). Run standalone with genome-mcp or python -m genome.mcp.server.
Run it as an HTTP API
Prefer HTTP? GENOME ships a FastAPI server that mirrors the library 1:1 (add / search /
get / update / delete / reset / synthesize), with an auto-generated OpenAPI spec at
/docs.
bash
pip install "genome-memory[fastapi]"
Try it locally (keyless, loopback only - one flag makes the "no auth" intent explicit):
bash
GENOME_ALLOW_NO_AUTH=1 python -m genome.server # serves on 127.0.0.1:8080
bash
curl -X POST localhost:8080/v1/memories \
-H 'Content-Type: application/json' \
-d '{"text": "Ada met Lin at the robotics summit in Berlin.", "user_id": "u1"}'
curl -X POST localhost:8080/v1/search \
-H 'Content-Type: application/json' \
-d '{"query": "Where did Ada meet Lin?", "user_id": "u1", "limit": 5}'
Safe by default. The server refuses to serve unauthenticated unless you opt in as
above, and it will not bind a non-loopback interface without a key. To expose it, set an
API key (sent as X-API-Key) - required to bind beyond localhost:
bash
GENOME_API_KEY=$(openssl rand -hex 32) GENOME_HOST=0.0.0.0 python -m genome.server
# then add: -H "X-API-Key: $GENOME_API_KEY" to every request
For multi-tenant deployments, set GENOME_REQUIRE_SCOPE=1 to require user_id/agent_id on
every call and disable the global reset. Docker: docker-compose up (needs GENOME_API_KEY
and POSTGRES_PASSWORD; Postgres is published on loopback only). Full guide, including the
Postgres backend and every env var: docs/tutorial_quickstart.md.
TypeScript / JavaScript client
@northtek/genome-memory mirrors the
Python Memory API shape against this server (ESM, Node 20+ or browser):
bash
npm install @northtek/genome-memory
ts
import { Memory } from"@northtek/genome-memory";
const mem = newMemory({ baseUrl: "http://localhost:8080" });
await mem.add({ text: "Ada met Lin in Berlin.", userId: "u1" });
const hits = await mem.search({ query: "Where did Ada meet Lin?", userId: "u1" });
Hybrid (BM25 + dense) and graph retrieval: hybrid underperformed plain dense on LoCoMo;
graph was not validated here.
Reranking's accuracy gain is embedder-dependent: it reliably improves retrieval
hit-rate, but its effect on final answer accuracy depends on the embedder - treat it as a
retrieval-quality tool, not a guaranteed accuracy win.
Bi-temporal memory: "what was true at time T"
GENOME can track how facts change over time and answer point-in-time questions - something
overwrite-based memory structurally can't do (it only keeps the latest value):
python
from genome.memory.belief import ingest_belief_turn, answer_belief_context
mem = Memory(storage="genome.db", llm_call=my_llm_fn)
# facts land at their DOMAIN time (parsed from the text), not wall-clock ingest time
ingest_belief_turn(mem, "In March 2024, Jordan moved to Seattle.", session_time=t0, user_id="u")
ingest_belief_turn(mem, "Jordan just moved to Austin.", session_time=t2, user_id="u")
answer_belief_context(mem, "Where does Jordan live now?", user_id="u") # -> Austin
answer_belief_context(mem, "Where did Jordan live in early 2024?", user_id="u") # -> Seattle
answer_belief_context(mem, "List every city Jordan has lived in.", user_id="u") # -> Seattle; Austin
On the TempBelief benchmark it answers as-of queries at 0.870 vs Mem0's 0.676, with the
knowledge graph audited at 0.97 precision / 0.96 recall. Caveat: TempBelief is synthetic
text with explicit dates; the edge shrinks on natural speech. Real capability, bounded proof.
Optional features
Opt-in; the default path stays LLM-free and local at ingest.
python
mem = Memory(
storage="genome.db",
llm_call=my_llm_fn, # LLM-based fact extraction on add()
resolve_conflicts=True, # ADD/UPDATE/DELETE vs existing memories
auto_extract_entities=True, # entity graph for graph retrieval
auto_consolidate_threshold=200, # summarize-or-prune when a scope grows past N
)
mem.search("...", user_id="u1", mode="hybrid") # modes: "dense" (default), "hybrid", "graph"
Reranking (local, free, no API):
python
from genome.memory.rerank import CrossEncoderReranker
mem = Memory(storage="genome.db", reranker=CrossEncoderReranker()) # lazy-loaded
mem.search("Where did the user go on vacation?", user_id="u1", limit=5) # reranked
Reproduce the benchmarks
The LoCoMo and LongMemEval datasets are not bundled (they carry their own licenses -
LoCoMo is CC BY-NC 4.0). See benchmarks/data/README.md to
download them. The first two lines need no dataset and no API keys:
GENOME Enterprise is a separate commercial product for regulated and on-premise buyers
who have to answer to an auditor for what an AI system knew and when: a tamper-evident
hash-chained audit record, point-in-time reconstruction, compliance reports, retention with
erasure proofs, RBAC and SSO. Self-hosted and licensed per deployment - there is no hosted
version, deliberately, because the value is that your data never leaves. That tier is what
funds this one. Evaluating it, or want commercial support on the open core?
info@northtek.io
GENOME is free and open source: read it, modify it, self-host it, and embed it in your own
applications - commercial use included - under the terms of Apache 2.0. There is no
"open core bait and switch" planned: the core stays Apache-2.0.
The Apache-2.0 grant covers the code, not the name - see
TRADEMARKS.md, which leads with what you may do without asking.
Questions: info@northtek.io.
Copyright 2026 Northtek (FrostByte Digital LLC).
mcp-name: io.github.NORTHTEKDevs/genome