Who graphify is for#
Developers onboarding to an unfamiliar large codebase
Build the graph once and your assistant already knows the architecture before you ask your first question. Query god nodes to understand what flows through the most-connected symbols. Ask 'who owns billing?' and get a two-hop path through the actual code instead of reading dozens of files.
Skip if:
Skip if the codebase fits in a single prompt window or has fewer than a handful of modules. Graphify's value scales with codebase size; on small projects, grepping and reading files directly is faster.
AI engineers building graph-augmented coding workflows
The graph.json output is a structured, queryable artifact you can build tooling on top of. Integrate it into CI pipelines, serve it via MCP HTTP for team access, or use it as a grounding layer for custom agents. The LOCOMO recall@10 of 0.497 versus mem0's 0.048 documents the quality delta over flat retrieval.
Skip if:
Skip if your questions stay within single-symbol scope. Graphify answers multi-hop questions across the codebase; LSP handles single-hop go-to-definition and is simpler for that use case.
Teams doing PR review on a large monorepo
`graphify prs` provides a terminal PR dashboard with CI status, AI triage, and merge-conflict risk assessment. The graph lets your assistant reason about blast radius when a highly connected symbol changes, which standard diff review cannot do.
Skip if:
Skip if your PRs touch isolated modules with no cross-module dependencies. In those cases, standard diff review covers the analysis without the overhead of maintaining a graph.
Privacy-first teams who cannot use cloud code indexers
Every major commercial code intelligence platform requires shipping source code to a remote server for indexing. Graphify builds the graph locally: your source stays on your hardware, and the only outbound traffic is the queries your assistant already sends to your configured model provider.
Skip if:
Skip if your team is already on a self-hosted Sourcegraph Enterprise instance with SSO and managed indexes. Graphify is better suited to teams that want local-first intelligence without running a full Sourcegraph stack.
The problem it solves#
AI coding assistants navigate codebases by reading files and grepping for symbols. Every session starts from zero: no memory of the architecture, no understanding of which modules call which, no awareness of what breaks if a central symbol changes. On a codebase of any real size, the assistant spends a significant portion of each session re-deriving structure it derived yesterday, consuming tokens to read files it has already read.
The deeper problem is answer quality. Fuzzy similarity search retrieves chunks that look related by embedding distance, then asks the model to reconnect them. When the relevant context spans multiple files and call chains, the model guesses at the links. Answers cite no path, and the reader has no way to check whether the reasoning traced real code or plausible-sounding associations.
How it solves it#
Deterministic AST graph build
Parses your codebase with 36 tree-sitter grammars covering 40 languages. No LLM call, no embeddings, no credits consumed during the build. The output is a local graph.json storing every function, class, and file as an entity, with typed cross-file relationships (calls, imports, inherits, mixes_in) resolved by static analysis. The build runs on your hardware and produces no outbound traffic.
Typed edge provenance
Every relationship in the graph carries a confidence tag. EXTRACTED means the relationship exists at a specific file and line you can open in your editor. INFERRED means it was derived from structure and naming conventions. When your assistant answers from the graph, you can see exactly what was read from source versus what was reasoned.
Skill install in 17 coding assistants
One `graphify install` command registers the /graphify skill with every AI coding assistant it detects: Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, Aider, and 11 more. The same graph.json is also available via an MCP server, letting any MCP-compatible client query it without running the full CLI.
Query, path, and explain commands
Three terminal commands query the graph directly. `graphify query` answers a plain-language question by returning a scoped subgraph. `graphify path A B` traces the shortest hop-by-hop route between any two nodes. `graphify explain` shows all connections for one entity, its source file, community, and degree.
Community detection and god node ranking
Graphify automatically clusters tightly linked code into named modules using the Leiden algorithm, with no LLM call. The GRAPH_REPORT.md highlights god nodes (the most-connected symbols, where a change ripples wide) and unexpected cross-module dependencies, ranked by degree of unexpectedness.
On-device, no telemetry
All code parsing runs locally via tree-sitter with nothing uploaded and no usage tracking. There is no opt-out because nothing is sent. Non-code files (PDFs, docs, images, video) are optionally processed by a model backend you configure, including a local Ollama instance to keep all data on-device.
Strengths and trade-offs#
Strengths
- Zero LLM credits for graph buildThe graph is built with deterministic AST parsing: no model call, no token spend. On the LOCOMO benchmark (n=300), graphify scored recall@10 of 0.497, versus mem0's 0.048 and supermemory's 0.149. Community users reported 71.5x fewer tokens consumed in Claude Code sessions after integrating graphify into their workflow.
- Apache 2.0 with full local operationThe Apache 2.0 license permits commercial use, modification, and distribution without restriction. Unlike Sourcegraph Cody, which requires a Sourcegraph account and ships your repository to a remote indexer for processing, graphify's graph build runs entirely on your own hardware. Your source code never leaves your machine.
- Auditable answers with file:line citationsEvery answer traces to a real graph path, with each edge tagged as extracted or inferred and pointing to a specific file and line number. Vector RAG returns an opaque similarity score; graphify returns a hop-by-hop path you can open in your editor and verify. The difference is following the actual call and import edges versus guessing which chunks are relevant.
- Cross-assistant portabilityOne graph.json works across all 17 supported assistants. Install the skill once and the same knowledge graph is available in Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, and Aider. Teams can serve the graph over an MCP HTTP server so each member queries the same shared artifact without running their own parse.
Trade-offs
- -PyPI package name is graphifyy (double-y)The official package on PyPI is `graphifyy`, not `graphify`. Other `graphify*` packages are unaffiliated. This naming causes installation friction: `uvx graphify` fails because uv reads the first token as a package name. The correct approach is `uv tool install graphifyy` or `uvx --from graphifyy graphify install`.
- -Non-code files require a configured model backendCode is parsed locally with tree-sitter and requires no model call. Docs, PDFs, images, and video require the model backend you configure for a semantic pass. A fully air-gapped setup needs a local Ollama instance to process non-code files; without one, those files are excluded from the graph.
- -Pre-v1 with a high open-issue countGraphify is at v0.9.x and carries nearly 1,000 open GitHub issues. For a project with over 107,000 stars, this reflects rapid community growth outpacing maintainer capacity. Core graph build and query are stable, but platform-specific behaviors and edge features may be inconsistent across the 17 supported assistants.
graphify vs alternatives#
Graphify vs Sourcegraph Cody
Sourcegraph Cody is a commercial AI coding assistant that builds a code intelligence index by syncing your repository to Sourcegraph's cloud infrastructure. Graphify builds a local knowledge graph using deterministic AST parsing with no cloud dependency.
| Feature | Graphify | Sourcegraph Cody |
|---|---|---|
| License | Apache 2.0, open source | Proprietary |
| Code indexing | On-device, tree-sitter AST | Remote (synced to Sourcegraph cloud) |
| Embeddings | None (graph traversal) | Yes (vector search) |
| Self-hosting | Full local operation | Enterprise plan only |
| Assistant support | 17 assistants via skill install | Sourcegraph Cody clients only |
| LLM credits for indexing | 0 | Per-token for some operations |
Graphify is the stronger choice when your team cannot upload source code to a third-party cloud, when you need the same graph to work across multiple AI assistants, or when you want to avoid per-seat billing on code intelligence. The on-device build also means the graph reflects your local working tree rather than a synced snapshot on a remote indexer.
Sourcegraph Cody remains the better fit for enterprises already running a full Sourcegraph deployment. It integrates directly with Sourcegraph's code search, batch changes, and insights features that graphify does not replicate. Teams that need cross-repository code intelligence at large scale with SSO, audit logs, and enterprise support contracts will find Sourcegraph Enterprise the more complete platform.
Graphify vs Atlassian Code Context
Atlassian Code Context is an AI-powered code understanding feature within the Atlassian ecosystem, designed for teams using Jira, Confluence, and Bitbucket. Graphify is a standalone tool with no dependency on any project management platform.
| Feature | Graphify | Atlassian Code Context |
|---|---|---|
| License | Apache 2.0 | Proprietary |
| Platform dependency | None | Atlassian suite (Jira/Bitbucket) |
| Local operation | Yes | No |
| Assistant support | 17 assistants | Atlassian-integrated tools |
| Graph queryable via CLI | Yes | No |
Graphify is the clear choice for teams not in the Atlassian ecosystem, for individual developers, and for any workflow where code must not leave the local machine. It is also the choice when you need to query the graph from a terminal command or an arbitrary MCP client rather than through a product UI.
Atlassian Code Context fits teams already running Jira and Bitbucket who want code intelligence surfaced inside their existing Atlassian project management workflow, with no additional tooling to install or maintain independently.
Install and self-host#
Graphify runs locally as a Python CLI tool with no server or cloud setup required; the PyPI package is `graphifyy` (double-y).
```bash
pip install graphifyy
graphify install
```What it's built on#
- Languages
- Python
- Infrastructure
- AWS
FAQ#
Does my code leave my machine when I use graphify?
No. Graphify parses code locally with tree-sitter: deterministic AST extraction, no model call, nothing uploaded. Non-code files are optionally processed by the model backend you configure, which can be a local Ollama instance to keep everything on-device. The only outbound traffic from a graphify session is the queries your assistant already sends to your own model provider.
How is graphify different from RAG or vector search?
RAG retrieves fuzzy top-k chunks by embedding similarity and asks the model to reconnect them. Graphify builds a real graph and traverses it, so every answer is an explicit path with file:line citations: no embeddings and no vector store. The difference is following the actual call and import edges versus guessing which chunks are relevant by similarity score.
Is graphify free to use commercially?
Yes. The core tool is Apache 2.0 licensed and free for commercial use with no account or API key required. There is a separate enterprise layer in early access for teams, self-hosted on your own infrastructure, covering graph-aware review and formal verification at the merge gate.
Which AI coding assistants does graphify support?
17 assistants as of the current release, including Claude Code, Cursor, GitHub Copilot, Codex, Gemini CLI, and Aider. Running graphify install registers the /graphify skill with every assistant it detects on your machine. The graph is also served over an MCP server that any MCP-compatible client can query.
My editor already has LSP go-to-definition. Why would I need graphify?
LSP answers one-hop questions: where is this symbol defined, and where is it referenced. Graphify answers multi-hop questions: what modules call this function across the entire codebase, what breaks if this god node changes, what is the shortest path between two subsystems. The two tools cover different scopes and work well together.
Similar open-source tools#
codegraph
Transform codebases into queryable knowledge graphs
RAGMeUp
Open source RAG framework for any dataset or LLM
RealtimeSTT
Real-time speech-to-text library with VAD and wake words
code-graph-rag
AI-powered codebase analysis with knowledge graphs
Embabel
Agentic AI framework for the JVM
codebase-memory-mcp
Efficient code intelligence for AI coding agents