donto.org / mcp agents.md · llms.txt · mcp.json

donto-memory — MCP server verified

Give any agent a bitemporal, evidence-first long-term memory. donto_recall · donto_search · donto_memorize over the Model Context Protocol.

What it is

donto-memory is an agentic long-term memory built on donto, a bitemporal, paraconsistent, evidence-first claim substrate. This MCP server exposes it as native tools so an agent (Codex, Claude Code, or any MCP client) can remember across sessions and recall what matters at query time — deciding for itself when to do so.

Bitemporal — every memory carries valid-time (when the fact was true), so recall can prefer the latest value of an attribute (knowledge updates) instead of stale ones.
Hybrid recall — lexical (full-text) + semantic (bge-small-en-v1.5, 384-dim) retrieval, RRF-fused, holder-scoped.
Evidence-first — recall returns anchored claims; when nothing is found, the honest answer is "I don't know," not a hallucination.
Zero-install — npx -y donto-memory-mcp and it's running; no clone, no setup. (A dependency-free single-file Python variant also ships in the repo.)

Install & register

Run it instantly with npx — no clone, no install. Defaults to the hosted endpoint https://memories.apexpots.com; point it at your own donto-memory with DONTO_MEMORY_URL.

Codex CLI

codex mcp add donto-memory -- npx -y donto-memory-mcp

Claude Code

claude mcp add donto-memory -- npx -y donto-memory-mcp

Generic MCP client (config)

{
  "mcpServers": {
    "donto-memory": {
      "command": "npx",
      "args": ["-y", "donto-memory-mcp"],
      "env": { "DONTO_MEMORY_URL": "http://127.0.0.1:7900" }
    }
  }
}

npm package donto-memory-mcp (Node, official MCP SDK) · stdio JSON-RPC 2.0 · protocol 2024-11-05. A dependency-free Python single-file variant (donto_mcp.py) is also in the repo.

Tools

`donto_recall`

Recall a holder's OWN memories relevant to a query (hybrid FTS + vector, holder-scoped). Use to answer questions about what a user/agent said, did, or prefers over time.

param	type	notes
`holder`	string (required)	memory owner IRI, e.g. `user:alice`, `agent:omega-bot`
`query`	string (required)	natural-language query
`limit`	integer	max rows (default 10)

Returns ranked rows: {subject, predicate, object, valid_from, valid_to}. Prefer the row with the latest valid_from when an attribute has several values.

`donto_search`

Substrate-wide full-text search across ALL of donto (not holder-scoped). Use to find any claim/fact in the store.

param	type	notes
`query`	string (required)
`context_prefix`	string	optional `ctx:` scope filter
`limit`	integer	default 10

`donto_memorize`

Store a memory for a holder. Extracts claims (extract=true) or stores raw episodic text (extract=false). Set valid_from to the date the fact became true.

param	type	notes
`holder`	string (required)
`text`	string (required)	the content to remember
`valid_from`	string	ISO date the fact became true (optional)
`extract`	boolean	extract claims (default true) vs raw episodic (false)

Agent documentation

Guidance an LLM agent should follow when using these tools (also machine-readable at /agents.md):

One holder per user/agent. Pick a stable IRI (user:<id> or agent:<name>) and reuse it for every memorize/recall for that subject. Recall is holder-scoped: you only see that holder's memories.
Recall before you answer any question that depends on past interactions ("what did I…", "my…", preferences, prior decisions, dates). Don't rely on the conversation window alone.
Memorize durable facts the user states about themselves, their world, decisions, or preferences — not transient chit-chat. Pass valid_from when the fact has a date.
Trust valid-time. If recall returns several values for one attribute, lead with the one whose valid_from is latest (it's the current truth); mention the prior value only if asked about history.
Be evidence-first. If recall returns nothing relevant, say you don't have it in memory — do not invent. You may widen with donto_search if a substrate-wide lookup is appropriate.
Keep queries natural. The hybrid retriever handles paraphrase semantically; you don't need keyword matching.

How it works

Each memorize writes claims/episodic chunks anchored to the holder, with valid-time. recall runs holder-scoped lexical + vector retrieval, RRF-fused, with predicate alignment-closure expansion, and returns ranked evidence-anchored rows. The substrate is paraconsistent: contradictory claims are held (not overwritten) and re-ranked by recency/reality — which is why knowledge-updates and honest abstention are first-class.

Tested

The protocol handshake and every tool are verified, and an agent (Codex gpt-5.4) was confirmed to call the tools and ground its answer in recalled memories:

# protocol
initialize            -> serverInfo {name: donto-memory, version: 0.1.0}
tools/list            -> [donto_recall, donto_search, donto_memorize]
tools/call recall     -> rows (isError: false)

# agentic (codex exec, gpt-5.4)
"call donto_recall(holder=…, query=…) then answer"
  -> codex invoked mcp_tool_call:donto_recall (x2)
  -> answer grounded ONLY in recalled memories  ✓

donto-memory itself is independently benchmarked on LongMemEval (faithful, no-cheating; codex reader + judge).

donto-memory MCP server · part of the donto substrate · server source: donto-memory/mcp/donto_mcp.py (private). Agent docs: /agents.md · /llms.txt.