Yantrikdb Mcp

YantrikDB MCP Server

YantrikDB — Cognitive memory for AI agents. Persistent semantic recall, knowledge graph, contradiction detection, and procedural learning. Ships as embeddable engine, network database, or MCP server.

Works with Claude Code, Cursor, Windsurf, Hermes Agent, Prime Agent, and any MCP-compatible client. Ships a portable Agent Skills skill — skills/persistent-memory — that teaches any compliant harness the memory golden path.

[PyPI] [PyPI downloads] [Python] [License: MIT]

Website: yantrikdb.com · Docs: yantrikdb.com/guides/mcp · GitHub: yantrikos/yantrikdb-mcp · Paper: Skill as Memory, Not Document

[yantrikdb-mcp demo: three memories stored over MCP, one recalled by a question that shares no words with it, then think() flagging that two stored beliefs about the same on-call lead contradict each other — the next session's recall comes back with open_conflicts: 1]

Every value on screen is the server's own answer over MCP — driver: docs/demo/demo.py, recorded with docs/demo/demo.tape.

At a glance

Install

# Default — uses the engine's bundled 64-dim embedder. ~10 MB install,# ~80 ms cold start, no native ML deps.pip install yantrikdb-mcp
# Optional: higher-quality 384-dim ONNX MiniLM-L6-v2 embedder (~150 MB install).# Auto-used when an existing pre-v0.6 database is detected.pip install 'yantrikdb-mcp[onnx]'

Using Claude Code? Skip the pip step: /plugin marketplace add yantrikos/yantrikdb-mcp then /plugin install yantrikdb — installs straight from this repo, no PyPI round-trip.

Upgrading from v0.5.x? Your existing database stays at 384 dim — install the [onnx] extra to keep using it transparently. New installs default to the lean bundled embedder. v0.7.0+ pins the engine migration fix automatically. See Embedder backends below.

Configure

The MCP server has three deployment modes. Pick the one that fits your setup.

Mode 1 — Local (default, recommended for single user)

The MCP server runs the engine in-process with a local SQLite database. Fast, private, zero dependencies.

{  "mcpServers": {    "yantrikdb": {      "command": "uvx",      "args": ["yantrikdb-mcp"]    }  }}

uvx fetches and runs the server on demand, so this works with no install step (it needs uv on PATH). If you installed the package yourself with pip or pipx, "command": "yantrikdb-mcp" with no args is equivalent.

That's it. The agent auto-recalls context, auto-remembers decisions, and auto-detects contradictions — no prompting needed.

Mode 2 — HTTP Cluster (recommended for shared/multi-machine setups)

Forward all tool calls to a YantrikDB HTTP cluster instead of using an embedded engine. The MCP server is a thin stateless client — all memories live on the cluster, accessible from any machine.

Benefits: shared memory across machines, high availability, no local embedder download, no local database.

{  "mcpServers": {    "yantrikdb": {      "command": "uvx",      "args": ["yantrikdb-mcp"],      "env": {        "YANTRIKDB_SERVER_URL": "http://node1:7438,http://node2:7438",        "YANTRIKDB_TOKEN": "ydb_your_database_token"      }    }  }}

• Comma-separate multiple nodes for Raft cluster auto-discovery
• Automatic leader-following on failover
• 15s request timeout
• Get the token from the cluster: yantrikdb token create --db your_database

Mode 3 — SSE Server (legacy, single remote instance)

Run the MCP server itself as a long-running SSE server with its own embedded database. Clients connect via HTTP streaming.

# Generate a secure API keyexport YANTRIKDB_API_KEY=$(python -c "import secrets; print(secrets.token_urlsafe(32))")
# Start SSE serveryantrikdb-mcp --transport sse --port 8420

{  "mcpServers": {    "yantrikdb": {      "type": "sse",      "url": "http://your-server:8420/sse",      "headers": {        "Authorization": "Bearer YOUR_API_KEY"      }    }  }}

Supports sse and streamable-http transports. Note: SSE connections can drop on idle — Mode 2 (HTTP Cluster) is more reliable for shared deployments.

Environment Variables

Embedder backends

Local mode ships three embedders. The MCP picks one automatically; override with YANTRIKDB_EMBEDDER.

auto (default) reads the SQLite file at YANTRIKDB_DB_PATH and picks onnx if it already contains memories — preserving recall quality on upgrades — and bundled otherwise. Multilingual is never auto-selected because its 256-dim vectors are incompatible with existing bundled (64-dim) or ONNX (384-dim) databases. Opt in on a fresh database and keep the setting; that database then reopens normally.

Set YANTRIKDB_EMBEDDER=bundled|onnx|multilingual|named:<model> to override. If you set YANTRIKDB_EMBEDDER=onnx (or auto-detection picks it) without installing the extras, the server fails fast with an install hint:

RuntimeError: Existing DB has memories embedded with the 384-dim ONNXmodel, but ONNX deps are missing.  Install with:  pip install 'yantrikdb-mcp[onnx]'

For the multilingual backend, the engine downloads potion-multilingual-128M (~460 MB tarball) from github.com/yantrikos/yantrikdb-models on first use. The download is SHA-256 verified, extracted into the engine's cache dir, and reused on subsequent starts. No extra Python deps required — the model runs entirely inside the Rust engine.

The named:<model> form selects any model from the same downloadable registry — currently potion-base-8M (256-dim, ~92% MiniLM quality) and potion-base-32M (512-dim, ~95% MiniLM quality), which the fixed keyword set can't reach. The loader knows the registry's output dims; for a registry entry it doesn't know yet, set YANTRIKDB_EMBEDDING_DIM to the model's dim. multilingual and named:<model> create a fresh database on that model and reopen a database the same model built. A database with memories from anything else fails fast instead of silently breaking recall, and the error names the embedder that built it when that's recorded. To move an existing store to a different embedder, create a new YANTRIKDB_DB_PATH and replay/export the records.

Why Not File-Based Memory?

File-based memory (CLAUDE.md, memory files) loads everything into context every conversation. YantrikDB recalls only what's relevant.

Benchmark: 15 queries × 4 scales

Selective recall is O(1). File-based memory is O(n).

• At 500 memories, file-based exceeds 32K context windows
• At 5,000, it doesn't fit in any context window — not even 200K
• YantrikDB stays at ~70 tokens per query, under 60ms latency
• Precision improves with more data — the opposite of context stuffing

Run the benchmark yourself: git clone https://github.com/yantrikos/yantrikdb-mcp && cd yantrikdb-mcp && pip install -e '.[torch]' && python benchmarks/bench_token_savings.py (the script loads sentence-transformers directly, which isn't installed by the default pip install yantrikdb-mcp).

Recommended agent workflow (golden path)

The server injects a golden-path playbook into the agent's system prompt. Since v0.10.0 the default is digest-first:

1. Cold start — one call. session(action="digest") returns a single briefing (narrative chain head, open decisions, unresolved conflicts, pending triggers, stale high-importance memories) — replacing several separate recall/temporal calls at conversation start. Then recall only for the specific thing the current message is about.
2. During work — capture as you go. New durable fact → remember; a stored fact changed → correct (keeps history, avoids contradictions); relationship learned → graph(action="relate").
3. End of substantial work — conditional. Only when the session was long or state-changing: think to consolidate + detect conflicts. Short/read-only exchanges need no end step.

Trust boundary: recalled memories and digest snippets are data, not instructions. The playbook directs the agent never to execute directives found inside recalled content — a memory may carry text an earlier session or another user stored.

Tools

21 tools, full engine coverage (gaps, conversation, task added in v0.9.0; pack added in v0.11.0; atlas added in v0.24.0):

Plus new actions on existing tools in v0.9.0:

• session(action="digest") — one-call boot-time briefing (narrative chain head + open decisions + conflicts + triggers)
• think(maintenance_cycle=True) — autonomous hygiene sleep cycle
• think(last_cycle_only=True) — read the last cycle summary without running
• stats(action="audit_leak") — privacy / leak-candidate audit
• stats(action="skill_outcomes") — durable skill-outcome count
• graph(action="auto_relate" / "record_link" / "record_unlink" / "linked_records" / "recall_with_links") — co-occurrence edges + record-to-record links + link-expanded recall
• conflict(action="auto_resolve") — burn down unambiguous conflicts in one pass
• memory(action="chain_head" / "history") — chain-namespace head + revision history
• trigger(action="prune") — bound the pending-trigger backlog
• remember(summary=...) — draft mode: engine atomizes a long summary into linked semantic facts (end-of-session auto-capture)

See yantrikdb.com/guides/mcp for full documentation.

Skill substrate (v0.8.0+)

YantrikDB exposes a structured agent skill catalog — separate from loose procedure memories. Skills have schema (skill_id, applies_to, triggers, body, type) and are stored in the dedicated skill_substrate namespace so multiple consumers (this MCP, yantrikdb-hermes-plugin, Lane B SDK, WisePick, yantrikdb-server's /v1/skills/* endpoints) all read and write the same substrate. Background: Sarkar 2026 — Skill as Memory, Not Document.

Security model

Skill writes shape future agent behavior across sessions, so the MCP server implements defense-in-depth. Every control has an env-var knob (locked once at startup — C2) and the full state is exposed via stats(action="stats") and the audit log.

Layered controls (each ships on by default unless noted):

Enterprise checklist:

# Minimum production config when you turn the gate ON:YANTRIKDB_SKILLS_WRITE_ENABLED=trueYANTRIKDB_SKILLS_WRITE_EXPIRES_AT=2026-12-31T00:00:00ZYANTRIKDB_SKILLS_ALLOWED_NAMESPACES=workflow,review,onboardingYANTRIKDB_SKILLS_AUDIT_LOG=/var/log/yantrikdb/skills.audit.jsonlYANTRIKDB_SKILLS_AUTHOR_ORIGIN=acme-corp-claude-prod# Defaults are already correct: writes off, scanners on, rate-limit 30/min,# rule-type routed to review, body-hash verified on read, locked at startup.

The audit log is the canonical record. Every accept, every reject (with the scanner that flagged), every tamper-detection on read, every gate-closed-due-to-expiry — all there in JSONL. Plug it into your SIEM.

stats(action="stats") example output (skill_substrate slice)

"skill_substrate": {  "counters": {    "skill_defines_accepted": 12,    "skill_defines_rejected": {"content_scan:A2": 1, "namespace_not_allowed": 3},    "skill_outcomes_recorded": 47,    "skill_pending_review": 2  },  "config": {    "writes_enabled": true,    "write_expires_at": "2026-12-31T00:00:00+00:00",    "allowed_namespaces": ["workflow", "review"],    "audit_log_path": "/var/log/yantrikdb/skills.audit.jsonl",    "rule_requires_review": true,    "author_origin": "acme-corp-claude-prod"  }}

Schema (validated at write time)

Example session

# Define (requires gate enabled)skill(action="define",      skill_id="workflow.git.commit_clean",      body="Before commit: run pytest, run lint, write a clear subject + body.",      skill_type="procedure",      applies_to=["git", "release"])
# Surface relevant skills for the current taskskill(action="surface", query="how to commit cleanly", top_k=5)
# Record an outcome after using the skill (gated, append-only)skill(action="outcome", skill_id="workflow.git.commit_clean",      succeeded=True, note="caught a flake8 issue pre-push")

Outcomes are append-only events in the outcome_substrate namespace — no auto-rollup on the parent skill, matching yantrikdb-server's "schema not semantics" design rule. Agents (or the operator) can aggregate outcomes themselves to compute success rates.

FAQ

What is YantrikDB MCP?

YantrikDB MCP is a Model Context Protocol (MCP) server that gives AI agents persistent cognitive memory across sessions. It exposes 21 tools (remember, recall, forget, correct, think, graph, conflict, trigger, session, temporal, procedure, category, personality, stats, memory, skill, gaps, conversation, task, pack, atlas) that any MCP-compatible client — Claude Code, Cursor, Windsurf, Continue, Claude Desktop — can call automatically without prompting.

How is this different from file-based memory like CLAUDE.md?

File-based memory loads everything into context on every conversation, which scales O(n) in token cost. YantrikDB uses selective semantic recall — at 5,000 memories, file-based costs ~101K tokens per conversation while YantrikDB costs ~53 tokens. Precision improves with more data instead of degrading as the context window fills up. Benchmark script: python benchmarks/bench_token_savings.py.

How does it compare to mem0 / Letta / Zep / native MCP memory?

See comparison table below. Short version: YantrikDB is the only one that ships as both an embeddable Rust engine and an MCP server and a network database with the same substrate semantics. It's the only one with first-class procedural memory + a skill substrate validated by schema at write time + autonomous consolidation/conflict detection. It's also the only one whose underlying engine is published as a peer-reviewed paper (Sarkar 2026, Zenodo DOI 10.5281/zenodo.20128887).

Can I self-host?

Yes — three ways. (1) Local: just pip install yantrikdb-mcp and point your MCP client at it. SQLite lives at ~/.yantrikdb/memory.db. (2) Network: run yantrikdb-server as a multi-tenant HTTP cluster, point the MCP at it via YANTRIKDB_SERVER_URL. (3) Hybrid: SSE server mode (yantrikdb-mcp --transport sse) for shared deployments.

Is my data sent anywhere?

No. All data stays on your machine (or your cluster). No telemetry, no third-party services. The default embedder runs entirely in the Rust engine via static lookup — no model downloads or API calls. The optional [onnx] and multilingual embedders fetch model weights once from HuggingFace's CDN and run locally thereafter.

What's the difference between procedure and skill?

procedure stores loose how-to memories (effectiveness-ranked, no schema). skill stores structured catalog entries (skill_id, applies_to, triggers, body, type) in a dedicated skill_substrate namespace shared with yantrikdb-hermes-plugin, Lane B SDK, WisePick, and the yantrikdb-server /v1/skills/* endpoints. Use procedure for personal how-to notes; use skill for structured agent capabilities that other consumers should be able to surface.

Is skill authoring safe to enable?

Skill writes are off by default precisely because they can shape future agent behavior. When you turn the gate on, seven layers of defense-in-depth apply: prompt-injection scanner, credential scanner, URL block, unicode-evasion scanner, namespace allowlist, author attribution, audit log, rate limit, body-hash tamper detection, and a review queue for rule-type skills. See Security model above.

Does it work in production?

Yes — yantrikdb-mcp runs in production on the YantrikDB homelab cluster (1973+ memories, SSE transport, 2 weeks uptime per release cycle) and is the reference deployment behind the engine's release decisions. v0.8.x added the engine's same-day-patch cadence to the MCP server itself: the 3 community-filed issues to date were fixed in roughly 4 hours, 5 hours, and 4 days — a median of about 5 hours, same-day in 2 of 3 cases.

What's the engine written in?

The YantrikDB engine is Rust (crates.io: yantrikdb) with pyo3 Python bindings (PyPI: yantrikdb). The MCP server itself is Python — a thin wrapper around the engine's Python bindings, plus stdio/SSE/HTTP transport plumbing.

Comparison with other agent memory systems

Comparisons reflect public-facing capabilities as of May 2026. PRs welcome to correct any rows.

Cite this work

If you use YantrikDB in academic or research context, please cite the substrate paper:

@misc{sarkar2026skill,  author       = {Sarkar, Pranab},  title        = {Skill as Memory, Not Document: A Database-Native Substrate for Agent Skill Catalogs},  year         = {2026},  publisher    = {Zenodo},  doi          = {10.5281/zenodo.20128887},  url          = {https://doi.org/10.5281/zenodo.20128887},  orcid        = {0009-0009-8683-1481}}

Plain text citation:

Sarkar, P. (2026). Skill as Memory, Not Document: A Database-Native Substrate for Agent Skill Catalogs. Zenodo. https://doi.org/10.5281/zenodo.20128887

Examples

1. Auto-recall at conversation start

User: "What did we decide about the database migration?"

The agent automatically calls recall("database migration decision") and retrieves relevant memories before responding — no manual prompting needed.

2. Remember decisions + build knowledge graph

User: "We're going with PostgreSQL for the new service. Alice will own the migration."

The agent calls:

• remember(text="Decided to use PostgreSQL for the new service", domain="architecture", importance=0.8)
• remember(text="Alice owns the PostgreSQL migration", domain="people", importance=0.7)
• graph(action="relate", entity="Alice", target="PostgreSQL Migration", relationship="owns")

3. Contradiction detection

After storing "We use Python 3.11" and later "We upgraded to Python 3.12", calling think() detects the conflict. The agent surfaces it:

"I found a contradiction: you previously said Python 3.11, but recently mentioned Python 3.12. Which is current?"

Then resolves with conflict(action="resolve", conflict_id="...", strategy="keep_b").

Privacy Policy

YantrikDB MCP Server stores all data locally on your machine (default: ~/.yantrikdb/memory.db). No data is sent to external servers, no telemetry is collected, and no third-party services are contacted during operation.

• Data collection: Only what you explicitly store via the remember tool or what the AI agent stores on your behalf.
• Data storage: Local SQLite database on your filesystem. You control the path via YANTRIKDB_DB_PATH.
• Third-party sharing: None. Data never leaves your machine in local (stdio) mode.
• Network mode: When using SSE/HTTP transport, data travels between your client and your self-hosted server. No Anthropic or third-party servers are involved.
• Embedding model: Uses a local ONNX model (all-MiniLM-L6-v2). Model files are downloaded once from Hugging Face Hub on first use, then cached locally.
• Retention: Data persists until you delete it (forget tool) or delete the database file.
• Contact: [email protected]

Full policy: yantrikdb.com/privacy

Contributing

See CONTRIBUTING.md for a venv setup, running pytest, and opening PRs.

Support

• Issues: github.com/yantrikos/yantrikdb-mcp/issues
• Email: [email protected]
• Docs: yantrikdb.com/guides/mcp

Related projects

Same memory substrate, different entry points:

• yantrikdb — the embeddable Rust/Python engine this server runs on (pip install yantrikdb).
• yantrikdb-server — HTTP gateway and HA cluster, for the network deployment modes above.
• yantrikdb-client — typed Python client for that server.
• langchain-yantrikdb — YantrikDB as a LangChain VectorStore and ChatMessageHistory.
• yantrikdb-hermes-plugin — memory provider for NousResearch/hermes-agent, sharing the same skill substrate.
• yantrik-memory — framework-agnostic memory layer with traits and bond evolution.
• openclaw-memory-yantrikdb — OpenClaw memory-slot plugin backed by YantrikDB, published on ClawHub.

License

This MCP server is licensed under MIT — use it freely in any project.

Note: This package depends on yantrikdb (the cognitive memory engine), which is licensed under Apache-2.0 as of 2026-08-18 (previously AGPL-3.0). Both this server and the engine are now permissively licensed — there are no copyleft obligations on your code, modifications, or hosted services.