data-ai MCP Server
Structural memory for AI coding agents. Bi-temporal graph, MCP-native, zero LLM calls. Cursor · Claude Code · Codex · Hermes · VS Code · Windsurf.
Discovered via github-topic:mcp-server and last synced 3mo ago.
1. Install the package
npx memtrace-skills install --only cursor --local
2. Add to claude_desktop_config.json
{
"mcpServers": {
"memtrace-public": {
"command": "npx",
"args": [
"memtrace-public"
]
}
}
}Config file location: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) / %APPDATA%\Claude\claude_desktop_config.json (Windows)
Quick module-level summary
You say…
`~/.kiro/settings/mcp.json` or `.kiro/settings/mcp.json`
Recommended
Memtrace
General-purpose "what changed?" — weighted blend of impact, novelty, recency
Global skills / guidance
"What broke?" — ranks by blast radius (`in_degree^0.7 × (1 + out_degree)^0.3`)
"What's unexpected?" — anomaly detection via surprise scoring
Exact-symbol lookup (1,000 queries, mempalace)
Token economy (same 1,000)
No
_"I'm new to this project"_, _"give me an overview"_
Intent retrieval (100 NL PR titles, Django)
_"what will break if I refactor this"_
Primary axis
Tokens
90
Minimum
Graph queries (Django, pyright GT)
BM25 + optional embeddings
_"something broke"_, _"root cause analysis"_
Coverage
**Rust (compiled binary)**
_"help me refactor"_, _"clean up tech debt"_
Δ
- **Coverage** = the tool returned any result for the query (separates "did you index it?" from "did you rank it well?") - **Acc@K** = the correct file appeared in the top K ranked results - **Avg latency** = wall-clock per query, including all protocol overhead (MCP JSON-RPC for Memtrace, HTTP for GitNexus, in-process for ChromaDB, subprocess spawn for CGC) - **Tokens** = average response size in tokens (chars / 4) **What the numbers say, read fairly:** - **Memtrace** holds rank-1 on 96.6% of queries with **128× lower latency** (0.07 ms vs GitNexus 8.95 ms), **1.18× tighter RSS** (26 MB vs 31 MB), and **1.38× higher precision@10** (0.97 vs 0.70). It ranks results by structural relevance — the canonical implementation comes first in one round-trip with the full agent envelope. - **GitNexus** wins by a 4-query margin on acc@1 because it ships raw enumeration order; memtrace re-orders by `direct_callers_count` so `Model.delete` precedes `tests.fake_delete`. Right tradeoff for agents, small benchmark cost. See [`BENCHMARKS-v0.3.22.md`](BENCHMARKS-v0.3.22.md) for the full reasoning. - **ChromaDB** shows what semantic embeddings look like for this workload — 87.8% top-10 but rank-1 is probabilistic, and the response is ~5× larger because it returns 800-char chunks rather than symbol metadata. Per-process RSS is 41× heavier (1,060 MB). - **CodeGrapherContext**'s 100% coverage of mempalace shows its FalkorDB-Lite parser works at small scale; latency is dominated by per-query subprocess spawn (2 s/query). It DNFs on Django (24+ min wall, no progress). **Where each tool shines** — the table above measures exact-symbol lookup only (Bench #0). Different workloads produce different rankings: ChromaDB wins Bench #2 (natural-language / intent retrieval), GitNexus has strong execution-flow traces, Memtrace wins exact lookup, graph queries (Bench #3), incremental freshness (Bench #4), token economy (Bench #1), plus capabilities no competitor has (bi-temporal memory, cross-service HTTP topology, typo tolerance via Levenshtein). See [`benchmarks/README.md`](benchmarks/README.md) for the full consolidated table and per-bench repro. <details> <summary><strong>Memtrace vs. general memory systems (Mem0, Graphiti)</strong></summary> <br/> Mem0 and Graphiti are strong conversational memory engines designed for tracking entity knowledge (e.g. `User -> Likes -> Apples`). They excel at that. For code intelligence specifically, the tradeoff is that they rely on LLM inference to build their graphs — which adds cost and time when processing thousands of source files. **Graphiti** processes data through `add_episode()`, which triggers multiple LLM calls per episode — entity extraction, relationship resolution, deduplication. At ~50 episodes/minute ([source](https://github.com/getzep/graphiti)), ingesting 1,500 code files takes **1–2 hours**. **Mem0** processes data through `client.add()`, which queues async LLM extraction and conflict resolution per memory item ([source](https://mem0.ai)). Bulk ingestion with `infer=True` (default) means every file passes through an LLM pipeline. Throughput is bounded by your LLM provider's rate limits. **Both** accumulate $10–50+ in API costs for large codebases because every relationship is inferred rather than parsed. **Memtrace takes a different approach:** it indexes 1,500 files in 1.2–1.8 seconds for $0.00 — no LLM calls, no API costs, no rate limits. Native Tree-sitter AST parsers resolve deterministic symbol references (`CALLS`, `IMPLEMENTS`, `IMPORTS`) locally. The tradeoff is that Memtrace is purpose-built for code — it doesn't handle conversational entity memory the way Mem0 and Graphiti do. </details> <details> <summary><strong>Memtrace vs. code graphers (GitNexus, CodeGrapherContext)</strong></summary> <br/> GitNexus and CodeGrapherContext both build AST-based code graphs with structural relationships — solid tools in the same space. Memtrace shares that foundation and extends it with temporal memory, API topology, and a Rust runtime:
613.7 ms
Incremental freshness (50 edits)
GitNexus
Best for
"who calls this", "show class hierarchy"
**16+** (Tree-sitter)
"find this function", "where is X defined"
"what changed this week", "how did this evolve"
"what breaks if I change this", "blast radius"
"show me the architecture", "find bottlenecks"
"list API endpoints", "service dependencies"
"index this project", "parse this codebase"
"what else changes with this", "hidden coupling"
"What changed near the incident?" — exponential time decay
"What was added vs removed?" — asymmetric scoring
`~/.codeium/windsurf/mcp_config.json`
`~/.config/opencode/opencode.json` or project `opencode.json`
`~/.codex/config.toml` or `.codex/config.toml`
`~/.hermes/config.yaml`
Config file
Cline MCP settings in the extension panel
4 cores
8 GB RAM
Not required
Required for temporal analysis
"find dead code", "complexity hotspots"
5 GB free