<div align="center"> <svg width="72" height="64" viewBox="0 0 64 64" fill="none" xmlns="http://www.w3.org/2000/svg"> <circle cx="20" cy="20" r="3" fill="#2ef2ff"/><circle cx="12" cy="32" r="2.5" fill="#a45cff"/> <circle cx="24" cy="44" r="3" fill="#2ef2ff"/><circle cx="28" cy="30" r="2" fill="#2ef2ff"/> <circle cx="44" cy="20" r="3" fill="#2ef2ff"/><circle cx="52" cy="32" r="2.5" fill="#a45cff"/> <circle cx="40" cy="44" r="3" fill="#2ef2ff"/><circle cx="36" cy="30" r="2" fill="#2ef2ff"/> <path d="M20 20 L28 30 L12 32 Z" stroke="#2ef2ff" stroke-width="1.5" stroke-dasharray="2 2" opacity="0.6"/> <path d="M12 32 L24 44 L28 30 Z" stroke="#a45cff" stroke-width="1.5" opacity="0.5"/> <path d="M44 20 L36 30 L52 32 Z" stroke="#2ef2ff" stroke-width="1.5" stroke-dasharray="2 2" opacity="0.6"/> <path d="M52 32 L40 44 L36 30 Z" stroke="#a45cff" stroke-width="1.5" opacity="0.5"/> <path d="M28 30 L36 30" stroke="#fff" stroke-width="2" opacity="0.8"/> </svg>

Synapse MCP Server

A persistent code-knowledge graph for AI agents. Runs locally. Writes safely.

</div>

---

🏗️ Currently in Preview. Synapse MCP is actively evolving. We want your feedback — open an issue to tell us what breaks, what's missing, or what would make you switch from grep for good.

---

Synapse MCP is a free, 100% local MCP server that turns your codebase into a persistent, in-memory AST knowledge graph. Claude, Cursor, Copilot, and every MCP-compatible agent gets exact caller trees, semantic search, safe atomic writes, and diff-aware change review — without a single byte of your code leaving the machine.

# Linux / macOS
curl -fsSL https://downloads.synapse-mcp.dev/install.sh | sh

# Windows PowerShell
irm https://downloads.synapse-mcp.dev/install.ps1 | iex

---

What Synapse actually does

Most code-graph tools stop at discovery: index the codebase, answer questions about it, done. Synapse goes further.

It runs as a persistent BEAM daemon — not a CLI you invoke, but a long-lived process that keeps your graph in memory across sessions. It watches files for changes automatically (inotify / FSEvents / kqueue) and re-indexes only the changed files, not the whole workspace. When you pull new commits it detects the new Git HEAD and re-indexes only the diff.

On top of that it adds what no competitor offers: safe write capability. Before any proposed edit touches disk, Synapse simulates it in memory, validates it against the compiler and linter, maps the blast radius, and only commits atomically on passing every gate. If anything fails it rolls back. Your files are never left broken.

In plain terms

Think of the difference between a new employee on their first day versus a senior engineer who has worked in the codebase for years.

The new employee opens files, searches for things, asks questions, gets confused by unfamiliar names. Every task starts with exploration.

The senior engineer already knows where everything is. They go straight to the right file, understand the downstream effects of a change before touching it, and know which tests to run. They don't explore — they act.

Synapse turns your AI agent into the senior engineer. The knowledge graph is built once, updated automatically as your code changes, and queried instantly on every agent request — all without any code leaving your machine.

Why should I use it?

| Without Synapse | With Synapse | |---|---| | Agent greps files, reads imports, opens 10 files to find one function | One tool call returns the exact chunk, its callers, and its tests | | Every session starts from zero | Graph persists and improves across sessions | | Agent writes a file, lint fails, file is broken | write_safely validates first, rolls back on failure | | You paste a stack trace and hope | resolve_stack maps it directly to your AST and suggests a fix | | Code review is manual | review_diff ranks blast radius and broken contracts before you push | | Code sent to a cloud service to build an index | Everything runs locally — zero data egress |

You don't change how your agent works. You don't change your workflow. You install Synapse, register your repo, and your agent gets smarter immediately.

---

What your agent gets

| Tool group | What it does | |---|---| | ask_synapse | Natural-language entry point — routes to the right tool automatically | | synapse_get_context | Pre-built structural slices: callers, callees, contracts, summaries | | synapse_search_codebase | Semantic (BM25F + embeddings), symbol, and regex — structured chunk IDs, not file dumps | | synapse_explore_graph | Transitive caller / callee traversal, cycle detection, context | | synapse_modify_files | Simulate → validate → write atomically → rollback on lint failure | | synapse_change_review | Diff analysis, blast-radius ranking, broken-contract detection | | synapse_debug_trace | Stack trace → AST root cause → reproducing test suggestions | | synapse_test_quality | Coverage bands, test mapping, ranked gap targets | | synapse_codebase_insights | Dead-code deletion safety, public API surface, dependency graph, refactor opportunities | | synapse_knowledge_cache | Persistent summaries and retrieval reinforcement across sessions | | synapse_manage_repos | Multi-repo registry — register, archive, restore; Git worktree support |

---

Benchmark — Autonomous Security Audit · 500k LOC · Same Frontier Model

| Metric | Synapse vs. shell tools | |---|---| | Tokens & Cost | −60% | | Speed | 2.2× faster | | Tool calls | −47% | | Accuracy | 100% — identical | | Data sent to cloud | 0 bytes |

Fewer tool calls + no network latency = dramatically faster agent loops. The agent spends tokens on the actual task, not on exploration.

---

Why not just use X?

We get asked this a lot. Here is the honest answer, with source-verified facts.

"Why not Graphify?"

Graphify is a Python CLI that extracts your codebase into a graph.json file. It is read-only, file-based, and stateless. Every query re-reads the JSON. There is no MCP server, no semantic search, no write safety, no multi-repo support, and no persistent memory. It is a good offline export tool. It is not a graph engine.

"Why not CodeGraph (colbymchenry)?"

CodeGraph is a serious read-only tool with one capability Synapse does not match: HTTP route-chain tracing — following a URL through routing layers into the handler and template for 17 frameworks (Django, Rails, Express, Spring, etc.). If that specific capability is your entire use case, CodeGraph is worth evaluating.

Everything else: CodeGraph has no semantic/vector search (FTS5 only), no write safety, no multi-repo support, no change review, no test mapping, no debug tracing, and no persistent memory. It exposes one MCP tool by default (codegraph_explore). It is per-project only.

"Why not code-graph-mcp (sdsrss)?"

code-graph-mcp is the most technically sophisticated read-only alternative. It has a BLAKE3 Merkle-tree incremental indexer, hybrid BM25 + vector search via Reciprocal Rank Fusion, and 20 tree-sitter parsed languages. It is a well-engineered single binary.

It is still read-only. No write safety, no change review, no multi-repo, no worktrees, no debug tracing. Its 20 languages versus Synapse's 50+ means no Elixir, Erlang, Haskell, OCaml, Scala, Solidity, COBOL, Zig, Gherkin, HCL, Protobuf, GraphQL, or SQL DDL. Its dependency auditing runs on a daily cron; Synapse's runs on every push and blocks the pipeline on failure.

The real difference is that Synapse is the only one in this category that can actively prevent AI agents from breaking production. A tool that cannot write is a tool that cannot protect you from a write.

---

50+ Languages. One graph.

AST-aware chunking and call-graph edge extraction — no plugins, no configuration, no cloud.

Elixir Python TypeScript JavaScript Go Rust OCaml Haskell F# Clojure Scala Java Kotlin Swift Objective-C C C++ C# Ruby PHP Dart Zig Erlang Julia Groovy Solidity GraphQL HCL / Terraform Protobuf SQL DDL Gherkin Shell PowerShell Lua ...and more

---

Local First. Always.

🔒 Your code never leaves your machine. No cloud indexing, no API calls with your source, no telemetry, no vendor lock-in.

The full AST graph — every function, every edge, every embedding — is built and stored locally in a persistent on-device store. Agents query it directly over MCP. Nothing goes out.

This matters for:

• Enterprise & regulated environments — source code stays inside your perimeter
• Open source contributors — your unreleased work stays unreleased
• Anyone who values speed and accuracy — local in-memory graph queries at sub-millisecond latency. No network round-trip, ever. No remote index that's out of date.

---

Engineering

Synapse is built to a production standard.

• Security audit on every push — mix deps.audit runs in CI with allow_failure: false. A dependency vulnerability blocks the pipeline immediately, not within 24 hours.
• Multi-platform smoke tests — every release candidate is built for Linux x86_64/aarch64, Darwin x86_64/aarch64, and Windows x86_64, then exercised via real-process SSE smoke tests before it reaches R2.
• BDD end-to-end — full Cucumber suite runs through the actual packaged binary boundary (Burrito + Rust launcher), not a mock.
• Signed release manifest — the launcher verifies binary integrity against a cryptographically signed manifest before executing. A tampered binary does not start.
• Launcher version gate — promotion is blocked if the launcher version hasn't been incremented correctly. A mis-versioned release cannot ship.
• Zero-latency file watching — the indexer drains all pending file events from its mailbox in a single pass (no sleep, no fixed debounce) and detects new Git HEAD commits, re-indexing only the changed diff.

---

Features at a Glance

| Feature | Description | |---|---| | 🔒 100% Local & Private | Graph built and stored on your machine. Zero cloud dependencies, zero data egress, zero network latency on queries | | ⚡ Sub-millisecond Graph Queries | In-memory ETS store — reads are direct table lookups with no I/O | | 🚀 SmartCrusher Compression | Responses auto-minified 30–60%: short keys, stripped nulls, relativised paths. Outline mode strips bodies — scan 20+ files at a fraction of the token cost | | Three Search Modes | Semantic (BM25F + random-projection embeddings, in-process, zero external ML runtime), symbol lookup, and PCRE regex | | Transitive Caller Graph | Every direct and transitive caller of any function. Configurable depth, confidence scores, edge labels, production vs. test caller splitting | | Safe Atomic Writes | Simulate edits in memory, validate against the compiler and linter, write atomically, auto-rollback on failure. Files are never left broken | | Instant Crash Resolution | Stack trace →