Claude Code talks to a small MCP server on my machine. That server calls the Neruva API, which stores and searches everything. 25 memory tools in total.
The agent never touches a database. It calls MCP tools; the MCP server turns each call into an authenticated request to api.neruva.io, which runs on Google Cloud Run in us-central1.
An append-only log of typed events. Text is embedded on the server, so a record can be found by meaning or by exact filter. My main namespace holds 3,458 records across dozens of kinds.
agent_recall searches records and the knowledge graph together and returns a short block of the most relevant items, with their kind and date. agent_remember is the matching write.
Subject, relation, object. Good for things that should have one right answer, like where a project lives or who to ask about DNS. What I learned running it: keep the set of relations small and put the detail in the object.
Save the state of a namespace and restore it later. Run the same query against the same state and you get the same result, which makes it possible to go back and see what the agent knew when it made a call.
Records can be forgotten by kind, tag or time window. An entity can be removed from the graph in both directions, so nothing is left pointing at it.
The API does more than my daily routine needs. Each of these answers on api.neruva.io today (checked October 18, 2026).
Store any bytes and get back their SHA-256 as the address. The server checks the hash on write, so an agent can record exactly what it read and anyone holding the hash can fetch the same bytes later.
Named indexes with upsert, query, fetch, delete, export and import, in the same shape as common vector databases, for projects that want plain embedding search.
Index a codebase into the knowledge graph (functions, calls, imports) so an agent can look up how code connects before it edits. Python built in, JS and TS through @neruva/js-extractor.
Store past episodes and their outcomes, then ask which earlier case looks most like the current one. Useful for warning an agent before it repeats a known mistake.
Small structural causal models: define what drives what, then ask what changes if one factor changes.
Mask phone numbers, emails and similar details in text before it is stored.
Per-tenant log of operations, signed with an ed25519 key, so the record of what happened can be checked later.
neruva-record wires into Claude Code hooks: recall at session start, a short recall before each prompt, and automatic logging. Optional; my own setup uses the tools directly.
The client side is public. The server and its search and graph engines are not; you need an API key from me to use the hosted API.
On LongMemEval, a public test of long-term chat memory, Neruva recall scored 93.3% on a 30-question stratified sample, with Claude Sonnet answering and grading (May 2026). Thirty questions is a small sample, so read it as a sign that recall works, not as a ranking.
agent_remember, agent_recall, agent_context, agent_snapshot, agent_restore
records_ingest, records_query, records_get, records_timeline, records_stats, records_compact, records_export, records_import, records_forget, records_delete
hd_kg_add_facts, hd_kg_query, hd_kg_query_topk, hd_kg_neighbors, hd_kg_context, hd_kg_replace_fact, hd_kg_delete_fact, hd_kg_forget_entity, hd_kg_stats
neruva_op_stats
I am happy to walk through it live on my own projects.