Memtrace

The persistent memory layer for coding agents.
A bi-temporal, episodic, structural knowledge graph — built from AST, not guesswork.

ai-agents · coding-agents · mcp-server · code-intelligence · knowledge-graph · semantic-search · temporal-analysis · local-first

Waitlist & Early Access — Memtrace is currently in a private beta. We are slowly rolling out access to ensure stability. You must join the waitlist at memtrace.io to use the product right now.

Join the discussion, ask questions, and follow beta updates in Discord.

Core indexing and structural search are stable. Temporal features (evolution scoring, timeline replay) are functional but may have rough edges. Report issues here.

🔒 Privacy — Memtrace runs entirely on your machine. Your source code never leaves it. All parsing, graph construction, embedding generation, and querying happens locally. The only network traffic is license validation, aggregate usage counts (total nodes/edges — no code, no file paths, no symbol names), and opt-out telemetry for crashes / errors / app-start events (sanitised — no source, no file contents, no symbol names). See PRIVACY.md and TELEMETRY.md for the full breakdowns. Disable telemetry with MEMTRACE_TELEMETRY=off.

GitHub Star Growth

Memtrace gives coding agents something they've never had: structural memory. Not vector similarity. Not semantic chunking. A real knowledge graph compiled from your codebase's AST — where every function, class, interface, and API endpoint exists as a node with deterministic, typed relationships.

Index once. Every agent query after that resolves through graph traversal — callers, callees, implementations, imports, blast radius, temporal evolution — in milliseconds, with zero token waste.

Local machine requirements — Memtrace indexes and embeds your code locally, so the first run is CPU/RAM intensive. Minimum: 4 CPU cores, 8 GB RAM, 5 GB free disk, Node.js 18+, and Git. Recommended for large monorepos: 8+ CPU cores, 16–32 GB RAM, and 10–20 GB free disk. No GPU required.

npm install -g memtrace    # binary + 12 skills + MCP server — one command
memtrace start             # launches the graph database and auto-indexes the current project

That's it. Run memtrace start from your project root — it spins up the graph database and kicks off indexing automatically. Claude and Cursor (v2.4+) pick up the skills and MCP tools automatically.

https://github.com/user-attachments/assets/e7d6a1e9-c912-4e65-a421-bd0256dffa5a

Built-in UI at localhost:3030 — explore your graph, trace dependencies, spot dead code, and visualize architecture at a glance

Why Memtrace Exists

Good code intelligence tools already exist. GitNexus and CodeGrapherContext build AST-based graphs with symbol relationships, and they work well for understanding what's in your codebase right now.

Memtrace is a bi-temporal episodic structural knowledge graph. It builds on that same AST foundation and adds two dimensions:

• Temporal memory — every symbol carries its full version history. Agents can reason about what changed, when it changed, and how the architecture evolved — not just what exists today. Six scoring algorithms (impact, novelty, recency, directional, compound, overview) let agents ask different temporal questions.
• Cross-service API topology — Memtrace maps HTTP call graphs between repositories, detecting which services call which endpoints across your architecture.

On top of that, the structural layer is comprehensive:

• Symbols are nodes — functions, classes, interfaces, types, endpoints
• Relationships are edges — CALLS, IMPLEMENTS, IMPORTS, EXPORTS, CONTAINS
• Community detection — Louvain algorithm identifies architectural modules automatically
• Hybrid search — Tantivy BM25 + vector embeddings + Reciprocal Rank Fusion, all on top of the graph
• Rust-native — compiled binary, no Python/JS runtime overhead, sub-8ms average query latency

The agent doesn't just search your code. It remembers it.

Benchmarks

Five sub-benches across three corpora (mempalace, Django, a 21-file scratch fixture). Every system runs on the same machine, against the same ground truth, using the same adapter contract. Ground truth comes from Python's stdlib ast, the pyright LSP, or deterministic edit scripts — never from any tool's own index — so no system gets a home-field advantage in the dataset itself.

Full reproduction instructions and per-bench numbers: benchmarks/README.md. The frozen exact-symbol harness is benchmarks/fair/; the extended harness covering all five benches is benchmarks/suite/.

Summary across the five benches (🟢 = Memtrace wins declared primary axis, 🟡 = Memtrace trails):

Memtrace wins 5 of 6, trails on 1 (Bench #2 — ChromaDB is the expected winner on semantic NL queries). Bench #5 (agent-level) is skeleton-only and gated behind RUN_AGENT_BENCH=1.

Results (1,000 Python symbol-lookup queries on mempalace, v0.3.22 + ranking)

Numbers from isolated per-adapter processes — full methodology in BENCHMARKS-v0.3.22.md.

• 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 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 for the full consolidated table and per-bench repro.

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), 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). 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.

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:

All numbers from benchmarks/ on the same machine, same corpora, same adapter contract. Ground truth is independent of every tool's index (Python ast for Bench #0/#1, pyright LSP for Bench #3, deterministic edit scripts for Bench #4) — no system is advantaged in the dataset itself. Bench #3 "filtered" rows only average over symbols with non-empty pyright gold on that axis; unfiltered rollups live in benchmarks/suite/results/.

The latency difference is primarily Rust vs. interpreted runtimes, and Memtrace's embedded MemDB engine (inverted property index for sub-millisecond find_by_property, HNSW vector index in-process) vs. HTTP/embedding pipelines. The feature difference is bi-temporal memory and API topology — dimensions Memtrace adds on top of the shared AST-graph foundation.

25+ MCP Tools

Memtrace exposes a full structural toolkit via the Model Context Protocol:

12 Agent Skills

Memtrace ships skills that teach Claude how to use the graph. They fire automatically based on what you ask — no prompt engineering required.

Plus 4 workflow skills that chain multiple tools with decision logic:

Temporal Engine

Six scoring algorithms for different temporal questions:

Uses Structural Significance Budgeting to surface the minimum set of changes covering ≥80% of total significance.

Compatibility

MCP tools work with any editor or agent that supports the Model Context Protocol. Skills are workflow prompts that teach the agent how to chain tools — Claude Code, Claude Desktop, and Cursor (v2.4+) all load them natively from the same SKILL.md format.

Setup

Claude Code + Claude Desktop

npm install -g memtrace handles everything automatically — binary, 12 skills, MCP server, plugin, and marketplace all register in one command for both Claude Code and Claude Desktop.

For manual setup:

claude plugin marketplace add https://github.com/syncable-dev/memtrace-public.git
claude plugin install memtrace-skills@memtrace --scope user
claude mcp add memtrace -- memtrace mcp -e MEMTRACE_ARCADEDB_BOLT_URL=bolt://localhost:7687

Cursor

Cursor v2.4+ supports Agent Skills natively, and npm install -g memtrace handles everything automatically — no separate Cursor plugin is needed because Cursor reads the same SKILL.md format as Claude.

What the installer writes:

• MCP server → ~/.cursor/mcp.json (global — works in every project you open)
• 12 skills + 4 workflows → ~/.cursor/skills/memtrace-*/SKILL.md

For a project-local install (so the skills travel with your repo and teammates get them on clone), run inside the project:

memtrace install --only cursor --local

This writes to .cursor/mcp.json and .cursor/skills/ relative to the project root instead of your home directory.

For a manual install (without the npm package), clone this repo and copy the skills directly:

cp -R plugins/memtrace-skills/skills/* ~/.cursor/skills/

Then register the MCP server manually (see the "Other Editors" JSON below).

Other Editors (Windsurf, VS Code, Cline)

After npm install -g memtrace, add the MCP server to your editor's config:

{
  "mcpServers": {
    "memtrace": {
      "command": "memtrace",
      "args": ["mcp"],
      "env": { "MEMTRACE_ARCADEDB_BOLT_URL": "bolt://localhost:7687" }
    }
  }
}

Uninstall

memtrace uninstall              # removes skills, MCP server, plugin, and settings
npm uninstall -g memtrace       # removes the binary

Already ran npm uninstall first? The cleanup script is persisted at ~/.memtrace/uninstall.js:

node ~/.memtrace/uninstall.js

A note on install

npm install -g memtrace ships a small main package + a platform-specific binary (one of @memtrace/darwin-arm64, @memtrace/linux-x64, or @memtrace/win32-x64) that npm picks automatically.

Most setups just work. If memtrace start ever says "Could not find binary for your platform", any of these will fix it:

# Option 1 — re-run install, asking npm to keep optional deps
npm install -g memtrace --include=optional

# Option 2 — refresh from latest
memtrace install                  # built-in self-update
# or:
npm install -g memtrace@latest --force

# Option 3 — install the platform binary directly (Apple Silicon shown — swap for your platform)
npm install -g @memtrace/darwin-arm64

This typically only happens on machines where npm is configured to skip optional dependencies (some corporate npmrc setups, certain CI caches). Postinstall self-heals on most installs; the options above cover the rest.

Languages

Rust · Go · TypeScript · JavaScript · Python · Java · C · C++ · C# · Swift · Kotlin · Ruby · PHP · Dart · Scala · Perl — and more via Tree-sitter.

Telemetry

Since v0.3.17 Memtrace ships with opt-out telemetry that helps us catch
crashes, regressions, and performance issues before someone has to file
an issue. Concretely:

• What's collected: app-start events, indexing/embedding durations,
  panic reports, and WARN/ERROR log lines from Memtrace's own crates.
• What's NOT collected: source code, file contents, symbol names,
  embeddings, repository names or paths, branch names, commit data.
• Sanitisation: every payload is run through a sanitiser that strips
  home-dir paths, token-shaped strings, and email addresses before
  it touches disk.

Turn it off with one env var:

# Per-run
MEMTRACE_TELEMETRY=off memtrace start

# Permanent (~/.zshrc, ~/.bashrc, etc.)
export MEMTRACE_TELEMETRY=off

Or in your editor's MCP config:

{
  "command": "memtrace",
  "args": ["mcp"],
  "env": { "MEMTRACE_TELEMETRY": "off" }
}

Full breakdown — including the on-disk queue layout, where the data is
stored on the receiving end, and how to inspect what would have shipped —
is in TELEMETRY.md.

Requirements

Memtrace does parsing, graph construction, and embedding generation locally. Expect the first index to use noticeable CPU and memory; follow-up queries and incremental indexing are much lighter.

Documentation · Discord · npm · Issues

_{Built by Syncable · Proprietary EULA · Free to use}