Straight answers.
What Graphify is, how it works, and how it differs. Written for people, and for the assistants that read this page.
Common questions
The ones that actually get asked.
Graphify helps you and your coding agent understand how a codebase fits together. It maps functions, files, and their connections so you can investigate a change with source evidence. Start with the hosted app at app.graphify.com, or run the open-source engine locally. You do not need to understand graph terminology to get started.
For example, a repository report may flag a potentially unused price-formatting helper. Open the source, check what the report actually covered, then ask your agent: ‘Verify whether this helper is still used, including dynamic and external callers. Propose the smallest justified change and relevant tests.’ A finding starts an investigation; it does not establish that deleting code is safe.
Connect a repository, open its Wiki for an explanation of the main code areas, or use Ask to investigate one change. Try: ‘What could changing the checkout flow affect? Show me the source evidence and what is uncertain.’ Use the graph when you want to explore the connections. You can read the dashboard without connecting a coding agent.
RAG retrieves fuzzy top-k chunks by embedding similarity and hopes the model reconnects 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. It's the difference between guessing which chunks are relevant and following the actual call and import edges.
Yes, two ways. The hosted product at app.graphify.com has a Free plan with no card, and Pro and Teams above it when you outgrow the caps. The open-source engine is free under the Apache 2.0 license, runs on your machine, and needs no account or API keys. Graph-aware review and formal verification are in every hosted plan. A separate early-access Enterprise layer adds self-hosting in your own infrastructure, SAML single sign-on and legacy migration.
17, including Claude Code, Cursor, GitHub Copilot, Codex, Gemini CLI, and Aider. Run `graphify install --platform <name>` for each assistant you use; bare `graphify install` sets up Claude Code, and each assistant's integration page gives its exact command. The graph is also served over an MCP server that any MCP client can query.
With the open-source engine, no: code is parsed locally with tree-sitter, with no telemetry and nothing uploaded (non-code files use the model backend you configure, which can be local like Ollama). The hosted product builds and keeps the same graph for you in the cloud.
About 40, 33 of them parsed on-device with tree-sitter grammars: Python, TypeScript, JavaScript, Go, Rust, Java, C, C++, C#, Ruby, Kotlin, Swift, PHP, and many more, including variants like JSX and TSX and infrastructure languages like Terraform (HCL). SQL and Terraform need an optional extra: pip install "graphifyy[sql,terraform]".
You can skip installing entirely: start on the hosted product at app.graphify.com and connect a repository. To run the open-source engine yourself, install the Python package with `uv tool install graphifyy`, run `graphify install --platform <your assistant>` to install the skill (bare `graphify install` sets up Claude Code), then type `/graphify .` inside the assistant to build the graph. That takes about five minutes and runs entirely on your machine.
The PyPI package is graphifyy, spelled with a double y: `uv tool install graphifyy`. Other graphify* packages on PyPI are unrelated to this project. The GitHub repository is github.com/Graphify-Labs/graphify and the website is graphify.com.
Two ways, same graph: the CLI (graphify query, graphify path, graphify explain, graphify prs) or the MCP server, which exposes 10 tools including query_graph, get_node, get_neighbors, and shortest_path.
Every edge in the graph carries a provenance tag. EXTRACTED means it is written in the source: a real call, import, or definition the parser read. INFERRED means Graphify worked it out, with or without a model, for example a call matched to a definition that no import proves, or a doc page linked to the code it describes; it carries a confidence score. AMBIGUOUS means the model pass flagged the link as uncertain.
There's no hard size limit: parsing is on-device with tree-sitter, so it scales with how much code you have. A small project indexes in minutes; a large monorepo takes longer and is bounded mainly by disk read and CPU on your machine, not a network round-trip. It's a local batch job, so run it once and keep it fresh incrementally rather than rebuilding from scratch.
The graph reflects the code as of the last index, so it goes stale as you commit. You don't rebuild the whole thing: `/graphify . --update` re-scans only what changed and patches those nodes and edges, which is far cheaper than a full pass. Run it after meaningful changes, or wire it into a hook or CI step so the graph tracks your working tree.
EXTRACTED edges are deterministic: they come straight from the AST, so a call or import edge is as reliable as your parser. INFERRED edges are Graphify's own resolution or a model's link, each with a confidence score; check them before relying on them. The failure mode is a plausible-but-incorrect link. The parser leaves out a call it cannot pin to one target; the model pass marks unclear links AMBIGUOUS.
LSP answers one hop: where is this symbol defined, where is it referenced. A graph answers the questions that span the codebase: what breaks if I change this, every path between two functions, how a config or doc connects to the code. It's persistent, queryable by your AI assistant, and every edge carries a provenance tag, so you get multi-hop blast-radius reasoning rather than a jump-to-def.
ctags builds a flat symbol index for jump-to-definition. Sourcegraph is enterprise code search, run in its cloud or self-hosted, with an MCP server on its Enterprise plan. Graphify builds an actual graph (typed nodes and provenance-tagged edges) that your AI assistant traverses over CLI or MCP, on your machine with the open-source engine or in Graphify Cloud.
No. That's the point. Instead of stuffing files into the model's context and hoping the answer is in there, the assistant queries the graph and pulls back only the relevant nodes and edges for the question. It reads the map, not the whole territory. How much that saves depends on the repository and the question. Graphify's own worked example measured 71.5× fewer tokens per query than reading every file of a 52-file corpus.
Where each answer goes on.
Every one of these expands on something above it.
How it works
The two stages, the three files, and what a typed edge actually claims.
The docs
Install, build, ask, serve. About five minutes, all of it local.
Graph vs RAG
Ten rows on why traversal answers what similarity cannot.
Integrations
The 20+ assistants, the model backends, and what it reads.
Cut agent token costs
How a local code graph replaces the grep-and-read loop, with no proxy.