AI

Graphify: Convert Your Codebase into a Queryable Knowledge Graph with 87.1k+ GitHub Stars

Graphify transforms how AI coding assistants understand your codebase by building a queryable knowledge graph. With 87.1k+ GitHub stars, it's the go-to tool for developers who want AI assistants to reason about entire projects with precision and context.

Tosin Akinosho

— 4 min read

Graphify transforms how AI coding assistants understand your codebase. Instead of grepping through files or relying on vector embeddings, it builds a queryable knowledge graph from your code, documentation, PDFs, images, and videos—all processed locally with zero API calls for code. With 87.1k+ GitHub stars and active development (commits within the last 10 hours), Graphify has become the go-to tool for developers who want their AI assistants to reason about entire projects with precision and context.

What is Graphify?

Graphify is an open-source AI coding assistant skill that maps entire projects into knowledge graphs. Created by Graphify Labs (a Y Combinator S26 company), it works with Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, and 15+ other AI assistants. The core insight is simple but powerful: instead of sending your entire codebase to an LLM or relying on fuzzy vector search, build a real graph where every node is a concept and every edge is an explicit relationship.

Type /graphify . in your AI assistant, and Graphify generates three files: graph.html (an interactive, clickable knowledge graph), GRAPH_REPORT.md (key concepts and suggested questions), and graph.json (the full queryable graph). Code is parsed locally with tree-sitter AST—deterministic, no LLM, nothing leaves your machine. Docs, PDFs, images, and video use your assistant's model for semantic extraction, or a configured API key.

The result: your AI assistant can now query your codebase instead of reading it. Ask "what connects auth to the database?" and get a traced path. Explain a concept. Find the most-connected "god nodes" that everything flows through. All without re-reading files.

Core Features and Architecture

Local-First Code Extraction — Code is parsed with tree-sitter AST across 36 languages (Python, TypeScript, Go, Rust, Java, C++, C#, Kotlin, Scala, PHP, Swift, Lua, Zig, Blade, Elixir, Razor, and more). No LLM, no API calls, no data leaving your machine. The AST extracts explicit relationships: calls, imports, inherits, mixes_in, and more. Every edge is tagged EXTRACTED (explicit in source) or INFERRED (resolved by graphify), so you always know what was read directly vs. derived.

Semantic Extraction for Docs and Media — PDFs, images, videos, and audio are transcribed locally (faster-whisper for video/audio) or sent to your AI assistant's model for semantic extraction. Markdown links and wikilinks become references edges between docs. Comments like # NOTE:, # WHY:, and ADR/RFC citations become first-class nodes linked to the code they explain.

Community Detection and God Nodes — Graphify uses Leiden clustering to split the graph into subsystems (communities), with LLM-free labels. It identifies "god nodes"—the most-connected concepts that everything flows through—so you see what's central to your architecture at a glance.

Query, Path, and Explain Commands — Once the graph is built, you query it instead of reading files. graphify query "" returns a scoped subgraph. graphify path A B traces the shortest path between two concepts. graphify explain "" shows all connections and their confidence tags. All queries run against graph.json with zero API cost.

Multi-Platform Skill Installation — Graphify installs as a skill into Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, Aider, OpenClaw, Kilo Code, Hermes, Kimi Code, and 10+ more. A single graphify install registers the skill; platform-specific commands like graphify claude install make it always-on for that assistant.

Team Collaboration and Git Integration — graphify-out/ is meant to be committed to git so everyone on the team starts with a map. A git merge driver prevents conflict markers in graph.json when two devs commit in parallel—their graphs are union-merged automatically. graphify hook install auto-rebuilds the graph after each commit (AST only, no API cost).

MCP Server and HTTP Transport — Graphify can serve as an MCP (Model Context Protocol) server over stdio or HTTP. python -m graphify.serve graph.json --transport http --port 8080 exposes the graph to a whole team via a single shared process, with optional API key authentication and DNS-rebinding protection.

Get free AI agent insights weekly

Join our community of builders exploring the latest in AI agents, frameworks, and automation tools.

Join Free

Getting Started

Prerequisites: Python 3.10+, and either uv (recommended) or pipx.

Step 1 — Install the package:

uv tool install graphifyy      # install the CLI (double-y package name)
graphify install               # register the skill with your AI assistant

Step 2 — Run it:

/graphify .                    # in your AI assistant, map the current folder

That's it. You get three files in graphify-out/: graph.html, GRAPH_REPORT.md, and graph.json. Open graph.html in any browser to see your codebase as an interactive force-directed graph.

Optional extras: Install with uv tool install "graphifyy[pdf,video,neo4j]" to add PDF extraction, video transcription, or Neo4j push support. The [all] extra includes everything.

Real-World Use Cases

Onboarding New Developers — Instead of reading docs or asking senior devs, a new team member runs /graphify . and gets an interactive map of the entire codebase. They can click nodes, trace paths, and ask their AI assistant questions grounded in the actual architecture.

Code Review and Impact Analysis — graphify prs shows which graph communities a PR touches, so reviewers understand the blast radius before diving into diffs. graphify prs --triage ranks your review queue by impact and risk.

Architecture Documentation — graphify export callflow-html generates Mermaid architecture diagrams from the graph. These auto-regenerate on every git commit if the hook is installed, so your architecture docs never go stale.

Long-Term Memory for AI Agents — Graphify benchmarks show 49.7% recall@10 on the LOCOMO dataset (vs. mem0 at 4.8%, supermemory at 14.9%). For AI agents that need to reason about code over time, a knowledge graph beats vector embeddings.

How It Compares

vs. Vector Embeddings (RAG): Vector search is fuzzy and probabilistic; graphify is deterministic. You get exact paths and explicit relationships. No embeddings to tune, no vector store to manage. Trade-off: graphify requires more upfront parsing, but queries are cheaper and more precise.

vs. LLM-Based Code Understanding: Sending your entire codebase to an LLM is expensive and slow. Graphify parses code locally (free), then uses the LLM only for semantic extraction of docs and media. For pure code reasoning, you never call an API.

vs. Grep and Full-Text Search: Grep finds strings; graphify finds relationships. You can ask "what calls this function?" and get a real answer, not a list of files containing the string. Graphify also understands cross-file imports and inheritance, which grep cannot.

What's Next

Graphify is actively developed—the latest commit was 10 hours ago (July 14, 2026). Recent work includes Streamable HTTP transport for team deployments, progressive-disclosure skill splits for all platforms, and multilingual query support. The roadmap includes deeper IDE integration, real-time graph updates as you code, and expanded language support.

The project is backed by Y Combinator (S26) and has a growing community on Discord. With 87.1k+ stars and 1,122 commits, Graphify represents a fundamental shift in how AI assistants understand code: not by reading files, but by reasoning about relationships.

Sources

Read more