synapse-mcp

Tu cerebro estructural para tus agentes de IA de programación.

Synapse-MCP es un servidor MCP gratuito y 100 % local que convierte tu codebase en un grafo de conocimiento AST persistente y almacenado en tu dispositivo. Claude, Cursor, Copilot y todos los agentes compatibles con MCP obtienen árboles de llamadas exactos, búsqueda semántica y refactorización sin alucinaciones, con un 60% menos de gasto en tokens que las herramientas de shell. Tu código nunca sale de tu máquina.

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

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

¿Qué es Synapse MCP?

Si has usado asistentes de programación con IA — Claude, Copilot, Cursor, Devin — seguramente habrás notado que pasan mucho tiempo encontrando código antes de poder modificarlo. Hacen grep en archivos, leen imports, buscan nombres de funciones y abren archivo tras archivo. Esa exploración es cara: quema tokens, lleva tiempo y, aun así, el agente a veces falla.

Synapse MCP es la solución a ese problema.

Es un servidor MCP: un proceso en segundo plano que se conecta a tu agente de IA y le ofrece un nuevo conjunto de herramientas. En lugar de un sistema de archivos y una casilla de búsqueda, Synapse le ofrece a tu agente un grafo de conocimiento preconstruido de todo tu código: cada función, cada clase, cada relación de llamada y cada límite de módulo, indexado, estructurado y listo para consultarse en milisegundos.

En palabras sencillas

Piensa en la diferencia entre un empleado nuevo en su primer día y un ingeniero sénior que lleva años trabajando en el mismo código.

El empleado nuevo abre archivos, busca cosas, hace preguntas y se confunde con nombres desconocidos. Cada tarea empieza con exploración.

El ingeniero sénior ya sabe dónde está todo. Va directo al archivo correcto, entiende los efectos de un cambio en el resto del código antes de tocarlo y sabe qué pruebas ejecutar. No explora: actúa.

Synapse convierte a tu agente de IA en el ingeniero sénior. El grafo de conocimiento se construye una sola vez, se actualiza automáticamente a medida que tu código cambia y se consulta al instante en cada petición del agente, todo ello sin que tu código salga de tu máquina.

¿Por qué debería usarlo?

No cambias cómo funciona tu agente. No cambias tu flujo de trabajo. Instalas Synapse, registras tu repo y tu agente se vuelve más inteliinmediatamente.

Related MCP server: Reporecall

100% Local. Siempre.

🔒 Tu código nunca sale de tu máquina. Synapse se ejecuta por completo en tu hardware: sin indexación en la nube, sin llamadas a API con tu código, sin telemetría y sin depender de ningún proveedor.

La mayoría de las herramientas de inteligencia de código envían tu código a un servicio en la nube para construir su índice. Synapse no. El grafo AST completo (cada función, cada arista, cada embedding) se construye y se almacena localmente en un almacén persistente en el dispositivo. Cuando el grafo está listo, tus agentes lo consultan directamente a través de MCP. Nada sale de tu máquina.

Esto es importante para:

• Entornos empresariales y regulados — el código fuente permanece dentro de tu perímetro

• Colaboradores de código abierto — tu trabajo sin publicar sigue sin publicar

• Cualquier persona que valore la velocidad — las consultas al grafo tienen latencia submilisegundo. Nunca hay round-trip de red.

¿Por qué Synapse?

Los agentes estándar hacen grep de texto. Synapse sirve fragmentos estructurales comprimidos desde un grafo AST preconstruido —llamantes, llamados, huecos de cobertura, contratos y resúmenes— en una sola llamada MCP.

"Cuatro llamadas de herramienta. Cero lecturas de archivos. Cero greps. Con Synapse el agente gasta tokens en la tarea real, no en exploración." — del informe de benchmarks de Synapse

Benchmark: auditoría de seguridad autónoma · codebase de 500k LOC · mismo modelo de vanguardia

Menos llamadas de herramientla y sin latencia de red = bucles de agente mucho más rápidos.

Características de un vistazo

Idiomas y dialectos

Más de 50 lenguajes. Un único grafo. Compatible con cientos de repos. Generación de chunks con conocimiento de AST y extracción de dependencias edge para todos los lenguajes del ecosistema principal — sin plugins, sin configuración, sin nube.

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 ...y más

Instalación

Consulta Guía de inicio rápido o visita synapse-mcp.dev/download para obtener la guía completa y el instalador con interfaz gráfica.

Precios

Free — The Golden Graph · $0 para siempre

Pro — The Shadow Graph · $19 / mes

⚡ El ahorro típico en tokens supera el costo de suscripción.

Synapse aprende de cada sesión

La mayoría de los agent expertise no modernos no tienen memoria. Cada sesión comienza desde cero: el agente vuelve a leer los mismosarchivos, descubre las mismas funciones y prueba las mismas preguntas una y otra vez. Eso es caro y lento.

Synapse es distinto. Mantiene un grafo de conocimiento persistente en el dispositivo que se acumula en cada sesión. Pero más allá de almacenar el grafo, incorpora una capa de aprendizaje y refuerzo integrada que se vuelve más inteligente cuanto más lo usas.

Cómo funciona el aprendizaje — en palabras sencillas

Piénsalo como un colega muy organizado que toma notas.

1. Resúmenes que permanecen Cuando un agente (o tú) explica lo que hace una función — "This handles Stripe webhook validation and checks for duplicate events" — Synapse lo escribe permanentemente en el grafo. En la siguiente sesión, cualquier agente que toque esa función recibe tu explicación automáticamente. La escribiste una vez. Todos los agentes se beneficián para siempre.

2. Consultas que aprenden solas Cada vez que una búsquueda devuelve un result se load order para el agente, Synapse registra silentemente la asociación: «cuando elguien pregunta por X, el chunk Y era la respuesta correcta». Con el tiemp, los result más útiles para las consultas frecuentes ascien al principo sin que nadie tenea que ajustar nada swap manual. Est es refuerzo de recuperación: el grafo mejoin su propio ranking a partir del uortuno real.

3. Promoción explícita Si un resultado es importantmente, puedes decirle a Synapse directamente: «para consultas sobre el procesamiento de pago, prresenta siempre este chunk como primer result». Esa instrución se almacena localmente y se respena en tutorial las sesiones futuras.

4. Detección de carencias Synapse rastrea qué partes de tu base de código se consultán más pero no tienen ninguna explicación asocia. Puede mostar estas vacíos on demand — asi sabes exactmente dynde cinco minutos de anotación tendrían el mayor impacto en las futuras sesiones de los agentes.

El resulto es un model de la base de código que se compone. El grafo se vuelve más rico, los intervals de result se afinán y los agentes dedican menos tiemp a reexplorar lo que ya se compren un has identity.

🔒 La capa de aprendizaje es totalmente local. Ninguna consulta, ningún resumen ni señal de uso abandona tu máquina.

✨ El sistema de aprendisaje y memoria es una función Pro. Es donde hemos invertido la ingeniería más original — construir un bucle de retroalimentación que esaees cada sesión agente enagentee measurably más rápidamente.

Referencia de herramientas de MCP

Synapse expone 13 herramientas de precisión a través de la Model Context Protocol. Todas las herramientes aceptan el flag compress_payload (valor por defeto true) que activaCrusher — 30–60 % menos to tokens de respuesta sin соглас información.

Las herramientas marcadas con FREE están disponibles en todos los planes. Las marcadas con PRO requieren una suscripción a Pro ($19/mes). Las funciones Pro son donde vive la ingeniería verdaderamente única: escrituras atómicamente seguras con reversión, aprendención de sesión a sesión, resolución de código muerto and análisis de impacto de cambios.

ask_synapse — FREE

Punto de entrada natural por area: por defecto. Envía cualquier pregunta o tarea de coded in lenguage natural. Synapse routa to the suayad más appropriate, devuelve una serie de next_tool_calls seguras que seguir, e informa de un completion_state junto con agent_instruction para que siempre sepas qué se ha oint se next.

Úasélo first cuer quer era — exploración del códig, check de segmented of, editción, debuging, análisis de tests and administración. Para «¿puedode borar X?», «¿sse sigue usonde X?» o «¿debeo pri servar X?», incluye inputs.chunk_id cuando lo copies; en caso contrario incluye repo_id and un símbolo concretamente calificado por aridad en inputs.symbol. If the user gives a prose descripción, ask for the concrete symbol or show candidates in hour guess.

{ "query": "Where is the retry logic for the payment service?", "repo_id": "my-org/my-repo" }

synapse_search_codebase — FREE

Encuentra código por meaning, name or pattern. Mateu search maneras en una sola herramienta:

{ "action": "symbol", "query": "PaymentService", "repo_id": "my-org/my-repo" }

synapse_explore_graph — FREE

Navega por las relaciones en torno de cualquier chunk. Dado a chunk ID (de cualquier resultado de búsqueda), recorre la del AST en cualquier dirección.

Use this before any tocar ninguna function to fill with the blast radius.

{ "action": "callers", "chunk_id": "abc123", "depth": 3 }

synapse_get_context — free unspecified

Advanced context: capture context para editar, acumulación y explicación.

{ "action": "edit", "intent": "Refactor the caching layer to use Redis", "repo_id": "my-org/my-repo" }

synapse_inspect_files — FREE

Lee código source y chunks con constramiento structural.

Paseformat: "outline" for scan 20+ files at a fraction of token cost. format: "full" only if you need full implementation.

**Example.*:

️ Linting workflows: escalación pass compress_payload: false al leer archivos for to investigate whitespace or formatting violations. SmartCrusher removes trailing spaces. Great and trailing whitespace before returning. Return the content, which can hide the very same violations you're trying to fix.

{ "action": "read_files", "files": [{ "path": "lib/my_module.ex", "ranges": ["45-80"] }], "format": "outline" }

synapse_modify_files — PRO

Edit code with safety guarantees — lint-validated and automatically rolled back on failure.

This is one of our proudest features. A naive write raw file by an agent is dangerous — a failed linter can cause broken file, half-written or commit that doesn't compile. write_safeely eliminates all class failures by simulating edit in memory, running your project own linter, and writing only if valid. If fails, original file remains intact.

Aconstantly vendía together instantasynapse_get_context (edit) before to understand the callers and the impact.

{ "action": "write_safely", "path": "lib/my_module.ex", "content": "..." }

synapse_change_review — PRO

Review diffs and assess the risk/h impact before pushing.

Before push, Synapse maps every chunk in the diff, sorts risk, identifies broken contracts and indicates which tests run. It replaces a manually review that typically takes 20-40+ minutes for a medium change.

|:

| analyse_diff | Analiza structural diff: which chunks only happened, what affects | | review_diff | Full code review: risk ranking, blind spots, broken contracts, recommended tests | | impact | Post-edit beat radius check — check what a commit change affects |

They goes a raw diff string or commit rango. Get actionreliable output before pushing.

{ "action": "review_diff", "diff": "..." }

synapse_codebase_insights — FREE

Analysis at codebase in a single call. Use the dead_code action (usually via ask_synapse) to get level of evidence function whether a symbol or chunk is actually in use or if it is safe to delete.

|:

| detect | Detección de lengua gage across workspace | | public_api | Extract public API surface from module or entire codebase | | dead_code | Read test deletion if with only-le/at-symbol level: given chunk_id or symbol qualified, returns production callers, test callers, confidence, caveats, and safe_to_delete | | contracts | Searches for interface contracts/behaviors/protocols and their implementations | | dependencies | Graph of dependencies between modules — who imports whom | | overview | Consolidated high-level views of code architecture | | refactor_opportunities | Identifies points: logic duplicated logic duplicated, modules overweight, coupling tight coupling |

{ "action": "overview", "repo_id": "my-org/my-repo" }

Feedback deletion questions should enter through usual ask_synapse so the routing, missing-entry 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" }
}

Si no hay un chunk_id disponible, pasa repo_id junto con un símbolo con aridad explícita, como Parser.parse/2; la prosa descriptiva debe generar una aclaración o candidatos, no una decisión de eliminación adivinada.

Interpreta dead_code leyendo preferred_identifier, valid_input_patterns, scope, clause_level_analysis, safe_to_delete, deletion_risk, confidence, caveats y supporting_evidence.production_callers / supporting_evidence.test_callers. dead_code es de nivel de función; la alcanzabilidad a nivel de cláusula se informa actualmente como no compatible. Los llamadores en producción implican conservarlo; los llamadores solo de pruebas y la visibilidad desconocida deben presentarse como precaución, no como eliminación automática.

synapse_test_quality — PRO

Descubrimiento de pruebas y análisis de cobertura: no requiere ejecutor de pruebas.

Obtiene la cobertura y las carencias de prueba directamente del grafo AST, sin ejecutar ni una sola prueba. Esto es especialmente potente en bases de código grandes, donde una suite de pruebas completa tarda minutos en ejecutarse. Synapse te dice qué está cubierto, qué no y dónde centrarse a continuación, en segundos.

{ "action": "find_tests", "symbol": "PaymentService.charge" }

synapse_debug_trace — PRO

Depuración y trazado de ejecución directamente desde el grafo de AST.

Pega un stack trace sin procesar y obtén un análisis de causa raíz que asigna cada frame directamente a tus chunks indexados, con una prueba de reproducción sugerida y la cadena de llamadas que llevó hasta allí. Sin runtime, sin depurador, sin necesidad de volver a ejecutar el escenario de fallo.

{ "action": "resolve_stack", "stack_trace": "..." }

synapse_knowledge_cache — PRO

La capa de aprendizaje y refuerzo. Conocimiento persistente que sobrevive entre sesiones.

Esta es la capacidad más singular de Synapse. Consulta Synapse Learns From Every Session para una explicación en lenguaje sencillo de cómo funciona.

{ "action": "save_summary", "chunk_id": "abc123", "summary": "Handles Stripe webhook validation and idempotency checks." }

synapse_manage_repos — FREE

Registrar, listar y gestionar repositorios en el grafo de Synapse.

{ "action": "register", "path": "/path/to/my-repo" }

synapse_indexer_control — FREE

Comprobaciones del estado del sistema y administración del índice.

{ "action": "status", "repo_id": "my-org/my-repo" }

synapse_capability_manifest — FREE

Superficie de herramientas autodocumentada. Devuelve la lista completa de herramientas, acciones y parámetros disponibles para la versión de Synapse en uso. Es útil para los agentes que inicializan un nueva sesión o que comprueban las funciones disponibles en el servidor conectado.

{}

Compatibilidad con Git Worktree

• Indexación delta — solo se reindexan los archivos modificados, añadidos o eliminados. Casi instantánea (< 50 ms).

• Prioridad de superposición — los chunks del worktree ensombrecen automáticamente los chunks del repositorio principal.

• Flujos de trabajo con agentes en paralelo — abre varios subagentes en worktrees separados sin duplicar el índice principal.

Obras en cualquier lugar

Synapse implementa el Model Context Protocol, Specification abierta. Si tu herramienta habla MCP, se integra con Synapse.

IDEs y editores: Cursor · Windsurf · VS Code · Zed · JetBrains AI

Agentes: Claude Code · GitHub Copilot · Devin · Aider · Cline · Continue.dev · Replit Agent · Amazon Q · OpenHands · SWE-agent · Plandex · Antigravity

Herramientas: Sourcegraph Copy · Q.odo · Tabnine

Guía de inicio

Instalación completa e instalador con interfaz gráfica: synapse-mcp.dev/download

Linux / macOS

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

Descarga y ejecuta el script de instalación — revísalo primero

Windows

powershell -c "irm https://downloads.synapse-mcp.dev/install.ps1 | iex"

Ejecútalo desde PowerShell — revísalo antes de ejecutar

El instalador detecta automáticamente tu cliente MCP (Cursor, Claude Code, Windsurf, VS Code, etc.) y ajusta la configuración correcta.

Privacidad

100 % local. Synapse se ejecuta por completo en tu máquina. No sale ningún código de tu entorno, no hay dependencias en la nube, no hay salida de datos. Tu código sigue siendo tuyo.

Contribución — cómo ayudar a que los agentes usen Synapse mejor

Esta es la contribución de mayor impacto que puedes hacer.

Los LLM se entrenan con miles de millones de líneas de código en las que los desarrolladores recurren a grep, find, cat y ls para explorar una base de código. Esta memoria muscular está grabado en los pesos del modelo. Cuando un agente llega a un proyecto nuevo, su primer instinto es utilizar grep — aunque haya una herramienta más inteligente y económica disponible.

Synapse incluye un conjunto de archivos de habilidades para agentes (.agents/skills/synapse-mcp/SKILL.md, AGENTS.md) que los agentes cargan al iniciar la sesión. Estos archivos anulan el instinto de usar grep para resolver, proporcionando a los agentes reglas de enrutamiento explícitas, antespacios y ejemplos de llamadas a herramientas. De hecho, son entrenamiento en el meta — enseñan a los agentes cómo usar las herramientas de las que disponen, no solo en qué consisten.

El problema: solo podemos escribirlos lo que observamos. Tal vez hayas visto modos de fallo, zonas del enrutamiento o fórmulas que tu agente concreto ignora. Nosotros no. Los archivos de habilidades mejoran muchísimo con informes de uso reales.

Qué nos gustaría que aportaras

Cómo contribuir

1. Abre una incidencia — describe el modo de fallo o la carencia que observadas. Incluyes el agente, la consulta y qué hizo frente a lo que debería o no.

2. Abre un PR — edita directamente AGENTS.md o .agents/skills/synapse-mcp/SKILL.md. Las solicitudes de cambio de los archivos de skill se revisan y fusionan con rapidez — no requieren pruebas.

3. Comparte un benchmark — si has ejecutado Synapse contra las herramientas de shell sobre tu propia base de código y tienes números, nos guste publicarlos.

Los archivos de skill están en la raíz del repositorio y en .agents/. Son Markdown sencillo: no se requieren conos de Elixir. Si puedes describir qué fue mal, puedes escribir el arreglo.

Lo que viene — HiMyelix Agents · próximamente, tercera 3 del 2026

Synapse brindan a tus agentes actuales un mapa de precisión de tu base de código. Myelix Agents es el paso siguiente: agentes de codificación con IA creados desde cero para pensar antes de codificar.

Mientras que los agentes actuales reaccionan (leer un archivo, escribir un cambio y esperar lo mejor), Myelix Agents planifica: mantienen un modelo de tarea for explicada, razonan sobre el riesgo antes de tocar el código, incorporan los aprendizajes de sesiones anteriores (a través del grafo de conocimiento de Synapse) y corrigen el rumbo cuando algo sale mal. Precisión sobre velocidad. Pensar sobre grep.

Los suscriptores de Synapse Pro obtienen acceso anticipado. Únete a la lista de espera →

Soporte

¿Necesitas ayuda? Abre una incidencia y te respondemos. Se aceptan informes de errores, solicitudes de funciones y preguntas sobre integración.

• 🐛 Informar de un error

• 💡 Solicitar una función

• 💬 Hacer una pregunta

Enlaces

• 🌐 synapse-mcp.dev — Sitio y documentación

• ⬇️ Guía de descarga e instalación

• 📖 Blog — análisis técnico y benchmarks

• 🔒 Política de privacidad