Model Context Protocol · Interop
The same grounded, self-checking pipeline behind this app is exposed as an MCP tool. Any MCP-compatible client — a coding agent in your terminal, for instance — can store text and ask questions that are answered onlyfrom what was stored: with citations, or an honest “not enough evidence.”
Data ownership
Your memory lives in a store you own — not locked inside the model vendor. Every recall is cited, your keys are revocable, and you can self-host the whole engine so nothing ever leaves your machine.
Language models hallucinate, forget everything between sessions, and cite nothing. This turns retrieval into a memory that fixes exactly those failures: it answers only from stored material, traces every claim to its source, and refuses when the evidence is not there.
It is deliberately notanother “remembers your preferences” memory — that lane is crowded. This is a document / fact memory whose one differentiator is that it self-checks and abstains. A memory that does not make things up.
From zero to a working memory in five steps. You need an account and any MCP-capable client (Claude Code, Antigravity, Cursor, Windsurf, Cline, Claude Desktop, …). There is nothing to host or run yourself — the engine is already online.
Sign in or sign up on the web app. This is where your stored memory lives and where you manage access.
Open API Keys, click Generate, and copy your key. It begins with are_live_ and is shown only once, so paste it somewhere safe. Lost it? Revoke it and make a new one.
Put this block into your client’s MCP config, with your key in the RESEARCH_API_KEY field:
{
"mcpServers": {
"research-memory": {
"command": "npx",
"args": ["-y", "research-memory-mcp"],
"env": { "RESEARCH_API_KEY": "are_live_your_key_here" }
}
}
}Where that config lives, by client:
claude mcp add research-memory --env RESEARCH_API_KEY=are_live_your_key_here -- npx -y research-memory-mcp~/.gemini/config/mcp_config.json (or .agents/mcp_config.json for one workspace).Reload your client. It should now list three tools — ingest, retrieve, and ask. If it shows an auth error, the key is wrong or revoked; generate a fresh one.
You never call the tools by hand. Talk to your AI normally — “Remember: our launch is March 3rd.” then later “When’s our launch?” — and it picks the right tool for you. The exact shapes are in The tools below.
Honest note. The engine is hosted, so there is nothing to install or run yourself beyond that one config. Usage is rate-limited and tied to your key — this is a personal instrument, not an open public service.
You won’t type these by hand — when you talk to your AI, it calls the right one for you. This is the shape it sends, and what comes back.
ingest(text, source?)Store text so it can be recalled later.
textrequiredthe content you want to remembersourceoptionala label for where it is filed — reuse the same label to overwrite itTemplate
ingest({
"text": "<the content you want to remember>",
"source": "meeting-notes"
})Example
ingest({ text: "Project Falcon ships on March 3rd.", source: "roadmap" })
→ Stored under source "roadmap" (1 chunk, 1 embedded).Everything you store is private to your account — your key scopes it to only you. source is simply where it is filed, so related notes can share one label.
retrieve(query)Find the most relevant stored chunks — raw retrieval, with each chunk's source and timestamp. No answer synthesis.
queryrequiredwhat you are looking forTemplate
retrieve({
"query": "<what you are looking for>"
})Example
retrieve({ query: "Falcon ship date" })
→ [1] (source: roadmap · stored 2026-08-05)
Project Falcon ships on March 3rd.ask(query)Answer a question through the full self-checking pipeline: a cited answer, or a plain "not enough evidence" — never a guess.
queryrequiredyour questionTemplate
ask({
"query": "<your question>"
})Example
ask({ query: "When does Project Falcon ship?" })
→ Project Falcon ships on March 3rd. [DOC-1327]
Grounded in chunks: 1327
ask({ query: "Who is the CEO of Tesla?" })
→ Not enough evidence in the stored corpus to answer this.Anywhere an AI agent needs to recall facts from your own material — and cite them — instead of guessing. It stores and recalls text; it does not run it.
RFCs, runbooks, and design docs your agent answers from — with a source, not a guess.
Store your rules once; any agent recalls them with a citation, so it cannot hallucinate your standards.
Decisions and facts that outlive a single chat session, ready to recall next week.
Point an agent at your handbook so new context is a question away.
A corpus whose answers you can actually trust, because every claim is traced.
Save something in one client, recall it from another — the memory is yours, not the app’s.
The MCP server is a thin adapter, not a second implementation. Each tool forwards to the same internal endpoints the app itself uses. Chunking, embedding, encryption, ranking, and the self-correcting answer pipeline all live in one place — so a change to storage or verification takes effect in exactly one place.
One design decision worth calling out: the relevance gate judges a query by its form — is this a factual, information-seeking request? — and deliberately not by whether the topic sounds real. Deciding whether evidence exists is the job of the check that runs after retrieval, not the gate. The chart below shows the fix.
Where your data goes. Your memory sits in a store you control. At answer time it passes through model APIs — Anthropic and OpenAI, neither of which trains on your data. Self-host if you want nothing to leave your machine. Full data-flow →
The retrieval choices are backed by measurement, not intuition — a fixed question set scored across strategies, and index behaviour checked as the corpus grows.
Where it stands today
source; removing a whole document is done in the web app.On the roadmap
forget tool so the agent can remove memories, not just replace them.