Synapse MCP is a 100% local MCP server that turns your codebase into a persistent AST knowledge graph, giving AI agents fast, structured code intelligence and safe mutation tools.
Ask in plain language: use ask_synapse to route questions, edits, deletion checks, reviews, debugging, and admin tasks to the right tool, with safe next-step guidance.
Search code: semantic, symbol, and regex search return structured chunk IDs, line numbers, and tags instead of raw file dumps.
Explore the graph: find direct/transitive callers and callees, inspect neighbourhood context around a chunk, and detect circular dependencies.
Inspect files: read full files or chunks with line ranges, use lightweight "outline" mode to save tokens, and count indexed lines.
Modify code safely: write files with in-memory simulation, lint validation, atomic commit, and auto-rollback; run global find-and-replace; delete chunks from the index.
Review changes: analyse diffs and commit ranges to get ranked blast radius, broken contract signals, blind spots, and recommended tests before pushing.
Understand the codebase: detect languages, extract public API surfaces, perform read-only function-level deletion-safety checks, scan contracts, build dependency graphs, get architecture overviews, and surface refactor opportunities.
Work with tests: derive coverage bands from the graph without executing tests, locate related tests, get ranked test targets, and configure Trunk linting.
Debug from stack traces: map crash frames directly to code chunks, get root-cause analysis and test suggestions, and trace execution paths through behaviours.
Learn across sessions: save permanent summaries on chunks, promote important results, query learned associations, and get suggestions for high-impact documentation targets.
Manage repositories: register, list, archive, restore, unregister, update excluded paths, and get actionable recommendations for dirty-merged Git worktrees.
Control the indexer: check server health, monitor indexing progress per repo, and trigger re-indexes.
Discover capabilities: the manifest tool returns all available tools, actions, and parameters for the running server.
Your structural brain for your coding AI agents.
Synapse-MCP is a free, 100% local MCP server that converts your codebase into a persistent, on-device AST knowledge graph. Claude, Cursor, Copilot, and every MCP-compatible agent gets exact caller trees, semantic search, and zero-hallucination refactoring — at 60% lower token spend than shell tools. Your code never leaves your machine.
# Linux / macOS
curl -fsSL https://downloads.synapse-mcp.dev/install.sh | sh
# Windows PowerShell
irm https://downloads.synapse-mcp.dev/install.ps1 | iexIf you've used AI coding assistants — Claude, Copilot, Cursor, Devin — you've probably noticed they spend a lot of time finding code before they can change it. They grep files, read imports, search for function names, open file after file. That exploration is expensive: it burns tokens, takes time, and the agent still sometimes gets it wrong.
Synapse MCP is the fix for that.
It is an MCP server — a background process that connects to your AI agent and gives it a new set of tools. Instead of a file system and a search box, Synapse gives your agent a pre-built knowledge graph of your entire codebase: every function, every class, every call relationship, every module boundary — indexed, structured, and ready to query in milliseconds.
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.
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 |
|
You paste a stack trace and hope |
|
Code review is manual |
|
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.
Related MCP server: Reporecall
🔒 Your code never leaves your machine. Synapse runs entirely on your hardware — no cloud indexing, no API calls with your source, no telemetry, no vendor lock-in.
Most code intelligence tools send your code to a cloud service to build their index. Synapse does not. The full AST graph — every function, every edge, every embedding — is built and stored locally in a persistent on-device store. When the graph is ready, your 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 — local graph queries have sub-millisecond latency. No network round-trip, ever.
Standard agents grep text. Synapse serves compressed structural slices from a pre-built AST graph — callers, callees, coverage gaps, contracts, and summaries — in a single MCP call.
"Four tool calls. Zero file reads. Zero grepping. With Synapse the agent spends tokens on the actual task — not on exploration." — from the Synapse benchmark report
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.
Feature | Description |
🔒 100% Local & Private | The graph is built and stored on your machine. Zero cloud dependencies, zero data egress, zero network latency on queries |
⚡ Sub-millisecond Graph Queries | Local in-memory store means responses are instant — no API round-trips eating into your agent's budget |
🚀 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 (plain English), symbol lookup, and full PCRE regex — all returning structured chunk IDs, not raw file dumps |
Transitive Caller Graph | Know every direct and transitive caller of any function before touching a line of code. Configurable depth, confidence scores, edge labels |
Safe Atomic Writes | Simulate edits in memory, map the blast radius, write atomically, and auto-rollback on lint failure. Your file is never left broken |
Instant Crash Resolution | Paste a stack trace, get root-cause analysis mapped to your AST graph — with reproducing test suggestions. No runtime needed |
Change Review & Impact | Feed a diff or commit range. Get ranked blast radius, broken contracts, tests to run, and blind spots — before you push |
Persistent Agent Memory | Summaries written in one session survive to the next. The more you use Synapse, the smarter your codebase model becomes |
Test Intelligence | Coverage bands, test mapping, and ranked test targets — derived from the graph without executing your test suite |
Codebase X-Ray | Language detection, public API surface, dead-code deletion safety, inter-module dependency graph, contract scanning, and refactor opportunities in one call |
50+ languages. One graph. Supports 100s of repos. AST-aware chunking and dependency edge extraction for every mainstream language — no plugins, no configuration, no cloud.
Elixir Python TypeScript JavaScript Go Rust OCaml Haskell F# Clojure Scala Java Kotlin Swift C C++ C# Ruby PHP Dart Zig Erlang Julia Groovy Solidity GraphQL HCL / Terraform Protobuf SQL Shell PowerShell Lua ...and more
See Quick Start below, or visit synapse-mcp.dev/download for the full guide and GUI installer.
Feature | Details |
AST Indexing | 10,000+ files across 50 languages in seconds |
Search | Semantic, symbol & regex — structured results, not file dumps |
Caller Graph | Transitive caller & callee traversal with confidence scores |
Codebase Insights | API surface, deletion safety, dependency graph & refactor candidates |
Compression | SmartCrusher trims payloads 30–60% before they hit your LLM |
Privacy | 100% local — zero cloud dependencies, zero data egress |
⚡ Typical token savings exceed the subscription cost.
Feature | Details |
Safe Writes | Simulate, validate & auto-rollback on lint failure |
Change Review | Blast radius, broken contracts & ranked risk |
Crash Resolution | Stack trace → root cause → reproducing tests |
Test Intelligence | Coverage bands & precise gap targeting |
Persistent Memory | Summaries survive across sessions |
Knowledge Cache | Queries improve result ranking over time |
Most AI tools have no memory. Every session starts from zero — the agent reads the same files, discovers the same functions, and asks the same questions all over again. That's expensive and slow.
Synapse is different. It maintains a persistent, on-device knowledge graph that accumulates across every session. But beyond just storing the graph, it has a built-in learning and reinforcement layer that gets smarter the more you use it.
Think of it like a highly organised colleague who takes notes.
1. Summaries that stick around
When an agent (or you) explains what a function does — "This handles Stripe webhook validation and checks for duplicate events" — Synapse writes that to the graph permanently. Next session, any agent that touches that function gets your explanation attached automatically. You wrote it once. Every agent benefits forever.
2. Queries that teach themselves Every time a search returns a useful result and the agent uses it, Synapse silently records the association: "when someone asks X, chunk Y was the right answer." Over time, the most useful results for common queries bubble up to the top automatically — without anyone manually tuning anything. This is retrieval reinforcement: the graph improves its own ranking from real usage.
3. Explicit promotion If a result is particularly important, you can tell Synapse directly: "for queries about payment processing, always surface this chunk first." That instruction is stored locally and honoured in every future session.
4. Gap detection Synapse tracks which parts of your codebase get queried most but have no explanation attached. It can surface these gaps on demand — so you know exactly where a five-minute annotation would have the biggest impact on future agent sessions.
The result is a codebase model that compounds. The graph grows richer, the rankings get sharper, and agents spend less time re-exploring what's already been understood.
🔒 The learning layer is entirely local. No queries, no summaries, and no usage signals ever leave your machine.
✨ The learning and memory system is a Pro feature. It's where we invested the most original engineering work — building a feedback loop that makes every subsequent agent session measurably faster.
Synapse exposes 13 precision tools over the Model Context Protocol. All tools accept a compress_payload flag (default true) that enables SmartCrusher compression — 30–60% fewer response tokens at zero information loss.
Tools marked FREE are available on all plans. Tools marked PRO require a Pro subscription ($19/mo). Pro features are where the truly unique engineering lives — safe atomic writes with rollback, session-to-session learning, crash resolution, and change impact analysis.
ask_synapse — FREEThe default natural-language entry point. Send any codebase question or task in plain English. Synapse routes it to the optimal underlying tool, returns safe next_tool_calls to follow, and reports a completion_state plus agent_instruction so you always know what to do next.
Use this first for virtually every task — code exploration, deletion-safety checks, editing, debugging, test analysis, and administration. For "can I delete X?", "is X still used?", or "should I keep X?", include inputs.chunk_id when known; otherwise include repo_id plus an arity-qualified exact symbol in inputs.symbol. If the user gives only descriptive prose, ask for the concrete symbol or show candidates instead of guessing.
{ "query": "Where is the retry logic for the payment service?", "repo_id": "my-org/my-repo" }synapse_search_codebase — FREEFind code by meaning, name, or pattern. Three search modes in one tool:
Action | Description |
| Plain-English similarity search over chunk embeddings. "Find all places that handle auth errors" |
| Exact named-symbol lookup by function, class, module, or type name |
| Full PCRE in-memory grep across the indexed graph. Returns chunk IDs, line numbers, and tags — not raw text |
{ "action": "symbol", "query": "PaymentService", "repo_id": "my-org/my-repo" }synapse_explore_graph — FREENavigate relationships around any chunk. Given a chunk ID (from any search result), traverse the AST dependency graph in any direction.
Action | Description |
| Every direct and transitive caller of a function, with configurable depth and confidence scores |
| All functions/modules called by a given chunk |
| Rich neighbourhood — callers, callees, sibling definitions, and related chunks |
| Detect circular dependency chains in the graph |
Use this before touching any function to understand its full blast radius.
{ "action": "callers", "chunk_id": "abc123", "depth": 3 }synapse_get_context — FREEAdvanced context gathering for editing, onboarding, and explanation.
Action | Description |
| Open-ended semantic research — parallel semantic + exact + fuzzy + graph traversal in one call |
| Pre-edit safety pack: callers, callees, must-read files, likely tests, and risk assessment for a planned change |
| Plain-English explanation of what a specific chunk does |
| Guided reading order for a subsystem — optimal for understanding unfamiliar code |
{ "action": "edit", "intent": "Refactor the caching layer to use Redis", "repo_id": "my-org/my-repo" }synapse_inspect_files — FREERead source files and chunks with structural awareness.
Action | Description |
| Read files with optional line ranges and |
| Read a single chunk by ID directly from the in-memory store — instant, no disk I/O |
| Count total indexed lines across the workspace |
Pass format: "outline" to scan 20+ files at a fraction of the token cost. Use format: "full" only when you need complete implementations.
{ "action": "read_files", "files": [{ "path": "lib/my_module.ex", "ranges": ["45-80"] }], "format": "outline" }⚠️ Linting workflows: Pass
compress_payload: falsewhen reading files to investigate whitespace or formatting violations. SmartCrusher strips trailing whitespace before returning content, which can hide the very violations you are trying to fix.
synapse_modify_files — PROEdit code with safety guarantees — lint-validated and atomically rolled back on failure.
This is one of the features we're most proud of. Vanilla file writes from an agent are dangerous — a failed linter means a broken file, a half-written function, or a commit that doesn't build. write_safely eliminates that entire class of failure by simulating the edit in memory, running your project's own linter against it, and only committing the bytes to disk if validation passes. If anything fails, the original file is untouched.
Action | Tier | Description |
| PRO | Simulate, lint-validate, write atomically. Auto-rollback on failure — your file is never left broken |
| PRO | Global find-and-replace across the indexed graph with pattern matching |
| PRO | Remove a chunk from the graph/index. It is not source deletion guidance; use |
Always pair with synapse_get_context (edit) first to understand callers and impact.
{ "action": "write_safely", "path": "lib/my_module.ex", "content": "..." }synapse_change_review — PROReview diffs and assess blast radius before pushing.
Before you push, Synapse maps every chunk your diff touches, ranks the risk, identifies broken contracts, and tells you which tests to run. This replaces a manual code review pass that typically takes 20–40 minutes for a medium-sized change.
Action | Description |
| Structural analysis of a diff: which chunks changed, what they affect |
| Full review: ranked risk scores, blind spots, broken contracts, recommended tests to run |
| Post-edit blast radius check — verify what a committed change touches |
Feed a raw diff string or a commit range. Get actionable output before you push.
{ "action": "review_diff", "diff": "..." }synapse_codebase_insights — FREECodebase-level analysis in a single call. Use the dead_code action, normally through ask_synapse, when an agent needs function-level evidence about whether one exact symbol or chunk is still used or safe to delete.
Action | Description |
| Language detection across the workspace |
| Extract the full public API surface of a module or the entire codebase |
| Read-only function-level deletion-safety check: |
| Scan for interface/behaviour/protocol contracts and their implementations |
| Inter-module dependency graph — who imports whom |
| Consolidated high-level overview of the codebase architecture |
| Identify hotspots: duplicated logic, bloated modules, tight coupling |
{ "action": "overview", "repo_id": "my-org/my-repo" }Deletion-safety questions should normally enter through ask_synapse so routing, missing-input guidance, and agent_instruction are preserved:
{
"query": "Can I delete this chunk?",
"repo_id": "my-org/my-repo",
"inputs": { "chunk_id": "my-org/my-repo:lib/parser.ex:120" }
}{
"query": "Is Parser.parse/2 still used?",
"repo_id": "my-org/my-repo",
"inputs": { "symbol": "Parser.parse/2" }
}If no chunk_id is available, pass repo_id plus an arity-qualified symbol such as Parser.parse/2; descriptive prose should produce clarification or candidates, not a guessed deletion decision.
Interpret dead_code by reading preferred_identifier, valid_input_patterns, scope, clause_level_analysis, safe_to_delete, deletion_risk, confidence, caveats, and supporting_evidence.production_callers / supporting_evidence.test_callers. dead_code is function-level; clause-level reachability is currently reported as unsupported. Production callers mean keep it; test-only callers and unknown visibility should be presented as caution, not automatic deletion.
synapse_test_quality — PROTest discovery and coverage analysis — no test runner required.
Derives test coverage and gaps directly from the AST graph — without running a single test. This is particularly powerful for large codebases where a full test suite takes minutes to execute. Synapse tells you what's covered, what isn't, and where to focus next, in seconds.
Action | Description |
| Coverage band analysis — which functions are tested, which have gaps |
| Locate tests related to a specific symbol or file, confidence-ranked |
| Ranked list of functions most in need of testing based on the graph |
| Configure Trunk for linting integration |
{ "action": "find_tests", "symbol": "PaymentService.charge" }synapse_debug_trace — PRODebugging and execution tracing directly from the AST graph.
Paste a raw stack trace and get back a root-cause analysis that maps each frame directly to your indexed chunks — with a suggested reproducing test and the call chain that led there. No runtime, no debugger, no re-running the failure scenario.
Action | Description |
| Paste a stack trace; get root-cause analysis mapped to your graph with reproducing test suggestions. No runtime needed |
| Trace the execution path of a behaviour or callback through the graph |
{ "action": "resolve_stack", "stack_trace": "..." }synapse_knowledge_cache — PROThe learning and reinforcement layer. Persistent knowledge that survives across sessions.
This is Synapse's most unique capability. See Synapse Learns From Every Session for a plain-English explanation of how it works.
Action | Description |
| Attach a plain-English description to a chunk. Every future query hitting that chunk gets your explanation for free |
| Search the cache by intent — retrieve promoted results from previous sessions |
| Explicitly promote a chunk for a query, immediately improving future result ranking |
| Find high-traffic chunks that lack summaries — investing here improves all future sessions |
{ "action": "save_summary", "chunk_id": "abc123", "summary": "Handles Stripe webhook validation and idempotency checks." }synapse_manage_repos — FREERegister, list, and manage repositories in the Synapse graph.
Action | Description |
| List all registered repositories with indexing status |
| Register a new repository root. Automatically detects Git worktrees for delta-only indexing |
| Pause indexing for a repo without removing its data |
| Re-activate an archived repository |
| Dismiss a dirty-merged worktree advisory and keep the overlay as-is |
| Remove a repository from the graph entirely |
| Update glob patterns to exclude paths from indexing |
{ "action": "register", "path": "/path/to/my-repo" }synapse_indexer_control — FREEHealth checks and indexer administration.
Action | Description |
| Current indexing phase, file counts, embedding readiness, and per-repo status |
| System health check — confirms the server is up and the graph store is accessible |
| Manually trigger a re-index for a specific repository |
{ "action": "status", "repo_id": "my-org/my-repo" }synapse_capability_manifest — FREESelf-documenting tool surface. Returns the full list of available tools, actions, and parameters for the running Synapse version. Useful for agents bootstrapping a new session or checking what features are available on the connected server.
{}Synapse supports Git worktrees transparently via the Virtual Worktree Overlay (VWO):
Delta Indexing — only modified/added/deleted files are re-indexed. Near-instant (< 50ms).
Overlay Priority — worktree chunks shadow parent repo chunks automatically.
Parallel Agent Workflows — spawn multiple sub-agents in separate worktrees without duplicating the main index.
Synapse implements the open Model Context Protocol. If your tool speaks MCP, it works with Synapse.
IDEs & Editors: Cursor · Windsurf · VS Code · Zed · JetBrains AI
Agents: Claude Code · GitHub Copilot · Devin · Aider · Cline · Continue.dev · Replit Agent · Amazon Q · OpenHands · SWE-agent · Plandex · Antigravity
Tools: Sourcegraph Cody · Qodo · Tabnine
Full install guide & GUI installer: synapse-mcp.dev/download
curl -fsSL https://downloads.synapse-mcp.dev/install.sh | shDownloads and runs the install script — inspect it first
powershell -c "irm https://downloads.synapse-mcp.dev/install.ps1 | iex"Run from PowerShell — inspect the script first
The installer auto-detects your MCP client (Cursor, Claude Code, Windsurf, VS Code, etc.) and writes the correct config.
100% local. Synapse runs entirely on your machine. No code leaves your environment, no cloud dependencies, no data egress. Your codebase stays yours.
This is the highest-leverage contribution you can make.
LLMs are trained on billions of lines of code where developers reach for grep, find, cat, and ls to explore a codebase. That muscle memory is baked into the model weights. When an agent is dropped into a new project, its first instinct is to grep — even when a smarter, cheaper tool is available.
Synapse ships a set of agent skill files (.agents/skills/synapse-mcp/SKILL.md, AGENTS.md) that agents load at session start. These files override the grep instinct by giving agents explicit routing rules, anti-patterns, and example tool calls. They are, in effect, runtime training for the meta-layer — teaching agents how to use the tools they have, not just what the tools do.
The problem: We can only write what we observe. You may have seen failure modes, routing gaps, or phrasing that your specific agent ignores. We haven't. The skill files improve dramatically with real-world usage reports.
Area | What to contribute |
Anti-patterns | Agent behaviours you've seen that Synapse should suppress (e.g. "my agent still greps even after loading the skill") |
Routing rules | Cases where an agent picked the wrong Synapse tool — what was the query, what should it have done? |
Phrasing that works | If a specific instruction wording reliably stops your agent from falling back to grep, share it |
Agent-specific quirks | Claude, GPT-4o, Gemini, and Copilot all have different tendencies. Agent-specific |
New tool examples | Concrete JSON examples for actions that aren't yet covered in the skill |
Missing workflows | Scenarios (debugging, onboarding, large refactors) where the skill gives no guidance |
Open an issue — describe the failure mode or gap you observed. Include the agent, the query, and what it did vs. what it should have done.
Open a PR — edit AGENTS.md or .agents/skills/synapse-mcp/SKILL.md directly. Skill file PRs are reviewed and merged fast — they don't require tests.
Share a benchmark — if you've run Synapse vs. shell tools on your own codebase and have numbers, we want to publish them.
The skill files live at the repo root and in .agents/. They are plain Markdown — no Elixir knowledge required. If you can describe what went wrong, you can write the fix.
Synapse gives your existing AI agents a precision map of your codebase. Myelix Agents is the next step: AI coding agents built from the ground up to think before they code.
Where current agents react — reading a file, writing a change, hoping for the best — Myelix Agents plan. They maintain an explicit task model, reason about risk before touching code, incorporate learnings from previous sessions (via Synapse's knowledge graph), and course-correct when something goes wrong. Accuracy over speed. Thought over grep.
Synapse Pro subscribers will get early access. Join the waitlist →
Need help? Open an issue and we'll get back to you. Bug reports, feature requests, and integration questions are all welcome.
🌐 synapse-mcp.dev — Website & docs
Code intelligence for coding agents: semantic, AST, graph, and full-text search. 279+ languages.
Codebase intelligence for agents: 152 structured artifacts across 21 programs, one call.
AI Agent with Architectural Memory. Impact analysis (free), tests and code from the graph (pro).
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/myelixlabs/synapse-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server