Graphify Testado: Um Índice de Grafos de Conhecimento para o Claude Code
Quase descartei o Graphify como mais um brinquedo com sabor de npx.
O pitch parecia limpo demais: "aponte para qualquer pasta, obtenha um grafo de conhecimento, consulte o grafo em vez de reler arquivos, veja seu consumo de tokens despencar." Tenho um reflexo saudável em relação a qualquer coisa que promete uma redução de ordem de magnitude em um único comando. Na maioria das vezes, a matemática funciona para a demo e desmorona em uma base de código real.
Então eu rodei em um projeto com o qual vinha perdendo discussões há um mês — um repositório de agência com sete módulos de aplicação, um emaranhado de serviços compartilhados e uma pasta docs/ que eu vinha evitando silenciosamente. A primeira construção levou menos de três minutos no meu MacBook. O grafo que ele gerou me contou algo sobre minha própria arquitetura que eu havia perdido por meio ano — uma dependência circular entre a lógica de faturamento e um serviço de notificação que nunca deveriam ter se conhecido.
Esse foi o momento em que parei de tratar o Graphify como um truque de economia de tokens e comecei a tratá-lo como uma ferramenta de revisão de código que, por acaso, também economiza tokens.
Este post é o que aprendi ao rodá-lo em três bases de código reais — o que ele realmente faz, como é a instalação de verdade, onde a matemática de tokens é honesta, onde é marketing, e quais workflows ele mudou para mim. Análise honesta, não um comunicado de imprensa. Se você é um usuário do Claude Code que fica vendo o /cost subir cada vez que pergunta sobre um repositório desconhecido, os próximos vinte minutos podem ser a coisa mais útil que você lê esta semana.
O Problema Que o Graphify Realmente Resolve
Aqui está o workflow no qual a maioria de nós está presa.
Você abre o Claude Code dentro de um repositório que não conhece bem. Faz uma pergunta — "onde esse user_id é validado?" ou "quais serviços tocam o módulo de faturamento?" ou simplesmente "explique como este app está estruturado." O Claude começa a ler arquivos. Ele lê o arquivo que você mencionou. Depois o arquivo que esse arquivo importa. Depois o arquivo que importa o arquivo que importa o arquivo. Vinte chamadas de ferramenta depois, você tem uma resposta e uma janela de contexto que está 70% cheia antes de ter escrito uma única linha de código.
Esse é o imposto de tokens. Cada conversa paga. Cada vez que você inicia uma nova sessão, paga de novo. Cada vez que compacta o contexto, paga de novo. A base de código não muda entre terça e quinta, mas seu agente a relê do zero toda vez.
Busca semântica — grep, ripgrep, embeddings vetoriais — arranha o problema mas não o resolve. grep encontra strings, não conceitos. Embeddings encontram parágrafos que parecem com sua consulta, não os relacionamentos estruturais que seu código realmente tem. Nenhum dos dois captura a resposta para "quais funções o RateLimiter acaba chamando, três saltos de profundidade?" porque essa resposta não está em nenhum arquivo único. Ela vive no grafo entre os arquivos.
A aposta do Graphify é que você deveria construir esse grafo uma vez, armazená-lo ao lado do seu repositório, e deixar seu agente consultar o grafo em vez de rastrear o código-fonte toda vez. O grafo tem aproximadamente dois megabytes de JSON. Sua pasta de código-fonte pode ter centenas de megabytes. O agente lê o grafo e recorre aos arquivos brutos apenas quando realmente precisa escrever ou modificar código.
Se você tem feito pesquisa assistida por IA em grandes bases de código, já sabe por que essa aposta é interessante. O restante deste post é sobre se ela compensa na prática.
A Ideia Central: Um Grafo como Índice
Antes do passo a passo de instalação, quero ter certeza de que você tem o modelo mental correto. A maioria dos posts sobre o Graphify pula essa parte, e é a parte que determina se a ferramenta será útil para o seu repositório.
Um grafo de conhecimento é apenas duas coisas: nós (as entidades — funções, classes, módulos, seções de documentação, conceitos) e arestas (os relacionamentos — chama, importa, herda de, depende de, referencia, é similar a). O Graphify constrói ambos deterministicamente para código e semanticamente para documentação.
Para código, ele usa o tree-sitter para parsear seu código em ASTs e extrair os relacionamentos estruturais sem jamais enviar um token a um LLM. Essa parte é rápida, gratuita e exata. O tree-sitter sabe que a função A chama a função B porque a sintaxe diz isso — nenhuma inferência necessária.
Para documentação, PDFs, markdown e imagens, o Graphify usa um LLM (à sua escolha — Claude, GPT, Gemini, Kimi, DeepSeek, Ollama local) para extrair entidades e inferir relacionamentos. Essa parte é mais lenta e custa tokens inicialmente — uma vez, durante a construção. Depois disso, o grafo persiste. Você paga o custo de extração na primeira vez e o amortiza em cada consulta por semanas.
Então ele executa a detecção de comunidades de Leiden no grafo combinado. Leiden é um algoritmo de clusterização que agrupa nós densamente conectados em comunidades — basicamente perguntando "quais partes deste grafo andam juntas?" A saída é a estrutura natural de módulos do seu repositório, derivada de como o código realmente se conecta, não de como as pastas estão organizadas por acaso. Às vezes essas duas estruturas concordam. Às vezes discordam violentamente, e essa discordância é o sinal mais interessante em toda a construção.
Quando você consulta o grafo, seu agente percorre arestas em vez de ler arquivos de código-fonte. "Mostre-me o fluxo de autenticação" se torna uma travessia de grafo que retorna talvez três mil tokens de nós e arestas estruturados, em vez de cinquenta mil tokens de código-fonte bruto. Essa é a compressão. É onde a economia vive.
A ressalva — e voltaremos a isso — é que consultas ao grafo são ótimas para ler sua base de código e péssimas para escrever nela. Quando você precisa modificar código, ainda precisa do arquivo bruto. O Graphify não substitui sua pasta de código-fonte; ele substitui sua exploração da pasta de código-fonte.
Instalação: Como Realmente é em 2026
O repositório está em github.com/safishamsi/graphify. Há uma peculiaridade que vale conhecer de antemão: o nome do pacote PyPI é graphifyy com y duplo enquanto o nome original é recuperado, mas o comando CLI ainda é graphify. O README é transparente sobre isso — não deixe que te confunda.
O Graphify precisa do Python 3.10 ou mais recente. Se você já está em um stack moderno, está tudo bem. Se ainda está no 3.9, esse é o seu empurrão para atualizar.
Hoje em dia instalo ferramentas Python com uv porque é o único ferramental Python que não me faz querer escrever tudo em Rust. O único comando que te dá uma instalação funcional é:
uv tool install graphifyy
Isso coloca o graphify no seu PATH automaticamente — sem malabarismo com venv, sem cerimônia de pipx. Se preferir pipx, também funciona:
pipx install graphifyy
E se é masoquista e quer pip puro:
pip install graphifyy
…vai precisar ter certeza de que ~/.local/bin (Linux) ou ~/Library/Python/3.x/bin (Mac) está no seu PATH, ou invocar como python -m graphify. Recomendo uv ou pipx — não há vantagem em lutar com o PATH para uma ferramenta CLI.
Verifique se está lá:
graphify --version
Se receber uma string de versão de volta, a instalação está feita. Tempo total na minha máquina: menos de trinta segundos.
Registrando o Graphify como uma Skill do Claude Code
Esta é a parte que realmente torna o Graphify útil dentro do seu agente. O CLI é suficiente. O registro da skill é o momento em que o Claude Code para de pedir para você rodar graphify manualmente e começa a usá-lo por conta própria quando precisa explorar um repositório.
Execute:
graphify install
Esse único comando faz três coisas. Copia o manifesto de skill específico da plataforma para ~/.claude/skills/graphify/ para que o Claude Code possa descobri-lo. Atualiza (ou cria) o CLAUDE.md do seu projeto com instruções para o assistente recorrer ao graphify query antes de recorrer a leituras de arquivos brutos. E registra os comandos de barra — /graphify query, /graphify path, /graphify explain — que você invocará diretamente quando quiser conduzir as consultas por conta própria.
Se você está usando Codex, OpenCode, Cursor, Gemini CLI ou um dos dez ou mais assistentes que o Graphify suporta, o mesmo comando graphify install auto-detecta a maioria deles e escreve o manifesto correto no lugar certo. O README tem uma matriz completa. Se está no Windows ou quer ser explícito, pode passar --platform claude ou --platform codex e forçar o alvo.
Após rodar graphify install, a verificação de sanidade correta é abrir o Claude Code, digitar / e procurar os comandos graphify no seletor. Se estiverem lá, a skill registrou corretamente. Se não, verifique se ~/.claude/skills/graphify/ existe e tem um SKILL.md dentro — esse é o arquivo que o Claude Code lê na inicialização.
Este é o mesmo padrão de carregamento de skills que cobri no meu guia de skills avançadas do Claude Code, e está se tornando o padrão de integração dominante no ecossistema. Skills, não servidores MCP, são o que a maioria das ferramentas de alto valor está sendo entregue em 2026.
Construindo Seu Primeiro Grafo
Agora a parte interessante. De dentro do repositório que quer indexar, execute:
graphify build
É isso. As configurações padrão te darão um grafo funcional. O Graphify escaneia a pasta, entrega arquivos de código ao tree-sitter para extração de AST, entrega docs e outros arquivos ao seu LLM configurado para extração semântica, executa a detecção de comunidades de Leiden e escreve a saída em um diretório graphify-out/.
Mas quase sempre você vai querer ser mais deliberado do que os padrões. As flags que mais uso:
--mode deep— executa um passo de extração semântica mais agressivo sobre docs e comentários. Custa mais tokens inicialmente, encontra mais arestas conceituais (aquelas que não aparecem no AST).--update— reconstrução incremental. Só reprocessa arquivos cujo SHA256 mudou desde a última execução. Essa é a flag que você usará 95% das vezes após a construção inicial.--cluster-only— reexecuta a detecção de comunidades de Leiden no grafo existente sem reextrair nada. Útil quando você adicionou novas arestas manuais ou ajustou parâmetros de clusterização e quer ver o efeito.--no-viz— pula a saída HTML interativa. Construções mais rápidas, saída mais enxuta. Use quando só precisa dograph.jsonpara um agente e não quer olhar a visualização.--watch— mantém o Graphify rodando e reextrai arquivos alterados ao salvar. Não uso isso no desenvolvimento normal porque quero um grafo estável, mas é útil quando você está remodelando ativamente a arquitetura e quer ver a clusterização mudar em tempo real.
Para o repositório de agência que mencionei, a primeira construção foi um graphify build --mode deep e levou cerca de dois minutos e quarenta segundos em uma base de código de dez mil arquivos. O custo em tokens para a extração semântica por LLM foi modesto — menos de um dólar de gasto com API a preços de Sonnet — porque o tree-sitter lidou com a maior parte do trabalho estrutural sem envolvimento do LLM. Execuções subsequentes de graphify build --update após commits pequenos terminaram em menos de quinze segundos.
Uma nota sobre o escopo de extração. O Graphify suporta modos somente código, código+docs e multimodal completo (o modo multimodal acessa PDFs, imagens e até transcrições de vídeo se você instalou as dependências opcionais). Para um repositório de app típico, mantenho em código+docs. O modo multimodal completo é genuinamente útil quando sua pasta docs/ tem diagramas de arquitetura como PNGs e você quer o conteúdo visual extraído — mas custa tokens e tempo, então só ative quando realmente tiver esse tipo de material.
O Que a Saída Realmente É
Quando graphify build termina, você terá um diretório graphify-out/ com três arquivos primários que importam:
graph.html — uma visualização interativa que você abre no navegador. Nós são dimensionados por pertinência à comunidade e conectividade. Arestas são coloridas por tipo de relacionamento. Você pode filtrar por comunidade, por tipo de arquivo, por tipo de relacionamento, e pode clicar em qualquer nó para ver seus vizinhos e ler o código-fonte original. Este é o arquivo que você mostra ao seu time em uma reunião. É também o arquivo que revelou minha dependência circular — eu podia literalmente ver o loop desenhado na tela.
graph.json — o grafo legível por máquina. É isso que seu agente lê quando responde perguntas. Cerca de dois megabytes para um repositório médio. JSON estruturado de nós e arestas que qualquer ferramenta pode parsear. Este é o arquivo que faz o trabalho real de economia de tokens.
GRAPH_REPORT.md — um relatório de auditoria em linguagem simples. Lista seus "nós divinos" (os arquivos altamente conectados que tocam tudo — geralmente um sinal de que há um cheiro arquitetural), links inesperados que o LLM notou que não aparecem em nenhum arquivo único, e um conjunto de perguntas sugeridas que você pode querer fazer ao grafo. A primeira vez que li um desses, foi como receber notas de onboarding de um engenheiro sênior sobre minha própria base de código.
Há também um diretório cache/ com hashes SHA256 por arquivo. É assim que o --update sabe quais arquivos realmente mudaram — é um hash de conteúdo, não um timestamp, então arquivos renomeados mas inalterados não disparam reextração.
Uma Consulta Real, com a Forma Real da Saída
A maneira mais limpa de mostrar como as consultas funcionam é executar uma. No CLI:
graphify query "o que conecta a camada de autenticação ao banco de dados?"
Ou, se você registrou a skill, a mesma coisa dentro do Claude Code:
/graphify query "o que conecta a camada de autenticação ao banco de dados?"
O que volta é um subgrafo — uma resposta estruturada listando os nós relevantes (o middleware de autenticação, o serviço de sessão do usuário, o pool de conexões, o repositório de usuários) e as arestas entre eles (quais funções chamam quais, quais módulos importam quais, quais docs referenciam qual conceito). Em um corpus de quinhentas mil palavras, uma consulta assim tipicamente retorna alguns milhares de tokens, onde ler os mesmos arquivos brutos teria custado centenas de milhares.
Os dois outros comandos que vale memorizar:
graphify path "UserService" "DatabasePool"
Isso retorna o caminho mais curto entre duas entidades nomeadas — a cadeia real de chamadas de função ou importações de módulo que as conecta. Esta é a consulta que te dá análise de impacto de graça. "Se eu mudar UserService, por quais caminhos essa mudança se propaga?" Três comandos, uma resposta.
E:
graphify explain "RateLimiter"
Isso retorna um resumo em linguagem simples de um nó — o que faz, o que o chama, o que ele chama, com quais conceitos está clusterizado na saída do Leiden. É a consulta "o que é essa coisa". A primeira coisa que rodo quando sou colocado em um repositório desconhecido.
Existem padrões de consulta mais ricos — expansão de vizinhança, consultas com escopo de comunidade, busca semântica no subgrafo de docs — e o README os apresenta. Mas esses três (query, path, explain) são os que uso diariamente.
Atualizações Incrementais: Mantendo o Grafo Atualizado
O problema de atualização é a objeção óbvia: "meu código muda todo dia, vou ter que reconstruir isso toda manhã?"
Não. Você vai rodar:
graphify build --update
…e ele vai reextrair apenas os arquivos cujo hash de conteúdo mudou desde a última construção, mesclá-los no grafo existente e reexecutar a clusterização. Em um repositório de dez mil arquivos com um punhado de arquivos alterados, isso leva segundos, não minutos.
Melhor ainda, o Graphify pode instalar git hooks que disparam uma atualização incremental automaticamente em commit ou checkout. Tenho isso habilitado no meu repositório principal de trabalho. Toda vez que faço push, o grafo atualiza. Toda vez que troco de branch, o grafo reflete a estrutura do novo branch. Não penso mais em atualização.
Se você tem acompanhado minha série sobre otimização de tokens, vai reconhecer esse padrão: carregar o trabalho caro antecipadamente, cachear, e recorrer ao cache durante sessões interativas. O Graphify é simplesmente uma implementação excepcionalmente limpa dessa ideia.
Extensões Que Vale Conhecer
Algumas flags de extensão levam o Graphify além de "ferramenta de inteligência de código" para algo mais interessante.
--obsidian gera um vault completo do Obsidian a partir do seu grafo. Cada nó se torna uma nota markdown. Cada aresta se torna um backlink. Você abre o Obsidian, aponta para o vault gerado, e tem um wiki navegável da sua base de código que atualiza toda vez que você reextrai. Este é o workflow que mapeia diretamente para a ideia do LLM Wiki do Karpathy — aprofundei esse padrão no meu artigo sobre RAG com Obsidian do Karpathy e o Graphify é a implementação mais limpa que usei para bases de código especificamente.
--neo4j exporta um arquivo cypher.txt que você pode reproduzir em uma instância Neo4j. Se está construindo um pipeline RAG que precisa de travessia de grafo adequada — raciocínio multi-salto, caminhos ponderados, consultas Cypher reais — esta é sua ponte. Construa o grafo com o Graphify, persista-o no Neo4j, consulte-o a partir da sua aplicação. Usei isso exatamente uma vez, para um cliente que precisava de um graph store de nível empresarial, e funcionou de primeira.
--mcp inicia o Graphify como um servidor MCP stdio. Se está rodando uma configuração onde múltiplos agentes precisam compartilhar o mesmo índice de grafo, MCP é a fronteira certa — seu grafo se torna um serviço, e qualquer cliente compatível com MCP pode consultá-lo. Cobri a tensão mais ampla entre MCP e skills no meu artigo sobre se o MCP está morrendo; o modo MCP do Graphify é um dos casos em que o MCP ainda faz sentido, porque o grafo genuinamente é um recurso compartilhado.
A exportação para Obsidian foi a que mais me surpreendeu. O grafo se torna um artefato navegável — algo que você lê, algo para onde faz link, algo que commita em um repositório wiki. Deixa de ser uma tática de otimização de tokens e se torna documentação que se mantém sozinha.
A Matemática Honesta dos Tokens
Esta é a parte onde a maioria dos artigos fica quieta. Deixe-me ser específico.
O grande número que circula no material de marketing é "71,5x menos tokens por consulta." Esse número é real — vem de um benchmark rodado em um corpus misto que inclui PDFs, imagens e transcrições de vídeo. Corpora multimodais inflam o contagem de tokens da base bruta dramaticamente (você não lê PDFs barato; está pagando para converter e reconverter). A compressão que o Graphify fornece nesse tipo de corpus é genuinamente enorme.
Em um repositório de código puro — que é o que a maioria de vocês realmente tem — a compressão realista é mais próxima de 5x a 10x para consultas típicas de "explore essa base de código". Isso ainda é substancial. Uma consulta que teria consumido cinquenta mil tokens de leituras de arquivo bruto pode consumir cinco a dez mil contra o grafo. Ao longo de um dia de trabalho, isso é dinheiro real. Ao longo de um mês de trabalho em um plano de API pago, é a diferença entre ficar no Sonnet para tudo e se preocupar constantemente com custos do Opus.
Mas a economia não é uniforme. Aqui é onde o Graphify realmente ganha e onde não ganha.
Onde ele ganha muito: Integração em um repositório que você nunca viu. Análise de impacto em um refactoring. Perguntas transversais como "todo lugar onde acessamos o Stripe." Revisão de arquitetura. Qualquer coisa onde você está tentando entender relacionamentos estruturais em vez de ler código específico.
Onde ele não ajuda: Escrever código novo. Modificar funções existentes. Debugar uma mensagem de erro específica. Qualquer coisa onde você precisa do conteúdo fonte real, não do resumo estrutural. Para esses workflows, seu agente ainda precisa ler arquivos brutos — o grafo diz a ele quais arquivos ler, mas não substitui a leitura em si.
Esta é a parte sobre a qual quero ser enfático porque vejo pessoas vendendo demais. O Graphify não é um substituto para sua base de código. É um índice sobre sua base de código. Índices são incríveis para consulta. Eles não são a coisa que você edita. Trate-o conforme e você vai extrair muito valor. Trate-o como bala de prata e vai ficar confuso quando sua sessão de refactoring ainda queimar tokens.
O Que Mudou no Meu Workflow
Após três semanas rodando nos meus próprios repositórios e duas bases de código de clientes, aqui está onde o Graphify acabou no meu cinto de ferramentas real.
Integração em um novo repositório. Primeiro comando em um clone fresco agora é graphify build --mode deep. Em três minutos tenho um grafo e um GRAPH_REPORT.md. Leio o relatório. Abro o HTML. Peço ao meu agente /graphify explain para os três nós mais conectados. Ao fim de quinze minutos tenho um modelo mental melhor do que teria com uma hora de exploração guiada por grep. Esse único workflow já pagou o tempo que gastei aprendendo o Graphify.
Auditorias entre repositórios. Quando um cliente pergunta "essa coisa está realmente usando a biblioteca pela qual estamos pagando?" — rodo o Graphify, consulto o grafo pelos pontos de entrada principais da biblioteca e leio a resposta. Antes isso era uma revisão manual de código de quarenta minutos. Agora são cinco minutos.
Análise de impacto pré-refactoring. Antes de tocar em uma função que espero ser estrutural, rodo graphify path "<nome-da-funcao>" "<coisa-distante>" para ver o que depende de quê. A saída de caminho mais curto captura as dependências que eu teria perdido.
Atualização de documentação. Gero o vault do Obsidian a partir do grafo e commito. A documentação agora é um derivado do código, não um artefato separado que desvia. Quando o código muda, o vault muda. Quando abro o Obsidian para escrever um novo artigo, posso fazer backlink direto para os nós da base de código que estou descrevendo.
Onde ainda recorro ao grep. Quando sei exatamente o que estou procurando — uma string específica, uma mensagem de erro, uma chave de configuração — grep ainda é mais rápido que qualquer consulta ao grafo. O Graphify ganha seu valor em perguntas onde eu ainda não sei qual é o grep certo. É a ferramenta de o que eu deveria estar buscando, não a ferramenta de já sei o que estou buscando.
Onde ainda recorro a um sub-agente. Quando a pergunta é aberta e criativa — "existe uma arquitetura melhor para isso?" — um sub-agente de planejamento com uma janela de contexto longa ainda ganha. O Graphify dá ao sub-agente um contexto inicial melhor (menor, mais denso, com consciência estrutural), mas o raciocínio ainda tem que acontecer no nível do modelo.
Essa combinação — grafo para estrutura, grep para strings, sub-agentes para raciocínio — se compôs de uma forma que eu não esperava. Não são ferramentas concorrentes. São uma pilha. O grafo diz ao sub-agente quais arquivos importam. O grep diz ao agente onde nesses arquivos procurar. O agente faz o raciocínio. Cada camada alimenta a próxima.
Se quer o padrão mais amplo de empilhamento de ferramentas como este, meu passo a passo da pilha de skills do Claude Code cobre a meta-arquitetura que agora uso como padrão.
Onde o Graphify Falha
Devo a você a lista honesta de modos de falha, porque os que encontrei não são teóricos.
Repositórios muito pequenos não precisam dele. Se sua base de código cabe confortavelmente na janela de contexto do Claude, construir um grafo é exagero. O ponto de equilíbrio nos meus testes ficou em torno de vinte mil linhas de código ou cinquenta ou mais documentos markdown. Menor que isso e o custo de construção supera a economia nas consultas.
Linguagens com cobertura fraca do tree-sitter. A extração estrutural é tão boa quanto a gramática do tree-sitter para sua linguagem. As mais comuns — Python, TypeScript, JavaScript, Go, Rust, Java, PHP — são excelentes. Linguagens mais exóticas podem produzir grafos mais finos, com menos arestas de chamada capturadas. Teste com sua stack antes de depender dele.
Repositórios com muita documentação e prosa não estruturada. A extração por LLM para docs é sensível a como a prosa está estruturada. Cabeçalhos limpos, nomes de entidade claros e terminologia consistente produzem ótimos grafos. Dumps de wiki em fluxo de consciência produzem grafos mais ruidosos. Isso é corrigível — reestruture os docs, rode de novo — mas não é mágica.
Custos de tokens na construção inicial para corpora multimodais muito grandes. Se você apontar o Graphify para uma pasta de cinquenta gigabytes de PDFs e vídeos, a primeira construção não será gratuita. Será única, mas não será gratuita. Planeje para isso. Para repositórios de código puro, isso não é um problema.
Precisão semântica depende do modelo. A qualidade das arestas inferidas por LLM depende de qual modelo você configurou. Claude Sonnet, GPT e Gemini produzem resultados sólidos nos meus testes. Modelos locais menores produzem grafos mais finos e ruidosos. Não há benchmarks publicados de precisão-recall para a extração semântica — trate as arestas inferidas como sugestões, não como verdade absoluta.
Nenhum desses é um impedimento. Todos valem ser conhecidos antes de apostar um workflow na ferramenta.
Você Deveria Instalar?
Aqui está minha árvore de decisão, destilada de três semanas de uso diário.
Instale o Graphify hoje se: Você é um usuário do Claude Code, Codex ou Cursor. Trabalha em bases de código maiores que dez mil linhas. Frequentemente é colocado em repositórios desconhecidos. Vê seu consumo de tokens subir durante sessões de exploração. Mantém uma pasta docs/ que gostaria que um LLM realmente lesse.
Espere algumas versões se: Você só trabalha em projetos pequenos. Sua stack usa uma linguagem de nicho com cobertura fraca do tree-sitter. Você não tem um ambiente local Python 3.10+ e não quer configurar um.
Não instale se: Você está procurando uma ferramenta mágica de refactoring. O Graphify não escreve código. Não conserta sua arquitetura. Ele te diz como sua arquitetura é — o que você faz com essa informação ainda é por sua conta.
Para mim, esta é a implementação mais limpa da ideia do Karpathy de que "o LLM é o programador, o wiki é a base de código" que já usei em código real (não apenas notas). Combina naturalmente com a forma como já uso o Claude Code, sobrevive ao uso diário sem quebrar, e o mantenedor está lançando versões rápido o suficiente para que os defeitos que eu apontaria esta semana possam desaparecer na próxima.
O grafo do repositório com o qual comecei este post agora está commitado junto com o código-fonte. Cada PR o reconstrói. Cada documento de onboarding o referencia. A pergunta "como essa base de código se parece afinal" que costumava levar uma hora agora leva noventa segundos. Essa é a mudança de workflow, e é a razão pela qual estou escrevendo sobre o Graphify em vez de seguir para a próxima novidade brilhante no meu feed.
Se você só fizer uma coisa depois de ler isto: abra um terminal, rode uv tool install graphifyy, depois graphify install, depois graphify build dentro de qualquer repositório que você vem evitando silenciosamente. O grafo que ele constrói provavelmente vai te surpreender — e possivelmente te envergonhar, da forma mais útil. Esse é o ponto.
Perguntas Frequentes
O que o Graphify realmente faz?
O Graphify converte uma pasta de código, docs e outros arquivos em um grafo de conhecimento consultável para que seu assistente de IA possa responder perguntas sobre a estrutura sem reler arquivos fonte brutos. Ele usa tree-sitter para parsing determinístico de código e um LLM para extração semântica sobre docs, depois clusteriza o resultado com detecção de comunidades de Leiden. A saída é um graph.json que seu agente consulta em vez de rastrear sua base de código.
Como instalar o Graphify no Claude Code?
Execute uv tool install graphifyy (ou pipx install graphifyy) para instalar o CLI, depois graphify install para registrá-lo como uma skill do Claude Code. O comando de instalação escreve o manifesto de skill em ~/.claude/skills/graphify/ e atualiza o CLAUDE.md para que o Claude Code recorra ao grafo antes de rastrear arquivos brutos. O tempo total de instalação é menos de um minuto em uma máquina moderna.
A redução de 70x em tokens é real?
O número de 71,5x é real mas depende do corpus — vem de um benchmark multimodal misto com PDFs e imagens inflando a base bruta. Em repositórios de código puro, espere aproximadamente 5x a 10x de compressão de tokens em consultas estruturais. Isso ainda é substancial, mas não é o número manchete. A economia se concentra em workflows de exploração e integração, não em escrita de código.
O Graphify substitui o grep ou busca vetorial?
Não — ele os complementa. O Graphify ganha em perguntas estruturais ("o que chama o quê", "caminho mais curto entre dois módulos"). O grep ainda ganha quando você sabe exatamente a string que está procurando. Busca vetorial ainda ganha para similaridade semântica difusa sobre texto longo. A configuração mais forte empilha os três, com o grafo como a camada de índice estrutural.
O grafo pode se manter atualizado conforme o código muda?
Sim. Execute graphify build --update para reextrair apenas arquivos alterados (detectados via hashes SHA256) e mesclar no grafo existente. Você também pode instalar git hooks que disparam atualizações incrementais em commit ou checkout, para que o grafo fique sincronizado com seu repositório sem intervenção manual.
Vamos Trabalhar Juntos
Procurando construir sistemas de IA, automatizar workflows ou escalar sua infraestrutura tecnológica? Adoraria ajudar.
- Fiverr (builds & integrações personalizados): fiverr.com/s/EgxYmWD
- Portfólio: mejba.me
- Ramlit Limited (soluções empresariais): ramlit.com
- ColorPark (design & branding): colorpark.io
- xCyberSecurity (serviços de segurança): xcybersecurity.io
