Graphify: Convierte tu Código en un Grafo de Conocimiento (Guía 2026)

Graphify (Graphify-Labs/graphify) es el repo que no paro de ver arriba en el trending semanal de GitHub este mes. Analiza tu código con tree-sitter y arma un grafo de conocimiento de funciones, clases, imports y llamadas, le suma tus docs y PDFs, y le da a tu agente de código una skill /graphify para consultar ese grafo en lugar de hacer grep archivo por archivo.

Leí el README, la documentación, la ayuda del CLI y el archivo de la skill en la v0.9.95 el 26 de octubre de 2026 para separar lo que corre en local gratis de lo que cuesta tokens, y para ver cuándo un grafo de código le gana de verdad a grep más embeddings. No lo instalé en esta máquina: cada comando de abajo está contrastado con el código fuente y cada número está atribuido.

1. Qué Es: Stars, Licencia y Alcance

Graphify es un CLI de Python más una skill para asistentes. La librería hace el trabajo (detectar archivos, extraer, construir el grafo, agrupar, generar el reporte) y la skill le dice a tu agente cuándo y cómo llamarla. El repo se presenta como una skill /graphify para Claude Code, Cursor, Codex y Gemini CLI con parsing AST local y determinista, cada arista explicada y sin vector store. El README lista más de 20 asistentes compatibles.

⭐

Stars en GitHub

~135.8K

API de GitHub, 26 oct 2026. #6 en el trending semanal con ~6.9K stars esa semana

⚖️

Licencia

Apache-2.0

Pasó de MIT a Apache; los aportes anteriores siguen bajo MIT (NOTICE, LICENSE-MIT)

🏷️

Última versión

v0.9.95

Publicada el 23 oct 2026. Requiere Python 3.10+

📦

Paquete

graphifyy

Con dos “y” en PyPI. El comando sigue siendo graphify

Por qué está en todas partes ahora

El repo se creó el 3 de abril de 2026, y el gráfico de GitHub Trending de Trendshift para él arranca el 3 de julio de 2026 con un mejor puesto de #5. El README lo marca como Y Combinator S26 y promociona un hermano de pago, Graphify Cloud, para grafos siempre activos y entre repos. Este post cubre solo el CLI open source.

Ojo con el nombre del paquete

El README es explícito: el paquete oficial en PyPI es graphifyy con doble y, y los demás paquetes graphify* de PyPI no están afiliados. Varios wrappers MCP de terceros también reutilizan el nombre. Instalá el nombre exacto o partí del repo de GitHub.

2. La Arquitectura en 4 Pasos

Juntando el README, ARCHITECTURE.md y docs/how-it-works.md, el pipeline es detectar, extraer, construir, agrupar, reportar y exportar. Acá lo tenés en cuatro pasos.

🔎

1. Detectar y clasificar el corpus

detect() recorre la carpeta, respeta .gitignore y .graphifyignore, y agrupa los archivos en código, docs, papers, imágenes y video. Un archivo .graphifyrc fija las extensiones ambiguas (.inc, .h, .m) al lenguaje correcto. La skill avisa cuando una ejecución pasa de 500 archivos o 2 millones de palabras y te pide elegir una subcarpeta.

🌳

2. Extraer: un AST para el código, un modelo para lo demás

El código pasa por tree-sitter en local: clases, funciones, imports, llamadas y herencia en unos 40 lenguajes, sin LLM y sin que nada salga de tu máquina. Docs, PDFs e imágenes pasan por una fase semántica que usa el modelo de tu asistente o una API key configurada. El audio y el video se transcriben en local con faster-whisper. Cada archivo lleva una huella SHA256, así que las re-ejecuciones se saltan lo que no cambió.

🧩

3. Resolver, etiquetar y agrupar

Los fragmentos se fusionan en un solo grafo de NetworkX. Cada arista lleva una etiqueta de procedencia: EXTRACTED (explícita en el código), INFERRED (resuelta por graphify, con un score de confianza cuando la creó un modelo) o AMBIGUOUS (marcada para revisión). Leiden agrupa los nodos en comunidades (Louvain si no instalás el extra leiden), y los nodos más conectados se vuelven “god nodes”.

💾

4. Escribir graphify-out/ y consultarlo

La salida es graph.json (formato node-link de NetworkX), GRAPH_REPORT.md y un graph.html interactivo. Los agentes lo consultan con graphify query, path y explain, mediante hooks que los empujan al grafo antes de hacer grep, o mediante un servidor MCP. Las exportaciones a Neo4j y FalkorDB son extras opcionales. No hay vector store.

INFERRED no significa “un LLM lo adivinó”

La documentación de arquitectura dice que la resolución puede inferir una conexión a partir de evidencia estática, así que una arista INFERRED puede venir del resolver del AST y no de un modelo. El vendor auditó a mano 12 aristas INFERRED entre archivos del código de producción de FastAPI el 5 de octubre de 2026 y todas eran correctas, aunque aclara que los helpers de tests con nombres repetidos generan aristas más ruidosas. Es una verificación puntual, no una métrica: tratá INFERRED como una pista que hay que comprobar.

3. Quickstart de 5 Minutos con FastAPI (Offline, Sin API Key)

Elegí FastAPI porque es el corpus que usa la demo del README, así podés comparar tu salida con la suya. Los comandos salen del README y de la ayuda del CLI en la v0.9.95. No los ejecuté, así que probalos primero en una carpeta descartable.

1. Instalá el CLI

# Python 3.10+ and uv (or pipx). The PyPI package has two y's
uv tool install graphifyy
graphify --version

2. Cloná un repo de ejemplo y construí un grafo solo de código

# FastAPI: the same corpus the README demo uses
git clone --depth 1 https://github.com/fastapi/fastapi.git
cd fastapi

# Code only, fully offline: tree-sitter AST, no API key, no LLM
export GRAPHIFY_BACKEND=none        # PowerShell: $env:GRAPHIFY_BACKEND = "none"
graphify extract . --code-only      # writes graphify-out/graph.json
graphify cluster-only .             # communities, GRAPH_REPORT.md, graph.html

3. Consultá el grafo desde la terminal

graphify god-nodes --top 10            # the hubs everything flows through
graphify explain "APIRouter"           # source line, community, edges
graphify path "FastAPI" "ModelField"   # shortest path between two symbols
graphify affected "Dependant"          # reverse traversal: what depends on it
graphify query "how does a request reach dependency injection?" --budget 1500

Lo que muestra el README para FastAPI (salida real, citada)

$ graphify explain "APIRouter"
Node: APIRouter
  Source:    routing.py L2210
  Community: 2
  Degree:    47

Connections (47):
  --> RequestValidationError [uses] [INFERRED]
  --> .get() [method] [EXTRACTED]
  <-- __init__.py [imports] [EXTRACTED]
  ...

$ graphify path "FastAPI" "ModelField"
Shortest path (3 hops):
  FastAPI --uses--> DefaultPlaceholder <--references-- get_request_handler() --references--> ModelField

extract se detiene en graph.json

graphify extract en modo headless escribe graph.json más un archivo de análisis y luego te sugiere correr graphify cluster-only, que escribe GRAPH_REPORT.md y graph.html. Sin backend de LLM, cada comunidad toma el nombre de su nodo más conectado, así que las etiquetas son deterministas. Los comandos de consulta salen con 0 si hay respuesta, 3 si un nombre es ambiguo (listan los candidatos en vez de adivinar) y 4 si nada coincide, lo que los hace fáciles de usar en scripts.

En Windows

En PowerShell usá $env:GRAPHIFY_BACKEND = "none" en lugar de export. Si después de uv tool install no encuentra graphify, la solución del README es uv tool update-shell. La tabla de plataformas del README indica que el instalador de Claude Code detecta Windows solo.

Fijá la versión

Salieron cuatro releases entre el 16 y el 23 de octubre de 2026 (de la v0.9.92 a la v0.9.95), y las tres últimas subieron el esquema de la caché del AST, así que el primer build después de cada upgrade vuelve a extraer todo. En equipo, fijala con uv tool install graphifyy==0.9.95 y actualizá a propósito. También hay un tag v1.0.0 viejo del 5 de abril de 2026; no es la versión actual.

4. Cómo Conectarlo a tu Agente de Código

La terminal sirve para revisar el grafo; lo que importa es que tu agente lo use. Hay tres caminos de integración y el README deja claro que son independientes: la skill, las instrucciones siempre activas y MCP.

Claude Code: skill, hook siempre activo y frescura

graphify install            # registers the /graphify skill (Claude Code by default)
graphify claude install     # CLAUDE.md section + PreToolUse hook: graph before grep
graphify hook install       # git hooks rebuild the graph on commit and checkout

# inside Claude Code
/graphify .

# after a git pull, per the README
graphify update .           # re-extracts changed code, no LLM

Otros agentes (de la tabla de plataformas del README)

• Codex: graphify install --platform codex, y después lo invocás con $graphify (activá multi_agent = true en [features] de ~/.codex/config.toml para la extracción en paralelo)
• Cursor: graphify cursor install (escribe .cursor/rules/graphify.mdc)
• Gemini CLI: graphify install --platform gemini (sección en GEMINI.md + hook BeforeTool)
• VS Code Copilot Chat: graphify vscode install
• OpenCode: graphify install --platform opencode
• Cualquier lector de Agent Skills: graphify install --platform agents (.agents/skills/)

MCP: exponer el grafo como herramientas

uv tool install "graphifyy[mcp]"
claude mcp add graphify -- graphify-mcp graphify-out/graph.json

El extra mcp agrega un servidor stdio, graphify-mcp (también se ejecuta como python -m graphify.serve). En serve.py de la v0.9.95 lista diez herramientas: query_graph, get_node, get_neighbors, get_community, god_nodes, graph_stats, shortest_path, list_prs, get_pr_impact y triage_prs. Agregá --transport http --port 8080 --api-key para compartir un solo servidor con tu equipo.

El hook cambia cómo se comporta tu agente

graphify claude install escribe una sección en CLAUDE.md y un hook PreToolUse que se dispara antes de las búsquedas y antes de leer archivos de código uno por uno con Read o Glob, empujando al agente hacia graphify query. Con GRAPHIFY_HOOK_STRICT=1 bloquea una lectura indexada una vez por sesión. Esa es la gracia, pero con un grafo desactualizado lleva al agente hacia datos viejos. graphify uninstall lo quita de todas las plataformas.

5. Costo, Privacidad y Modelos Locales

El titular es “el código se mapea gratis”, y para el código es cierto. La factura aparece cuando sumás docs, PDFs e imágenes, y cuando contás tokens en cada consulta. Estos son los números del vendor, todos autoreportados.

🆓

Construir el grafo del código

Tree-sitter corre en local. La tabla de benchmarks del README indica 0 créditos de LLM para construir el grafo

🧠

Tokens de tu agente

Docs, PDFs e imágenes

En Claude Code la skill lanza subagentes en paralelo para la fase semántica; extract en modo headless necesita una API key o un modelo local

📉

71.5x vs ~1x

Tokens por consulta vs leer los archivos

Corpus mixto de 52 archivos vs una librería de 6 archivos (docs/how-it-works.md). El ahorro crece con el tamaño del corpus

🎯

70.8% → 82.0%

Cobertura de datos clave en ERPNext

~1M de líneas, n=6 preguntas, agente Claude Opus 4.8, ~140K tokens por consulta (BENCHMARKS.md)

Correr la parte de LLM en local

GRAPHIFY_BACKEND=none (o --code-only) deja el grafo como AST puro. Para docs con requisitos de residencia de datos, GRAPHIFY_BACKEND=ollama usa una instancia local de Ollama en OLLAMA_BASE_URL, y el backend openai llega a llama.cpp, vLLM o LM Studio con OPENAI_BASE_URL y OPENAI_MODEL. La ayuda del CLI recomienda --max-concurrency 1 para LLMs locales.

Tres trampas de privacidad

Primera: la skill lee exactamente una API key; si GEMINI_API_KEY o GOOGLE_API_KEY está definida en tu shell, la fase semántica va a Gemini en lugar de al modelo de tu agente. Segunda: extract en modo headless detecta el proveedor en el orden Gemini, Kimi, Claude, OpenAI, DeepSeek, Azure, Bedrock, Ollama, y Kimi enruta a servidores de Moonshot AI en China; usá --backend para elegir. Tercera: no hay telemetría, pero cada consulta se registra en local en ~/.cache/graphify-queries.log (desactivalo con GRAPHIFY_QUERY_LOG_DISABLE=1).

Cómo leo los benchmarks

El resultado de código cubre seis preguntas: eso es una demo, no un benchmark. LOCOMO y LongMemEval son datasets de memoria conversacional, y ese harness corrió graphify con recuperación híbrida y un embedder local BGE-m3, que no es el camino del CLI “sin embeddings”. La cifra de 71.5x es autoreportada, y el banner de “80% menos tokens” del README es una promesa de Graphify Cloud sin metodología adjunta.

6. Graphify vs RAG Vectorial, PageIndex y GraphRAG

Los cuatro enfoques construyen un índice una vez y lo consultan muchas veces. Se diferencian en qué es el índice, quién lo construye y qué preguntas responde bien.

🔤

Grep + embeddings

Índice: Archivos crudos más embeddings de chunks (a menudo con BM25)
Lo construye: Un modelo de embeddings por chunk; grep no necesita nada
Consulta: Coincidencia exacta o similitud semántica
Mejor para: Cadenas exactas y “buscá código que haga algo parecido a X”

🌲

PageIndex (árbol sin vectores)

Índice: Un árbol de las secciones de un documento largo
Lo construye: El layout del PDF más resúmenes de nodos hechos por un LLM
Consulta: Un LLM razona bajando por el árbol
Mejor para: PDFs largos y estructurados, como informes y manuales

🕸️

Microsoft GraphRAG

Índice: Grafo de entidades más resúmenes jerárquicos de comunidades
Lo construye: Extracción con LLM sobre unidades de texto; su README avisa que indexar es caro
Consulta: Búsqueda global, local, DRIFT o básica
Mejor para: Preguntas temáticas sobre texto narrativo

🧬

Graphify

Índice: Un grafo de símbolos del código, más conceptos de los docs
Lo construye: AST de tree-sitter en local; un modelo solo para docs y multimedia
Consulta: Recorrido BFS o DFS, camino más corto, explain
Mejor para: Preguntas estructurales de varios saltos sobre un codebase

GraphRAG está en modo mantenimiento

El README de Microsoft ahora dice que GraphRAG está mayormente en modo mantenimiento y que no sumará funciones nuevas (último release v3.3.0, 8 de octubre de 2026). Sigue siendo la referencia para grafos de entidades extraídos con LLM, pero sobre código le paga a un LLM para redescubrir lo que un parser lee gratis.

Dónde un grafo de código le gana a grep + embeddings

• “¿Cómo llega A hasta B?”: path devuelve la cadena salto a salto entre archivos, algo que grep solo aproxima con varias búsquedas
• Impacto antes de un refactor: affected hace un recorrido inverso para listar qué depende de un símbolo
• Onboarding en un repo grande y desconocido: los god nodes, las comunidades y GRAPH_REPORT.md te dan un mapa antes de abrir un solo archivo
• Conectar la intención con el código: los comentarios # NOTE: y # WHY: y las citas a ADRs o RFCs se vuelven nodos conectados al código que explican
• Agentes que releen los mismos archivos en cada sesión: el grafo persiste, así que la parte cara no se repite

Mi lectura (inferencia, no una medición)

Las consultas al grafo arrancan de coincidencias de palabras clave con los nombres de los nodos (el flag --seed del CLI existe para forzarlas), así que una pregunta formulada con palabras que el código no usa puede fallar donde los embeddings sí acertarían. Grep sigue siendo más rápido para cadenas exactas como mensajes de error y claves de configuración. En la práctica, yo mantendría grep, sumaría el grafo para la estructura y solo iría a embeddings si la búsqueda por paráfrasis es una necesidad real.

7. Cuándo NO Usarlo

Esta es la parte que un badge de trending no te cuenta.

✅ Encaja bien si...

• Tu repo tiene cientos de archivos o más, y tu agente relee los mismos una y otra vez
• Hacés preguntas estructurales: cadenas de llamadas, dependencias, el radio de impacto de un cambio
• Querés que el código se quede en local: la fase AST nunca sale de tu máquina
• Podés mantener el grafo fresco con git hooks o con graphify update en CI
• Tu equipo va a commitear o compartir el grafo para que todos consulten el mismo mapa

⚠️ Evitalo (o dejalo opcional) si...

• El repo es chico: con un corpus de 6 archivos la propia tabla del vendor muestra ~1x de reducción de tokens, y tu agente puede simplemente leerlo
• El código cambia más rápido de lo que reconstruís: un grafo desactualizado más un hook siempre activo llevan al agente, con total confianza, hacia una estructura vieja
• Tu código depende de dispatch dinámico, reflexión, contenedores de DI o rutas por string que un parser estático no ve; la documentación advierte que la ausencia de un camino no prueba que dos sistemas sean independientes
• Tus preguntas son cadenas exactas (mensajes de error, variables de entorno, claves de config): grep es más rápido y completo
• Tu corpus es casi todo documentación y no podés mandarla a un proveedor de modelos, o no podés pagar la fase semántica
• Es un monorepo enorme: la skill te pide acotar pasados los 500 archivos, graph.html agrega la vista pasados los 5,000 nodos, y los grafos entre repos siempre activos son de la Cloud de pago
• Necesitás una herramienta estable hoy: saca varios releases por semana, y los cambios de esquema de caché obligan a re-extraer todo

Mi postura

Empezá solo con código y offline: no cuesta nada, tarda minutos y GRAPH_REPORT.md por sí solo te dice si el grafo entiende tu repo. Si los god nodes y las comunidades coinciden con cómo pensás el sistema, instalá la skill y el hook. Si parecen ruido, probablemente tu codebase es muy chico o muy dinámico para que esto rinda, y grep sigue siendo la herramienta correcta.

Conclusión

La idea central de Graphify es sólida y barata: un parser ya conoce tu grafo de llamadas, así que dejá que construya el mapa y que el agente lo recorra en lugar de hacer grep. El CLI open source hace eso en local para unos 40 lenguajes, con cada arista etiquetada según cómo se encontró.

Los costos están en los bordes: tokens para la fase de docs, disciplina para mantener el grafo fresco y un hook que cambia los hábitos de tu agente. Tratalo como cualquier índice: construilo sobre tu propio repo, contrastá el reporte con lo que ya sabés y quedátelo solo si le ahorra trabajo real a tu agente.

Sello de verificación

Las stars, el release y la licencia se chequearon contra la API de GitHub, PyPI y los archivos LICENSE y NOTICE el 26 de octubre de 2026 (v0.9.95). Los comandos salen del README, la ayuda del CLI en graphify/__main__.py, cli.py, serve.py y el archivo de la skill en la misma versión. No instalé ni ejecuté el paquete. Las cifras de benchmark son del vendor y autoreportadas.