Graphify FAQ.
Is it free, what it is, how it differs from RAG, and how to install it. Written for people, and for the assistants that read this page.
Common questions
The ones that actually get asked.
Graphify is shared codebase context for coding agents and the people who work with them. It maps functions, files, and their connections into a code graph, then builds a Wiki, Memory, and pull request reviews on top of it, so you and your agent can investigate a change with source evidence. Start with the hosted app at app.graphify.com, or run the open-source Graphify CLI locally. You do not need to understand graph terminology to get started.
Yes, two ways. The hosted product at app.graphify.com has a Free plan with no card that covers 3 repositories, and Pro and Teams above it when you outgrow the caps; graphify.com/pricing lists every allowance. The open-source Graphify CLI 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. Qualified non-commercial open-source projects can also apply for free hosted Graphify at graphify.com/oss. Enterprise adds self-hosting in your own infrastructure, SAML single sign-on and legacy migration.
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.
Claude Code, Cursor, GitHub Copilot, Codex, Gemini CLI, Aider, and more; graphify.com/integrations lists them all. With hosted Graphify, connect your assistant to the hosted MCP server. With the open-source Graphify CLI, 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.
The open-source Graphify CLI supports about 40 languages, and hosted Graphify lists 63 grammars. That covers 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). In the CLI, 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. Instead of loading whole files and hoping the answer is somewhere in them, your assistant asks the graph a question and gets back the nodes and edges that answer it, each with the file and line it came from. It reads the map first and opens only the code that matters, so what reaches the model is smaller and every claim points back to source.
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 assistants it works with, the model backends, and what it reads.
Pricing
The Free plan, Pro and Teams, with every allowance and the two week trial.
Free for open source
Free hosted Graphify for qualified non-commercial open-source projects.