HumanDB remembers what matters across every conversation, recalls it with reproducible, model-free ranking, and refuses to fabricate. One SQLite file per user. No vector database to run.
$ pip install humandb
from humandb import HumanDB
db = HumanDB("memory.db") # one file. that's the database.
# remember across a whole conversation
db.add([
{"role": "user",
"content": "I'm Rayyan. My wife Zainab loves gardening."},
])
# recall, deterministically, with provenance
hits = db.recall("what does my wife enjoy?")
# -> [{ fact: "Zainab enjoys gardening",
# source: "msg_4f2a", score: 0.91 }]# the whole API is one route shape: /db/{space}/{op}
curl https://api.humandb.dev/db/rayyan/recall \
-H "Authorization: Bearer $HUMANDB_KEY" \
-d '{ "query": "what does my wife enjoy?" }'
# {
# "memories": [
# { "fact": "Zainab enjoys gardening",
# "subject": "Zainab",
# "source": "msg_4f2a",
# "score": 0.91 }
# ]
# }// drop HumanDB into any MCP client
{
"mcpServers": {
"humandb": {
"command": "npx",
"args": ["-y", "humandb-mcp"]
}
}
}
// tools your agent gets, out of the box:
// humandb_recall humandb_query
// humandb_push_event humandb_scheduleSpeaks HTTP and MCP, so it drops into any model or framework
It forgets what your user told it last week. Or worse, it confidently "remembers" something that was never true. Most memory tools paper over the first problem and quietly make the second one worse. HumanDB is built to do neither.
Context windows fall off. Vector recall returns whatever is nearest, even when nothing is actually relevant.
An LLM asked to "recall" will invent a plausible answer rather than admit the memory was never stored.
Six decisions that make HumanDB something you can put your name on in front of a customer.
Recall is math, not a model call. A reproducible fusion of keyword, lexical, and semantic ranking returns the same memories for the same query, every time. You can trace exactly why each one surfaced. No temperature, no surprises, no drift.
When the answer isn't in memory, HumanDB says so. It abstains on 90.6% of adversarial questions instead of inventing a reply.
Every user's memory is a single SQLite file. Nothing to provision, scale, or pay a second vendor for. Back it up with a copy command. Run it on a laptop or a Raspberry Pi.
Each memory links back to the exact message it came from. Nothing is a black box, and nothing is unaccountable. Show your users why their agent knows what it knows.
Facts change. HumanDB supersedes contradictions cleanly and keeps when each version was true, so "what did we know, and when" is always answerable.
Sharper recall on roughly 25% fewer context tokens, so the memory layer makes every model call cheaper instead of more expensive.
Knows that Zainab is the user's wife, merges duplicate people, and stays owner-agnostic. People, not just strings.
Per-agent read and write permissions, one-call forget-all, and private by default. The user owns the memory, not you.
One database per user or per workspace. Isolation is the file boundary, so a leak across tenants is structurally impossible.
Three moving parts, each one boring on purpose.
Send conversations or events. HumanDB extracts the durable facts, the people, and the relationships, and discards the small talk.
db.add(messages)Facts land in one bi-temporal SQLite graph, each tagged with its source and the moment it became true. Contradictions supersede, they don't pile up.
# entities · edges · validity · sourceAsk in plain language. Deterministic fused ranking returns the most relevant memories, with citations, on a tight token budget.
db.recall(query)A product that refuses to make things up should show its work. These are HumanDB's own numbers on LoCoMo, the long-conversation memory benchmark.
LoCoMo: 10 conversations, 400 QA pairs, fused retrieval, Claude Opus as answerer and judge. Open-domain (n=20) is a small, noisy slice. We publish the methodology so you can reproduce it.
No cluster to stand up. No embeddings pipeline to babysit. Install, point it at a file, and go.
pip install humandb.import { HumanDB } from "humandb";
const db = new HumanDB({ space: "rayyan" });
// before generating a reply, recall what matters
const memories = await db.recall(userMessage);
const reply = await llm.generate({
system: withMemory(memories), // sourced, ranked, small
messages,
});
// after, persist what's new (noise is dropped for you)
await db.add([...messages, reply]);from humandb import HumanDB
db = HumanDB(space="rayyan")
# recall before the reply
memories = db.recall(user_message)
reply = llm.generate(
system=with_memory(memories),
messages=messages,
)
# persist after
db.add(messages + [reply])A friend that actually remembers your life, not just your last message.
Recall a customer's history with provenance, and never invent a policy.
Remember the codebase, the conventions, and the decisions across sessions.
A shared, permissioned brain so agents learn from each other, not in silos.
A single file means private memory that never has to leave the device.
Tight token budgets and fast, deterministic recall keep latency low.
Self-host the open core and keep every byte on your own infrastructure, or let us run it for you. Either way, no memory is sold, sampled, or trained on. Privacy isn't a tier, it's the default.
Self-host the core for nothing. Pay only when you want us to run it.
Self-host the engine. The whole thing, on your infrastructure.
Managed HumanDB. We run, scale, and back up the memory for you.
For teams with their own infrastructure and their own rules.
Deterministic recall, provenance on every fact, and a refusal to make things up. Build with HumanDB today.