En resumen: codebase-memory-mcp indexa tu repositorio en un grafo de conocimiento persistente para que tu agente de codificación responda preguntas estructurales desde el grafo en lugar de buscar y leer su camino hasta allí. El proyecto mide cinco consultas estructurales en aproximadamente 3.400 tokens a través del grafo frente a aproximadamente 412.000 mediante la exploración archivo por archivo, una reducción del 99,2%. Escrito en C, se distribuye como un único binario nativo sin entorno de ejecución ni clave API, cubre más de 160 lenguajes y se ejecuta completamente en tu máquina. 41.536 estrellas a partir del 1 de septiembre de 2026, con licencia MIT. Si instalas una cosa de la ola de herramientas de agente de 2026, que sea esta.
Esta es una inmersión profunda en una herramienta de nuestra selección de cinco herramientas de agente de IA de código abierto que vale la pena instalar en 2026.
Pregúntale a tu agente dónde se llama una función y observa lo que sucede. Busca (grep). Lee tres archivos. Busca de nuevo con un patrón diferente. Lee cuatro archivos más. Finalmente, responde correctamente, después de haber quemado decenas de miles de tokens llenando su contexto con código fuente que olvidará en el momento en que termine la sesión.
Luego haces una pregunta de seguimiento y vuelve a hacer todo el proceso.
Ese bucle es donde se va la mayor parte de tu límite de uso en una sesión larga, y también es la razón por la que la calidad de las respuestas se degrada a lo largo de una tarde: una ventana de contexto llena de contenido de archivos tiene menos espacio para el razonamiento. codebase-memory-mcp ataca ambos problemas con la misma jugada.
Qué hace
Analiza tu repositorio en un grafo de conocimiento persistente de funciones, clases, cadenas de llamadas, rutas HTTP y enlaces entre servicios, y luego responde preguntas estructurales desde ese grafo.
El análisis sintáctico se realiza a través del análisis AST de tree-sitter en más de 160 lenguajes, con una capa LSP híbrida que añade resolución de tipos semánticos para un grupo central que la insignia README cuenta como diez: Python, la familia TypeScript y JavaScript incluyendo JSX y TSX, PHP, C#, Go, C, C++, Java, Kotlin, Rust y Perl. La distinción es importante. El análisis AST te dice que se llama a un método `save`; la resolución de tipos te dice a qué clase pertenece.
El resultado se expone como 15 herramientas MCP que cubren búsqueda, rastreo de cadenas de llamadas, visión general de la arquitectura, análisis de impacto, verificaciones de cobertura de índices, consultas Cypher contra el grafo, detección de código muerto, vinculación HTTP entre servicios y gestión de ADR. Cualquier cliente que hable el Protocolo de Contexto del Modelo puede usarlo, y el proyecto lista 45 interfaces de agente compatibles, incluyendo Claude Code, Codex, Cursor, Windsurf, OpenCode, Gemini CLI, Aider y Kilocode.
Los números
Dos conjuntos independientes, y ambos merecen ser leídos con atención.
La propia medición del proyecto: cinco consultas estructurales consumieron alrededor de 3.400 tokens a través del grafo frente a unos 412.000 tokens mediante la exploración de grep archivo por archivo. Esto representa una reducción del 99,2%, o aproximadamente 120 veces menos tokens para las mismas respuestas.
La versión académica está en una preimpresión, Codebase-Memory: Tree-Sitter-Based Knowledge Graphs for LLM Code Exploration via MCP, evaluada en 31 repositorios del mundo real. Reporta un 83% de calidad de respuesta, 10 veces menos tokens y 2,1 veces menos llamadas a herramientas en comparación con la exploración archivo por archivo.
La diferencia entre 120x y 10x es la parte honesta. La cifra de 120x corresponde a cinco consultas estructurales, que es el mejor caso del grafo, porque las preguntas estructurales son exactamente para lo que sirve un grafo. La cifra de 10x es una mezcla más amplia en 31 repositorios, lo cual se acerca más a lo que verás en el uso diario. Ambas son grandes. Toma el 10x como tu número de planificación y considera cualquier cosa mejor como una ventaja.
La velocidad es la otra mitad. Indexar el kernel de Linux, 28 millones de líneas en 75.000 archivos, lleva tres minutos. Un repositorio promedio se indexa en milisegundos. Las consultas estructurales regresan en menos de un milisegundo. La tubería es RAM-first con compresión LZ4, SQLite en memoria y coincidencia de patrones Aho-Corasick fusionada, y la memoria se libera después de la indexación.
Escribirlo en C en lugar de TypeScript o Python es la razón de la existencia de esos números, y también es por eso que no hay un tiempo de ejecución que instalar.
Instalación
macOS y Linux:
curl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.sh | bash
Windows, con los pasos que el proyecto recomienda en lugar de una única línea de comando a ciegas:
Invoke-WebRequest -Uri https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.ps1 -OutFile install.ps1
notepad install.ps1 # read it first
Unblock-File .\install.ps1
.\install.ps1
Las opciones incluyen --skip-config para el binario solo sin configuración de agente, y --dir=<path> para una ubicación personalizada. El instalador detecta automáticamente los agentes de codificación instalados y escribe sus entradas MCP documentadas, además de instrucciones, habilidades y hooks de ciclo de vida donde el cliente los soporta. En macOS, elimina los atributos de cuarentena y firma el binario ad-hoc, por lo que no es necesario el trabajo manual de xattr o codesign.
Luego reinicia tu agente y dile que indexe el proyecto.
Dos banderas de configuración que vale la pena establecer el primer día:
# index new projects automatically on first connection
codebase-memory-mcp config set auto_index true
codebase-memory-mcp config set auto_index_limit 50000
# graph visualization, built into the binary
codebase-memory-mcp --ui=true --port=9749
La interfaz de usuario en localhost:9749 renderiza el grafo de conocimiento en 3D. Es realmente útil para detectar estructuras que no sabías que estaban allí, y es una buena verificación de cordura de que el índice cubrió lo que esperabas.
Si trabajas en muchos repositorios, auto_watch false evita que una sesión registre su proyecto con el observador en segundo plano, y watcher_enabled false desactiva completamente el hilo de sondeo. Esta segunda opción se lee una vez cuando se inicia el demonio, así que detén el demonio después de cambiarla.
Dos cosas a verificar antes de ejecutarlo
Ambas están documentadas por el proyecto, lo cual es una buena señal, y ambas merecen treinta segundos de tu atención.
Microsoft Defender puede marcar un binario de lanzamiento como Trojan:Script/Wacatac.B!ml. El proyecto documenta esto como un falso positivo conocido, señala que típicamente 61 de aproximadamente 62 motores lo devuelven limpio, y apunta que la misma familia de detección afecta al GitHub CLI, llama.cpp, Godot y la propia cadena de herramientas Go de Microsoft. Cada lanzamiento se escanea en VirusTotal antes de su publicación y las notas de lanzamiento enlazan los resultados. Esa es una postura más transparente que la que adoptan la mayoría de los proyectos, y el problema subyacente es un conocido problema heurístico con pequeños binarios nativos sin firmar.
Lee tu base de código y escribe en los archivos de configuración de tu agente. Ese es su trabajo, y el proyecto lo dice claramente en lugar de ocultarlo. Las mitigaciones son reales: el código fuente completo está disponible bajo licencia MIT, los lanzamientos llevan una OpenSSF Scorecard y un nivel de procedencia SLSA 3, y el procesamiento es completamente local. El proyecto también afirma que no realiza ninguna solicitud de red por sí mismo, no busca actualizaciones en segundo plano y no se comunica con el exterior. Las actualizaciones se ejecutan desde el script de instalación ubicado junto al binario en lugar de desde dentro del proceso en ejecución, lo cual es una elección de diseño deliberada explicada extensamente en el README.
La respuesta correcta a ambos es la misma: lee el script de instalación antes de pasarlo a bash, y verifica la afirmación de que es solo local si te importa. Un gran número de estrellas es popularidad, no una auditoría.
Por qué este es el que hay que instalar primero
Todas las demás herramientas en la actual ola de agentes cambian tu flujo de trabajo. Las personas cambian cómo haces las preguntas (prompts). Los árboles de trabajo paralelos cambian cómo organizas el trabajo. El acceso web cambia lo que pides.
Este no cambia nada de cómo trabajas y hace que cada sesión sea más barata y mejor. No hay ningún hábito nuevo que aprender. Lo instalas, indexas el proyecto y tu agente deja de consumir contexto en bucles de grep. En una refactorización larga, la diferencia entre alcanzar tu límite a las 2 p.m. y terminar el día no es sutil.
El efecto en la calidad es la mitad subestimada. Un agente que gasta 400.000 tokens leyendo archivos tiene mucho menos espacio para pensar realmente en tu problema, y su recuerdo de lo que leyó al principio de la sesión se degrada. Responder desde un grafo mantiene el contexto libre. La misma dinámica se aplica a lo que tus herramientas devuelven a ese contexto, que es el tema de las ventanas de contexto de respuesta de herramientas de agente, y es el mismo fallo que hace que las respuestas de API infladas sean caras en los flujos de trabajo de los agentes.
Las herramientas que realmente usarás
Quince herramientas MCP suenan a mucho que aprender. En la práctica, no aprendes ninguna de ellas, porque el agente elige. Lo que vale la pena saber es qué preguntas ahora tienen una respuesta barata, para que empieces a hacerlas.
- El **análisis de impacto** es el de mayor valor y el menos utilizado. Antes de cambiar la firma de una función, pregunta qué se rompe. El grafo rastrea cada invocador en todo el repositorio en menos de un milisegundo, mientras que la versión grep omite el despacho dinámico y se rinde con cualquier cosa indirecta. Esto convierte “creo que es seguro” en una lista.
- El **rastreo de cadenas de llamadas** responde cómo la ejecución realmente llega a un fragmento de código. Útil en repositorios desconocidos y mucho mejor que leer hacia arriba a través de cinco archivos esperando encontrar el punto de entrada.
- La **visión general de la arquitectura** proporciona un mapa estructural sin que el agente lea todo el árbol. Esta es la que hace que la incorporación a una base de código desconocida se sienta diferente, y se combina bien con una persona de exploración de solo lectura.
- La **detección de código muerto** encuentra lo que nada llama. Ejecútala antes de un sprint de limpieza en lugar de discutir sobre ello.
- La **vinculación HTTP entre servicios** rastrea una llamada en un servicio hasta el manejador en otro. En una base de código de microservicios, esta es la diferencia entre un agente que entiende un repositorio y uno que entiende el sistema. También es exactamente donde aparece la brecha contractual que se describe a continuación.
- Las **consultas Cypher** son la vía de escape. Cuando quieres algo específico que las otras herramientas no cubren, puedes consultar el grafo directamente.
El cambio práctico está en cómo haces las preguntas (prompts). Las preguntas que antes evitabas porque costaban 50.000 tokens y dos minutos ahora son casi gratuitas, así que hazlas. “¿Qué llama a esto?” antes de cada refactorización. “¿Cómo se ve la ruta de solicitud para este endpoint?” antes de depurar. La herramienta cambia la economía de la curiosidad, lo cual importa más que cualquier característica individual.
Lo que el grafo sabe y lo que no
Aquí está el límite, y es uno muy claro que vale la pena entender antes de confiar demasiado en la herramienta.
El grafo se construye a partir de tu código. Sabe lo que tu código es. Entre las 15 herramientas se encuentra la vinculación HTTP entre servicios, que rastrea una llamada en un servicio hasta el manejador en otro, y eso es algo genuinamente útil para que un agente lo sepa.
Lo que no puede decirte es lo que dice el contrato. Sabe que existe la ruta /v1/invoices/{id} y qué función la atiende. No sabe que el endpoint devuelve un 409 con un sobre de error diferente cuando se reutiliza una clave de idempotencia, que el campo status tiene exactamente cinco valores válidos, que el cursor es opaco en lugar de un desplazamiento, o que un campo está obsoleto y desaparecerá el próximo trimestre. Nada de eso se puede derivar de la fuente del manejador, porque la mayor parte es un acuerdo en lugar de una implementación.
Así que el agente, ahora equipado con un recuerdo estructural perfecto, sigue adivinando el contrato. Escribe un cliente contra una forma inferida y lo prueba contra un mock que inventó, y todo está en verde hasta el entorno de preproducción (staging).
Por eso Apidog y una herramienta como esta encajan bien en lugar de superponerse:
- El **grafo responde “dónde”.** Qué manejador, qué cadena de llamadas, qué se rompe si esta firma cambia.
- La **especificación responde “qué”.** Esquemas reales, códigos de estado reales, sobres de error reales, leídos por el agente en lugar de reconstruidos. El razonamiento está en usar tu especificación OpenAPI como herramientas para el agente.
- Los **mocks se generan a partir de la especificación**, incluyendo ramas de error que el agente nunca pensaría en falsificar.
- Las **pruebas de contrato fallan en CI** cuando la implementación y el acuerdo divergen, que es el modo de fallo descrito en lo que sucede cuando los cambios de API rompen los agentes de IA.
Hay una simetría agradable en esto. codebase-memory-mcp existe porque leer el código fuente para responder preguntas estructurales es costoso y poco fiable. Lo mismo ocurre con leer el código fuente para inferir un contrato, y la respuesta es la misma: indexar la cosa una vez, en un formato construido para la pregunta. Descarga Apidog si tus agentes están escribiendo clientes de API contra formas que nadie documentó. Relacionado: diseño de esquemas de herramientas de API para agentes y ¿sigues necesitando una herramienta de API en la era de los agentes de IA?.
La memoria del código no es memoria del trabajo
El segundo límite es organizativo.
El índice reside en un directorio de caché en una máquina, bajo una cuenta. Se comparte entre tus sesiones locales de Claude Code, Codex y OpenCode a través de un demonio de coordinación, lo cual es una buena pieza de ingeniería, y se detiene en el borde de esa máquina.
Más importante aún, el grafo es memoria de la base de código, no memoria del trabajo. Puede decirte que el ayudante de reintentos llama al cliente de pagos. No puede decirte por qué el retroceso cambió en julio, quién lo decidió, cuál fue la alternativa o si alguien lo revisó. Esa historia existió en una sesión de terminal que ya no está.
Los equipos sienten esto como una brecha extraña: el agente tiene mejor recuerdo del código que cualquier humano del equipo, y ningún recuerdo en absoluto de las decisiones que lo produjeron.
Sharkly cubre la otra mitad haciendo que la tarea sea el registro duradero en lugar de la pregunta (prompt):
- El **trabajo reside como tareas**, y la salida del agente llega como comentarios a los que puedes responder. El progreso y las llamadas a herramientas se transmiten de vuelta a la tarea. El razonamiento sobrevive a la sesión.
- Un **agente es una configuración guardada**. Instrucciones, entorno de ejecución, habilidades, repositorios, entorno. La configuración donde tu agente tiene el índice, la especificación y los permisos correctos se reutiliza en lugar de reconstruirse por máquina.
- La **ejecución es 'trae la tuya'**. Conectas una Computadora, que puede ser tu portátil, un servidor o un contenedor, y Sharkly usa el Entorno de Ejecución (Runtime) ya instalado en ella. Esto es directamente relevante aquí, porque el índice es por máquina: saber qué Computadora contiene el repositorio indexado es la diferencia entre un grafo 'caliente' y un arranque 'en frío' de tres minutos.
- El **trabajo del repositorio se ejecuta en un worktree separado por tarea**, para que las tareas paralelas contra el mismo repositorio no colisionen.
- Una **tarea en Backlog no inicia una ejecución**, por lo que el trabajo se prepara antes de que se ejecute algo.
- Una **estructura que un equipo ya entiende**: espacios, proyectos, sprints, tareas, con sincronización con Jira.
La memoria de código más la memoria de trabajo es la combinación. Una herramienta le da a tu agente el recuerdo del repositorio. La otra le da a tu equipo el recuerdo de lo que los agentes hicieron en él.
Preguntas frecuentes
- **¿Funciona con Cursor, Codex y OpenCode, o solo con Claude Code?** Es un servidor MCP, por lo que cualquier cliente MCP funciona. El proyecto lista 45 interfaces de agente compatibles y el instalador detecta automáticamente lo que tienes. Si estás evaluando clientes de agente para trabajo con API, consulta nuestro análisis de clientes de API en Cursor y Copilot.
- **¿Mi código sale de mi máquina?** No. El procesamiento es completamente local, y el proyecto afirma que no realiza ninguna solicitud de red por sí mismo y no busca actualizaciones en segundo plano. El código fuente es MIT si deseas verificarlo en lugar de creerlo ciegamente.
- **¿Es realista la reducción del 99% de tokens para mi repositorio?** La cifra del 99,2% corresponde a cinco consultas estructurales, que es el caso más fuerte del grafo. El número revisado por pares en 31 repositorios es 10 veces menos tokens y 2,1 veces menos llamadas a herramientas. Planifica alrededor de 10x. El trabajo con muchas preguntas estructurales lo superará.
- **¿Qué tan grande puede ser el repositorio que puede manejar?** El caso límite declarado es el kernel de Linux con 28 millones de líneas y 75.000 archivos en tres minutos. El límite predeterminado de autoindexación es configurable en 50.000 archivos. Los repositorios de aplicaciones ordinarias se indexan en milisegundos.
- **¿Por qué Defender lo marca?** Es un falso positivo conocido del aprendizaje automático en binarios nativos pequeños sin firmar. El proyecto lo documenta, señala que 61 de aproximadamente 62 motores lo consideran limpio y enlaza los resultados de VirusTotal por cada lanzamiento. La misma familia de detección afecta al GitHub CLI y la propia cadena de herramientas Go de Microsoft.
- **¿Esto reemplaza la lectura del código?** Para preguntas estructurales, sí, y eso es la mayoría de lo que preguntan los agentes. Para comportamiento, casos límite e intención, no. Y para lo que una API devuelve, necesitas una especificación en lugar de cualquiera de las dos, que es el argumento en ¿todavía necesitas una herramienta de API en la era de los agentes de IA?.
Conclusión
Esta es la herramienta menos llamativa en la ola de agentes de 2026 y la que ofrece el mejor retorno. Sin cambios en el flujo de trabajo, sin nuevos hábitos, un único binario nativo y una reducción medida de un orden de magnitud en los tokens que tu agente gasta respondiendo preguntas que no debería tener que buscar con grep. También es más rentable cuando varios agentes se ejecutan a la vez, como es el caso de Orca. Instálalo, indexa tu proyecto, configura auto_index y abre el visor de grafos una vez para ver lo que ha construido.
Luego, ten claros los dos límites. El grafo sabe dónde está tu código, no lo que tu API promete, y esa brecha es lo que Apidog cierra con una especificación, un mock y un conjunto de pruebas. Y recuerda el repositorio, no el trabajo, que es lo que Sharkly cierra haciendo de la tarea el registro en lugar de la pregunta (prompt).
Un recuerdo perfecto del código es una base sólida. No es lo mismo que saber lo que es verdad o lo que se decidió.