Ninety thousand, eight hundred and forty nine GitHub stars. Eight thousand eight hundred and sixty forks. A Y Combinator S26 graduate. And a single install command that turns any folder of code, documentation, SQL schemas, PDFs, images, and even videos into a queryable knowledge graph that every major AI coding assistant can reason over. Graphify, built by a team led by Sofi Shamsi under Graphify Labs, has become one of the fastest-growing open-source developer tools of 2026, trending at number two on GitHub as of July 19. The premise is straightforward: stop making your AI assistant read twenty files to answer one question. Give it a map instead.
The install takes roughly thirty seconds. You run uv tool install graphifyy followed by graphify install. Then, inside any supported AI assistant, you type /graphify . and the tool builds a knowledge graph of your entire project. Code is parsed locally through tree-sitter AST extraction with zero API calls. No embeddings, no vector store, no data leaving your machine for code. Documentation, PDFs, and images go through your assistant's model for a semantic pass, but the core code graph is fully offline. The output is three files: a graph.html you can open in any browser with clickable nodes and search, a GRAPH_REPORT.md with highlights and surprising connections, and a graph.json the assistant queries repeatedly without rereading source files.
What Makes Graphify Different From Everything Else
The developer tooling space is crowded with RAG systems, vector indexes, and embedding stores that promise to help AI assistants understand codebases. Graphify takes a fundamentally different approach. It builds a real directed graph where every edge carries a confidence tag, either EXTRACTED for relationships found directly in the source code or INFERRED for relationships derived through graph resolution. This transparency matters because it lets you distinguish between what the tool actually read and what it guessed. No black box, no opaque similarity scores.
The graph model enables capabilities that vector indexes struggle with. You can ask for the shortest path between two functions using graphify path UserService DatabasePool and get a hop-by-hop walkthrough of how they connect across files and modules. You can explain a single node with graphify explain RateLimiter and see all forty seven connections, including which are imports, which are method calls, and which are inferred through resolution. The community detection via Leiden clustering automatically splits large codebases into subsystems with labels, giving you a map of how a project is organized without reading a single line of architecture documentation.
On the LOCOMO benchmark with three hundred repositories, Graphify achieved a recall at ten of 0.497, compared to 0.048 for mem0 and 0.149 for supermemory. Its LongMemEval accuracy on structured code understanding reached 76 percent, tied with dense RAG systems but with zero LLM credits spent on the code parsing side. The benchmark results matter less than the architectural insight: a graph structure captures relationships that similarity search inherently misses. When two functions live in different files but share a data structure, a vector index might never surface the connection. A graph traces it in one hop.
Twenty Platforms, One Skill File
Graphify supports over twenty AI coding assistants out of the box, including Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot CLI, Aider, OpenCode, Kilo Code, Factory Droid, Devin CLI, and even Hermes. Each platform gets a tailored install path. Claude Code and CodeBuddy use PreToolUse hooks that fire automatically before file reads and nudge the assistant toward the graph instead. Codex, OpenCode, and Aider write persistent instruction files like AGENTS.md that provide the same query-first guidance. Cursor writes a rule file with alwaysApply: true. The breadth of platform support is itself noteworthy. Most developer tools pick one or two assistants. Graphify ships skill files for all of them, with a single graphify install command writing the correct config for whichever platform you use.
The team configuration is equally well thought out. Graphify recommends committing the graphify-out/ directory to git so everyone on the team starts with a map on first clone. A git merge driver union-merges graph.json automatically when two developers commit in parallel, preventing the conflict marker problem that plagues generated files. Post-commit hooks rebuild the graph on every commit using only AST extraction, which costs nothing and takes seconds. One person builds the graph, commits it, and the entire team benefits without running a single API call.
The optional extras extend the tool well beyond code. Video transcription via faster-whisper, PDF extraction, Google Workspace integration for .gdoc and .gsheet files, live PostgreSQL schema introspection, Neo4j and FalkorDB push, and an MCP server that exposes the graph over stdio or HTTP for team-wide access. The HTTP server mode is particularly interesting for organizations that want a single shared graph service: python -m graphify.serve graph.json --transport http --host 0.0.0.0 lets the whole team point their IDEs at one URL, with optional API key authentication.
What This Means for AI-Assisted Development
The trajectory of Graphify's growth tells a broader story about how developers interact with AI coding assistants. The first wave of AI coding tools was about autocomplete and chat-based code generation. The second wave, which Graphify exemplifies, is about giving AI assistants structured understanding of existing codebases. The difference is the difference between asking an assistant to write a new function and asking it to modify an existing codebase without breaking anything. The former requires language understanding. The latter requires project understanding.
Graphify's architecture deliberately avoids the embedding pipeline. No vectors, no semantic similarity scores, no opaque relevancy ranking. The graph is deterministic for code. Every edge is either found in an AST or resolved through graph traversal. This makes the tool predictable and debuggable in ways that vector-based systems are not. When the graph misses a connection, you can trace why. When a vector index misses a connection, you can only tune parameters and hope.
The Y Combinator backing and the rapid adoption suggest Graphify is not a side project. The enterprise tier, graphify.com, extends the same graph approach to an organization's entire working context including meetings, documents, and conversations. The open-source tool is the wedge. The platform is the product.
Who This Is For
Graphify is for any developer who uses an AI coding assistant on a codebase larger than a single file. It is for teams that onboard new developers and want them to understand the architecture without reading every module. It is for maintainers of open-source projects who field questions about how their code is organized. It is especially useful for monorepos, microservice architectures, and any project where understanding cross-file relationships is the bottleneck to productivity. If you have ever watched your AI assistant read twenty files before answering a simple question about how two services connect, Graphify is the tool you did not know you needed.
