Graphify: convierte tu código y tus archivos en un grafo consultable

De todos los proyectos open source que han aparecido últimamente, hay uno que ha crecido bastante rápido: Graphify. La idea es simple de explicar y bastante interesante de usar: toma todos tus archivos —código, documentos, PDFs, imágenes, videos— y los convierte en un grafo donde todo está conectado, que después puedes consultar en lugar de andar buscando archivo por archivo.

El flujo se resume en una línea:

tu código  →  /graphify  →  knowledge

La promesa es que al indexar tu código en un grafo de conocimiento, tu agente consulta el grafo en lugar de leer archivo por archivo: menos tokens quemados por consulta y respuestas más exactas, porque las relaciones ya están establecidas.

Y una idea que vale la pena tener en mente desde el inicio: esto es para gente que lee más de lo que escribe. Ya volveremos a este punto.

Enlaces:

• Web oficial: graphify.com
• Repositorio: github.com/Graphify-Labs/graphify

En este artículo te doy un resumen de qué se trata, cómo instalarlo y, sobre todo, para qué sirve realmente (y para qué no).

De dónde viene la idea

Antes de entrar al proyecto en sí, vale la pena entender el concepto, porque Graphify no lo inventó: es una implementación de una idea que ya se venía mencionando.

El origen es un post de Andrej Karpathy de alrededor de abril de este año, sobre lo que él llama LLM knowledge bases. Ahí explica que cada vez que está aprendiendo un tema o investigando algo, alimenta su propia wiki. La idea es esta: tú tienes un proyecto conformado por documentos de todo tipo —artículos, investigaciones, código, imágenes, videos, lo que él llama archivos "en crudo" o raw—. Todo eso lo pasas por un modelo que en lugar de dejarlos dispersos los categoriza dentro de conceptos.

Así, en vez de tener archivos sueltos, empiezas a agruparlos, obtienes relaciones entre ellos y luego los visualizas en alguna interfaz (Karpathy usa Obsidian). ¿Y todo esto para qué? Para poder hacer consultas. Preguntas algo sobre un tema y como todo está relacionado, se puede navegar por el grafo e ir respondiendo.

Es una alternativa a montar un RAG, pero de forma mucho más sencilla. La respuesta puede terminar siendo bastante similar, solo que esto es mucho más simple de mantener: al final son archivos conectados entre ellos.

Hay varios proyectos que nacieron de esta base —hay uno de Google, otro de Microsoft, y varios más dispersos en el open source—, pero Graphify es de los que más relevancia ha ganado en los últimos meses, principalmente por su facilidad de uso.

Un punto importante: no está ligado a ningún agente en específico. Puedes usarlo con cualquier agente o harness de IA, y con cualquier herramienta de frontend para visualizarlo.

Requisitos previos

Antes de instalar necesitas dos cosas:

1. Python 3.10 o superior. Verifica con:

python --version

2. uv (o pipx), que es el gestor para crear entornos virtuales de Python. El comando de instalación está en su documentación para Mac, Linux y Windows. Se instala rapidísimo.

Instalación

Ubícate dentro del proyecto donde quieres usar Graphify y ejecuta:

uv tool install graphifyy

# alternativa
pipx install graphifyy

Ojo con esto: el paquete en PyPI es graphifyy con doble "y". El comando de la CLI sí es graphify.

Luego registras el skill:

graphify install

Vas a ver un mensaje de bienvenida con un resumen del proyecto. Aquí tienes dos opciones: este comando lo instala para todos los agentes que tengas disponibles en tu computadora, o puedes instalarlo solo para algunos, con comandos por plataforma:

graphify install --platform codex
graphify cursor install
graphify install --platform opencode

Soporta Claude Code, Codex, Cursor, OpenCode, Gemini CLI, GitHub Copilot y 20+ más.

Generando el grafo

Ahora abres tu agente de IA y lanzas el comando. En Claude Code escribes / y aparece graphify. Le pasas un punto para indicarle que escanee el proyecto actual:

/graphify .

Aquí es donde conviene ser honesto: este proceso consume bastantes tokens. El agente de IA es el que escanea el código una sola vez y arma el grafo, y para acelerar lanza múltiples subagentes en paralelo.

En mi caso lo corrí sobre un monorepo que, sin ser excesivamente grande, tomó alrededor de 17 minutos y consumió aproximadamente un millón de tokens. Antes de empezar te pregunta si quieres analizar el proyecto entero o seleccionar solo alguna aplicación específica del monorepo, lo cual ayuda bastante a controlar el gasto.

Al terminar obtienes una carpeta graphify-out/ con tres archivos principales:

También te reporta la cantidad de nodos, comunidades y el costo en tokens.

Lo más importante: los nodos NO son archivos

Este es el punto que más se malentiende, así que vale la pena detenerse.

Cuando abres graph.html y ves esa enorme cantidad de nodos distribuidos, es fácil asumir que cada nodo es un archivo y que las líneas representan qué archivo importa a cuál. No es así.

Lo que el grafo une son conceptos. Toma una gran cantidad de archivos que pueden estar agrupados y crea un nodo llamado, por ejemplo, public, o contextual animations. Va separando por grupos temáticos, no por estructura de carpetas.

A la derecha de la visualización vas a ver una sección llamada communities. Estas son las distintas secciones que se van formando automáticamente: table and dialogs, admin tables, skills docs, etc. Y aquí está lo interesante: los archivos dentro de una misma comunidad no necesariamente están en la misma carpeta. Pueden estar unos en frontend y otros en backend. La idea del grafo es justamente mostrar que están relacionados aunque vivan en lugares distintos del proyecto.

Un detalle práctico: el graph.html que se genera puede ser un archivo enorme. En mi caso lo abrí en Neovim y ni siquiera cargaba hasta el final. Tenlo en cuenta.

Los comandos de consulta

Al final, la única razón de armar todo esto es para poder consultarlo. Estos son los comandos principales.

update

Actualiza el grafo cuando añades más archivos y quieres que se reflejen:

graphify update ./src

query — el más sencillo y el más útil

Consultas cosas del repo en lenguaje natural:

graphify query "de qué forma funciona la autenticación del CLI"

Lo que pasa aquí es lo interesante. Usando el skill, lo primero que hace es cargar las referencias de dónde están esos nodos. No usa el flujo típico de Claude Code de leer un archivo, buscar el otro, leer el siguiente, y así. En su lugar usa a Graphify como intermediario.

El resultado: se analiza toda la cadena. De qué forma esa autenticación se relaciona con el backend, con el frontend, y lo sabe sin tener que ir buscando archivos él mismo. El grafo ya le da la información.

Esto tiene dos beneficios concretos: ahorras tokens y la respuesta puede ser más exacta, porque las referencias ya están establecidas entre sí. En mi prueba me explicó cómo funciona el login, de dónde se obtienen los datos y qué otros archivos lo están utilizando.

path — la ruta más corta entre dos puntos

Sirve para saber de qué archivo a qué archivo va la ruta, y qué nodos se van incluyendo en el camino:

graphify path "TaskCommand" "PrismaSchema"

Aplica el algoritmo de ruta más corta, que es posible justamente porque estamos sobre un grafo. En mi prueba me indicó que schema.prisma no era parte del grafo, y para llegar tuvo que hacer un salto de nueve nodos: desde task.ts, luego a una función outputItem, luego a una tabla, y así.

La respuesta fue honesta: no había un camino real entre la aplicación de consola y la API, estaban desconectados estáticamente. Y eso también es información útil.

explain

graphify explain "RateLimiter"

¿Para quién es esto realmente?

Aquí viene la parte donde conviene bajar las expectativas, porque esto no es magia. No es que consultas algo y te da la respuesta perfecta de inmediato. Es una forma sencilla de saber cómo se están conectando muchas partes del código de un proyecto.

Para código, la utilidad aparece sobre todo cuando el proyecto es muy grande. Si tienes un proyecto pequeño donde recién estás empezando, con algo vibe-codeado, por lo general no necesitas esto: estás haciendo mucho más trabajo del necesario cuando las búsquedas pueden resolverse con los comandos que ya trae Claude Code o Codex. Dicho de otra forma: si tu código es grande, esto tiene sentido; si no, es demasiado.

Y volviendo al punto del inicio: esto es para gente que lee más de lo que escribe. El grafo se paga solo cuando el trabajo consiste en entender, rastrear y relacionar material existente, no cuando consiste en producir código nuevo.

Donde le veo mucho más sentido es en investigación. Y hay una razón de contexto importante: Karpathy no es desarrollador de software, es investigador de IA. Lo que él hace son reportes y análisis, no tanto creación de software. Entonces esto encaja mucho mejor si:

• Trabajas en Data Science
• Estás armando una tesis y vas incluyendo cada vez más archivos
• Quieres consultar datos cruzados de todo el material que has ido juntando
• Necesitas un segundo cerebro o una wiki personal que crece con el tiempo

A medida que vas añadiendo más archivos, videos o documentos, el grafo va creciendo con más conocimiento.

No solo HTML: otras formas de guardar el grafo

La visualización en HTML es solo una de las opciones. El proyecto en realidad funciona como un plugin conector entre tu código y plataformas que soportan modelos basados en grafos:

• Obsidian — una de las opciones más populares, genera los archivos y los enlaza. Incluso puede quedar alojado en la nube si tienes cuenta de Obsidian.
• Neo4j o FalkorDB — bases de datos que soportan grafos nativamente.
• GraphML para Gephi o yEd.
• Servidor MCP para acceso estructurado desde tu agente.

Esto conecta directamente con lo que menciona Karpathy en su post: en lugar de obtener respuestas en la terminal como texto plano, puedes renderizar archivos, markdowns, crear slides o representaciones a partir de los datos conectados. Es otra forma de organizar y representar los archivos que ya tienes.

Conclusión

Graphify no es el único proyecto en este espacio, pero sí es una de las formas más sencillas de empezar con todo esto. El flujo es directo: instalas, ejecutas un comando, esperas el escaneo y a partir de ahí consultas.

Lo que hay que tener claro:

• ✅ Vale la pena en proyectos grandes o para investigación acumulativa
• ✅ Ahorra tokens en el uso diario y da respuestas más precisas
• ⚠️ El escaneo inicial cuesta tokens de verdad (un millón en mi caso)
• ⚠️ En proyectos chicos es sobre-ingeniería innecesaria
• ⚠️ Los nodos son conceptos, no archivos — no lo leas como un árbol de dependencias

Hay más alternativas viniendo por parte de empresas grandes, y todas terminan generando la misma salida: este grafo. Pero por facilidad de entrada, Graphify es un buen punto de partida.

Si tienes dudas o quieres profundizar en algún tema, déjamelo en los comentarios.

Recursos

• graphify.com — web oficial
• Graphify-Labs/graphify — repositorio en GitHub (la guía más actualizada)
• Documentación de uv — instalación del gestor de entornos
• Post de Andrej Karpathy sobre LLM knowledge bases — el concepto de origen
• How to Use Graphify: Turn Any Folder Into a Knowledge Graph — guía complementaria en Medium