Graphify · El Mapa, el Cerebro y el Detective de tu Código

Si Claude Code te empieza a sentir lento cuando trabajás con repos grandes, no es la inteligencia del modelo — es que estás haciéndole "ingerir archivo por archivo" cuando tu repo tiene 800 archivos. Graphify resuelve eso convirtiendo cualquier carpeta (código, PDFs, papers, videos) en un grafo de conocimiento que Claude consulta sin abrir archivo por archivo. Resultado medido: 71.5× menos tokens en consultas de arquitectura.

Soporta 25 lenguajes y se integra con Claude Code, Cursor, Codex, Copilot, Gemini CLI y otros 9 agentes. Esta nota cubre los tres modos de uso (Mapa, Cerebro, Detective) y casos donde brilla más.

El problema que resuelve

Cuando le pedís a Claude "explicame cómo funciona la autenticación en este repo":

• Sin Graphify: Claude lee auth.ts, ve que importa session.ts, lee ese, ve que importa db.ts, lee ese, después busca todos los lugares que llaman auth.login(), lee 12 archivos más... Termina gastando 40-80k tokens y la conversación queda saturada.

• Con Graphify: Claude consulta el grafo, ve los nodos y conexiones relevantes, te explica en 500-1.500 tokens.

71.5× de ahorro no es marketing — es la diferencia entre cargar archivos vs. consultar relaciones extraídas.

Cómo funciona

Graphify indexa tu carpeta una vez (toma 1-10 minutos según tamaño) y construye un grafo con:

• Nodos: clases, funciones, archivos, conceptos, párrafos (en PDFs).
• Aristas: imports, calls, references, "es subclase de", "implementa", "menciona".

El grafo se guarda local en SQLite (o Postgres si tu proyecto es enorme). Cuando Claude/Cursor/cualquier agente compatible quiere info, le hace queries al grafo en lugar de leer archivos.

Las consultas típicas:

• "Mostrame todas las funciones que llaman a authorize()" → 10 ms, devuelve lista.
• "Qué clases extienden BaseRepository" → 5 ms, devuelve árbol.
• "Cuál es el path más corto entre User y Payment" → 20 ms.

Cada respuesta es una query SQL contra el grafo, no una lectura de archivos.

Los tres modos

Modo 1: El Mapa — visualización

Modo más simple. Levantás el servidor de Graphify:

graphify serve --port 4000

Abrís http://localhost:4000 y ves el grafo entero como una visualización. Podés:

• Filtrar por tipo (solo clases, solo funciones).
• Buscar nodos por nombre.
• Click en un nodo → ves sus conexiones entrantes y salientes.
• Zoom in/out, drag.

Cuándo es útil: onboarding a un repo nuevo. En 5 minutos ves la macro-estructura — qué módulos existen, cómo se conectan, dónde están los hubs (nodos con muchas conexiones, suelen ser código crítico).

Modo 2: El Cerebro — Claude consulta el grafo

Modo más usado. Una vez indexado, Claude (vía MCP de Graphify) puede consultar el grafo. Le instalás el MCP:

graphify mcp install

Y en CLAUDE.md:

## Consultas de código
Antes de leer archivos individuales para entender el repo, usá las
tools de graphify_query. Ahorra tokens dramáticamente.

Tools disponibles:
- graphify_search_node(name)
- graphify_get_callers(function)
- graphify_get_subclasses(class)
- graphify_shortest_path(from, to)
- graphify_get_module_structure(path)

Después le decís a Claude:

"Explicame el flow de checkout en este repo."

Y Claude usa graphify_search_node("checkout"), encuentra el nodo, hace traversal de las funciones que se llaman, devuelve explicación coherente.

Modo 3: El Detective — diagnóstico de issues

Modo más avanzado. Cuando hay un bug raro, le pedís a Graphify que investigue:

graphify detective --issue "El campo email no se guarda al crear usuario"

Graphify:

1. Busca nodos relacionados con "user creation" y "email".
2. Identifica los caminos donde el flujo pasa.
3. Te muestra el callgraph relevante.
4. Marca nodos sospechosos (funciones con muchas branches, lugares donde el campo se podría perder).

No reemplaza al desarrollador — le da un mapa de dónde mirar.

25 lenguajes soportados

Lista current:

Tier 1 (soporte completo): TypeScript, JavaScript, Python, Java, Go, Rust, C#, C++, Ruby, PHP, Swift, Kotlin.

Tier 2 (soporte parcial): C, Scala, Lua, Dart, Elixir, Haskell, OCaml, R, Clojure.

Tier 3 (experimental): Zig, Nim, Crystal, F#.

También procesa:

• Markdown / MDX.
• PDFs (extrae texto + estructura).
• Papers académicos (Markdown o PDF).
• Videos (con transcripción).
• Notebooks Jupyter.

Caso de uso: auditoría de repo legacy

Patrón que vi varias veces: heredás un repo de 5-10 años, 300k LOC, documentación 0. La primera tarea: entender qué hay y cómo conecta.

Workflow con Graphify:

# 1. Indexar
graphify index .

# 2. Levantar visualización
graphify serve

# 3. Mirar el mapa por 30 minutos
# Identificás módulos centrales (hubs), módulos zombies (sin conexiones).

# 4. Conectar MCP a Claude

# 5. Preguntas exploratorias:
> "Cuáles son los 10 módulos más conectados?"
> "Cuáles son los 10 módulos sin conexiones entrantes (probablemente zombies)?"
> "Cuál es el flow desde HTTP request entrante hasta DB write?"

Lo que antes era "abrir 20 archivos al azar y rezar para entender", se vuelve sistemático.

Caso de uso: onboarding de developer

Un dev nuevo empieza el lunes. Antes:

• Le tirás el repo, "leelo".
• Cuatro días después todavía no entiende qué hace el módulo X.

Con Graphify:

• Le mostrás el mapa.
• Le decís: "este es el módulo central, este es el flow principal, estos son los puntos de entrada".
• En 2-3 horas tiene mental model del repo.

El ahorro de tiempo se multiplica por cada nuevo developer.

Caso de uso: refactor planeado

Antes de refactorizar un módulo:

1. Graphify te muestra qué depende del módulo.
2. Antes de tocar, sabés qué tests vas a romper potencialmente.
3. Sabés a qué otros módulos hay que ajustar.

Sin Graphify: refactorizás, corrés tests, rompés cosas, ajustás, repetís. Con Graphify: planeás cambio sabiendo el blast radius primero.

Integración con los 14 agentes

Lista de agentes con MCP de Graphify oficial:

• Claude Code
• Claude Desktop (vía claude.ai/connectors)
• Cursor
• Codex (OpenAI)
• Copilot (GitHub)
• Gemini CLI (Google)
• Aider
• Continue.dev
• Cody (Sourcegraph)
• OpenCode
• Roo Code
• Cline
• Tabby
• Qwen Coder

Cada uno se conecta diferente. Para Claude Code es vía MCP install. Para Cursor es agregar regla en .cursorrules. La doc cubre los 14.

Performance

Indexación inicial:

• 10k LOC: ~30 segundos.
• 100k LOC: ~3 minutos.
• 1M LOC: ~25 minutos.

Re-indexación incremental (después de cambios):

• Solo los archivos modificados se reprocesan.
• Típicamente <5 segundos.

Storage:

• ~10-50MB por cada 100k LOC en SQLite local.
• ~100MB-1GB en Postgres si querés multi-usuario.

Queries:

• Mayoría <50ms.
• Queries complejas (path finding) <500ms.

Limitaciones

Tres puntos honestos:

1. Calidad del grafo depende del parser

Para TypeScript/JavaScript con tipos bien definidos, el grafo es excelente. Para JavaScript sin tipos (pre-TS), el parser tiene que inferir más, calidad baja. Para Python con annotations, bien; sin annotations, regular.

2. Macros y meta-programming

Lenguajes con macros (Rust, Lisp variants) tienen partes del grafo incompletas porque el parser estático no resuelve macros. Workaround: ejecutar build primero, parsear el output expandido.

3. Cambios estructurales mayores requieren re-index

Si renombrás 50 archivos a la vez, mejor correr graphify index . de cero en lugar de incremental. El incremental se confunde con renames masivos.

Costos

Graphify en sí es gratis (open source MIT). Lo que cuesta:

• CPU local: durante indexación inicial.
• Storage: insignificante para repos medianos.
• Tokens al modelo: la justificación del proyecto. 71× menos.

No requiere API key, no requiere internet, todo local.

Conclusión

Graphify ataca el problema #1 cuando los repos crecen: el costo (en tokens y tiempo) de explorar archivo por archivo. Al pre-indexar como grafo, las consultas pasan de leer 50 archivos a una query SQL.

Si tu repo es chico (<10k LOC) no lo necesitás. Si es mediano (10k-100k), es nice-to-have. Si es grande (>100k), es indispensable. Si trabajás con repos legacy, es lo primero que instalás antes de tocar código.

Tags: graphify, knowledge-graph, claude-code, ahorro-tokens, auditoria, onboarding, codigo