memtrace-public

What it does

Three things, every release.

🧭   Run a fleet of coding agents on the same repo without merge hell. Each agent reads the same call graph, sees the same blast radius, inherits the same temporal history. No collisions. No stale context.

🔁   Replay any refactor with full causal awareness. Agents see exactly what depends on what, and what changed when. No more "I refactored a function and 14 tests broke that nobody saw."

⚡   Index a 50k-file repo in under 90 seconds. Rust + Tree-sitter, $0 in API costs, 20+ languages plus framework-aware scanners (Vapor, Lapis, Kong, GitHub Actions, Terraform, RLS policies, …), fully local. Your code never leaves your machine.

🆕   LeanCTX Native — compressed reads, smart trees, and a value ledger. Four new compression modes on get_source_window, single-call directory maps, real-time token-savings dashboard, and an opt-in adaptive learner that beats the static table by ~14%. Full breakdown: docs/leanctx-native.md. Available in v0.3.57+.

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

Numbers

Reproducible benchmark suite: benchmarks/. Same machine, same corpora, same adapter contract. Ground truth from Python's ast and pyright LSP — never from any tool's own index. No system gets a home-field advantage in the dataset.

Detailed breakdowns: BENCHMARKS-v0.3.22.md · BENCHMARKS-v0.3.29.md · Code reviewer benchmark

GitHub Star Growth

Get access

Memtrace is in private beta. We're rolling out access in batches to keep the feedback loop tight — every cohort lands in a Discord channel where we ship fixes from real bug reports inside a week.

→ Join the waitlist at memtrace.io.

Already have access? npm install -g memtrace and you're indexing in 90 seconds. Full setup below.

🔒 Privacy. Memtrace runs entirely on your machine. Source code never leaves it. The only network traffic is license validation, aggregate node/edge counts, and opt-out crash telemetry — no source, no file paths, no symbol names. Full breakdown: PRIVACY.md, TELEMETRY.md. Disable telemetry with MEMTRACE_TELEMETRY=off.

Why Memtrace exists

Good code-intelligence tools already exist. GitNexus and CodeGrapherContext build AST-based graphs that work for "what's in my repo right now."

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

• Temporal memory — every symbol carries its full version history. Six scoring algorithms (impact, novelty, recency, directional, compound, overview) let agents ask different temporal questions: "what changed?", "what's unexpected?", "what'll break?".
• 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:

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

Memtrace vs. general memory systems (Mem0, Graphiti)

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.

25+ MCP tools

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

Search & Discovery

• find_code — hybrid BM25 + semantic + RRF
• find_symbol — exact / fuzzy with Levenshtein

Relationships

• analyze_relationships — callers, callees, hierarchy, imports
• get_symbol_context — 360° view in one call

Impact Analysis

• get_impact — blast radius with risk rating
• detect_changes — diff-to-symbols scope mapping

Code Quality

• find_dead_code — zero-caller detection
• find_most_complex_functions — complexity hotspots
• calculate_cyclomatic_complexity
• get_repository_stats

Temporal Analysis

• get_evolution — 6 scoring modes
• get_timeline — full version history
• detect_changes — diff-based scope

Graph Algorithms

• find_bridge_symbols — betweenness centrality
• find_central_symbols — PageRank / degree
• list_communities — Louvain modules
• list_processes / get_process_flow

API Topology

• get_api_topology — cross-repo HTTP graph
• find_api_endpoints
• find_api_calls

Indexing & Watch

• index_directory — parse, resolve, embed
• watch_directory — live incremental
• execute_cypher — direct g