# Graphify

> Graphify is the knowledge graph control plane for enterprise software: a code knowledge graph your AI coding assistant queries instead of grepping. It parses a codebase on-device with tree-sitter (36 code languages, plus Markdown, PDFs, Office documents, SQL schemas, live PostgreSQL and Terraform) into one typed, traversable graph. Every answer is an explicit path with real file:line citations, and every edge is tagged EXTRACTED, INFERRED or AMBIGUOUS, so an agent always knows what was found in the code and what was guessed. Use it hosted at https://app.graphify.com (Free, Pro, Teams), run the open-source engine yourself (Apache 2.0, no account, no telemetry), or self-host the Enterprise layer inside your own network, which adds automated legacy migration and SAML single sign-on. Differential formal verification and graph-aware pull-request review are in every plan.

Built by Graphify Labs, a Y Combinator S26 company. Official channels, and the complete list: the website https://graphify.com, the source at https://github.com/Graphify-Labs/graphify, and the PyPI package `graphifyy` (double y). graphify.net, app.graphify.net, and graphiffy.com are not affiliated with or operated by Graphify Labs.

Public Wikidata entity references:

- [Graphify Labs on Wikidata](https://www.wikidata.org/wiki/Q141604132): the organization that makes Graphify.
- [Graphify on Wikidata](https://www.wikidata.org/wiki/Q141604074): the software distributed as the `graphifyy` package on PyPI.

Every page on this site has a markdown twin for agents: append .md to any URL (for example https://graphify.com/vs/rag.md), or send `Accept: text/markdown`. The exhaustive index, including per-problem Q&A, the full CLI and MCP reference, pricing, security controls, every assistant, language, and glossary term, is at https://graphify.com/llms-full.txt.

## The six problems Graphify is built around

Fifty conversations with Fortune 500 CTOs and platform teams came back as the same six problems. The product is organised around them, and so is this file.

- [Use cases: the six problems](https://graphify.com/use-cases): Each problem, what the graph does about it, and one job a graph does worse
- [Enterprise: which of these is costing you](https://graphify.com/enterprise): The early-access form asks the same six questions and scopes a self-hosted deployment around the answer
- [What is Graphify?](https://graphify.com/what-is-graphify): The plain-language definition, what it is not, and where it stops

## 1. We cannot prove what the AI told us

Answers about your own code come back as opinions. In safety, audit or regulated work, an answer without evidence behind it is worthless. Graphify makes every answer a path you can open: each hop is a real node in your code with a file and line, and each edge carries a provenance tag. EXTRACTED means the parser found the call, import or definition in the AST. INFERRED means a model connected it (a doc to the service it describes). AMBIGUOUS means the evidence could not be resolved (dynamic dispatch, reflection) and the edge is kept but flagged. For changes to code, differential formal verification goes further: a solver looks for an input on which the old and new versions of a function disagree. Proven means no such input exists. Changed means here is the input and what each version returns, plus a regression test. Unknown is reported as unknown, never rounded into either.

- [Formal verification](https://graphify.com/formal-verification): Prove it, or break it. The old code is the spec; you write nothing
- [Verification docs](https://docs.graphify.com/platform/verification): The four verdicts (equivalent, distinguished, may_equivalent, unsupported), the six-tier ladder from Z3 SMT down to an honest abstain, per-language soundness (Python unbounded; C, C++ and Java bounded via CBMC and JBMC), the GitHub check, and the measured decisive rates
- [Confidence tags](https://graphify.com/glossary/confidence-tags): What EXTRACTED, INFERRED and AMBIGUOUS mean and how to lean on each
- [Security: every claim here is checkable](https://graphify.com/security): No LLM in the verification path; local solvers and network-denied sandboxes

## 2. Nobody has one map of the code

Hundreds of repositories, teams across countries, no shared view. Changes cross boundaries invisibly and the blast radius only shows up after shipping. Graphify builds one persistent graph across every repository you point it at, reindexed on every push, and serves it to all 17 supported assistants over MCP so every engineer and every agent reads the same map. A generated architecture report names the communities (real subsystems such as auth or billing), the god nodes (the modules everything imports, where change is riskiest) and the connections nobody expected. Honest boundary: it maps the repositories you point it at, it is not org-wide code search over thousands of repositories, and it does not judge the architecture.

- [Concepts: how the graph is built](https://graphify.com/concepts): Tree-sitter AST extraction on-device, provenance on every edge, why traversal beats embeddings
- [Solutions for platform teams](https://graphify.com/solutions/platform-teams): One shared reading of a large codebase, the generated map, one layer behind every assistant, and what it is not
- [MCP server](https://graphify.com/mcp): The graph over the Model Context Protocol; every tool accepts a project_path so one server answers for a whole workspace of repositories
- [Glossary: community](https://graphify.com/glossary/community) and [god node](https://graphify.com/glossary/god-node): The two structures the map is read by
- [Graphify vs Sourcegraph](https://graphify.com/vs/sourcegraph): A platform your engineers search, against memory your assistant queries

## 3. The review passes, then the change breaks something else

A diff shows the lines. It does not show what depends on them. Reviewers approve, and the real impact turns up in production. Graphify reads a pull request against the graph instead of its diff: what the changed functions are called by, what calls those, and which configs and tests name them (the blast radius), plus which other open branches are reaching for the same nodes (the merge nobody sees coming), and the order the queue should merge in. On the hosted product the review is waiting when you open the PR; Free includes 15 PR reviews/month; Pro includes 400/day and Teams 700/day. It comments on reach, not on style. Combined with verification it becomes a merge gate: advisory by default, blocking when you set it.

- [PR reviews: review the change, not the diff](https://graphify.com/pr-reviews): What it reaches, what else is reaching, and where each claim came from
- [CLI: graphify prs](https://docs.graphify.com/reference/overview): `graphify prs` maps open pull requests onto the graph; `--triage` ranks the review queue; `--conflicts` flags two branches editing the same node
- [MCP tools: list_prs, get_pr_impact, triage_prs](https://docs.graphify.com/reference/mcp-tools): PR impact as graph data any MCP client can read
- [Blast radius](https://graphify.com/glossary/blast-radius): Everything transitively affected by a change
- [Graphify vs CodeRabbit](https://graphify.com/vs/coderabbit): A reviewer that catches it in the pull request, against a graph that knows it while writing

## 4. Token spend climbs every quarter with nothing to show for it

Seats, tokens and GPUs keep going up, with no proof of which context layer earns the bill and no way to govern how any of it gets used. An assistant that queries the graph stops pasting whole files into context: it pulls back only the nodes and edges the question needs, so retrieval is paid once at parse time rather than per session per engineer, and every query is a line you can account for. Community-measured figures, linked to their authors on the site: 79x fewer tokens on a 496K-token codebase with zero vector database (Steve Scargall, MemVerge), and 71.5x fewer tokens per session in a Claude Code and Graphify setup (lucasrosati). Graphify did not run these numbers; the people linked did. Query output is budgeted (default 2,000 tokens, tunable), and the Enterprise layer adds SSO and exportable audit logs so there is a trail for every query.

- [Token reduction](https://graphify.com/glossary/token-reduction): The context-window savings from answering with structure instead of files
- [Customers and community figures](https://graphify.com/customers): Every number links to the person who measured it
- [FAQ: doesn't querying the graph just eat tokens too?](https://graphify.com/faq): It reads the map, not the whole territory
- [Solutions for engineering leaders](https://graphify.com/solutions/engineering-leaders): Lower assistant spend, faster onboarding, fewer regressions, verification in early access
- [Graphify vs RAG](https://graphify.com/vs/rag): Re-embedding and storage grow fast; edges are cheap and updates are incremental

## 5. The answer is never only in the code

It sits across repositories, wikis, contracts and decades of documents. Nothing spans both sides, so people stitch it together by hand and get it wrong. Graphify puts code and non-code in the same graph: code is parsed deterministically by tree-sitter and tagged EXTRACTED; Markdown and docs, PDFs, Office files, images, transcribed audio and video, SQL schemas, live PostgreSQL and Terraform are read by the model backend you choose (Claude, OpenAI, Gemini, DeepSeek, Kimi, AWS Bedrock, Azure OpenAI, or a local Ollama or any OpenAI-compatible server) and tagged INFERRED. Jira and Atlassian linking is part of the Enterprise early-access track, so the decision sits beside the code it caused. The graph exports to Neo4j, FalkorDB, GraphML, Obsidian, SVG and Mermaid. Honest boundary: for fuzzy search over a large body of prose, embeddings are the better tool and Graphify does not try to beat them.

- [Integrations: assistants, backends, data sources, exports](https://graphify.com/integrations): 17 assistants, 8 LLM backends, 9 data sources, 6 export targets
- [Graphify vs vector databases](https://graphify.com/vs/vector-databases): A call edge exists because the parser found the call, not because two chunks embed near each other
- [Enterprise: Jira and Atlassian, engineering digest](https://graphify.com/enterprise/access): Tickets and decisions linked into the graph

## 6. We re-learn the codebase on every engagement

Each client project or modernization starts from scratch by hand. It eats the margin, and none of what is learned compounds into the next one. Graphify builds the map once and keeps it current: a code change re-parses only the changed file, with no re-embedding and no full re-index, and a git hook rebuilds on every commit. New engineers and new engagements start from the generated architecture report (communities, god nodes, surprising cross-community connections) instead of a directory tree, and the MCP server exposes the same report, stats and suggested first questions to the assistant. The Enterprise form asks what the code is, from COBOL or mainframe and SAP or ERP through embedded C and C++, Java or .NET, to modern cloud, because modernization is where this problem is most expensive.

- [Quickstart](https://docs.graphify.com/quickstart): Install, build the graph, read GRAPH_REPORT.md, query. About five minutes, all of it local
- [Tutorial](https://docs.graphify.com/guides/first-graph): The first run step by step, and how to read the three output files
- [FAQ: how stale does the graph get, and what does re-indexing cost?](https://graphify.com/faq): `/graphify . --update` re-scans only what changed
- [Solutions for platform teams](https://graphify.com/solutions/platform-teams): Tribal knowledge does not scale; a map that is generated does

## Get started

- Hosted: connect a repository at https://app.graphify.com. Free plan, no card. The graph is built and kept current for you and served to your assistant over MCP at https://api.graphify.com/mcp (Streamable HTTP, OAuth sign-in on first connect, no key to paste, every tool read-only)
- Self-run: `uv tool install graphifyy` (or `pipx install graphifyy` / `pip install graphifyy`; Python 3.10 or newer), then `graphify install` to register the `/graphify` skill with the assistants it detects, then `/graphify .` inside the assistant to build the graph
- Outputs in `graphify-out/`: `graph.html` (interactive graph), `GRAPH_REPORT.md` (architecture report), `graph.json` (machine-readable graph)
- Query: `graphify query "what connects auth to the database?"` · trace: `graphify path "UserService" "DatabasePool"` · explain: `graphify explain "RateLimiter"` · pull requests: `graphify prs --triage --conflicts`
- Keep it fresh: `/graphify . --update` (incremental) · `/graphify . --mode deep` (multi-pass, more inferred connections)
- Local MCP server: `python -m graphify.serve graphify-out/graph.json` (stdio) or `--transport http --port 8080` (shared). Ten tools: query_graph, get_node, get_neighbors, shortest_path, get_community, god_nodes, graph_stats, list_prs, get_pr_impact, triage_prs
- Disambiguation: the package is `graphifyy` with a double y; `uvx graphify` fails because there is no PyPI package named graphify. Other graphify* packages are unrelated

## Pricing

- [Pricing](https://graphify.com/pricing): Free includes 3 repositories; all paid plans include unlimited repositories. Free: $0, 25,000 nodes per repo, 10 push builds per repo/UTC day, 15 PR reviews per workspace/month, 1 formal verification run/day, with 2 PR reviews and 1 verification run at a time; no card. Pro: $15/month billed monthly or $10/month billed yearly ($120/year) for one developer, uncapped graph size, 100 push builds per repo/day, 400 PR reviews/day and 400 verification runs/day; 10 PR reviews and 2 verification runs at a time. Teams: uncapped graph size, 100 push builds per repo/day, 700 PR reviews/day and 800 verification runs/day; 20 PR reviews and 2 verification runs at a time, with shared graphs, central billing, and a dedicated Slack support channel, minimum 2 seats. For the first 100 teams, $29/seat/month billed monthly or $20/seat/month billed yearly ($240/seat/year); after the first 100, $40/seat/month billed monthly or $28/seat/month billed yearly ($336/seat/year). Annual plans are billed once per year; card prices show monthly equivalents. Pro and Teams include a two-week trial with a card required. All plans retain shared build concurrency, memory and request-rate limits; see the pricing FAQ. Enterprise: custom and licensed per developer seat, with self-hosting, automated legacy migration, security and compliance, SSO/SAML, GitHub Enterprise support, a dedicated Slack support channel, and custom invoicing, payment terms, DPA and terms of service. The open-source CLI remains free under Apache 2.0

- [Open source](https://graphify.com/oss): Graphify is free for qualified non-commercial projects with MIT or Apache licenses. Projects with 1,000+ stars are auto-approved. Graphify is open source. We believe modern software is built in the open. Apply with your repository link, email address, repository owner/admin status, and confirmation that it is a community project rather than part of a commercial product.

- [Startups](https://graphify.com/startups): Pre-Seed and Seed startups with under $1M in revenue over the past 12 months get 50% off Graphify Teams plan for up to 6 months. Apply with your company name, website, work email, role, team size, funding stage, revenue range in USD over the past 12 months, and confirmation that your revenue meets the eligibility limit.
- [YC companies](https://graphify.com/yc): YC companies get 6 months of Graphify Teams for free. Give your agents the context to understand your codebase. From Graphify, YC S26. Claim the offer through Bookface.
- [The Memory Layer](https://graphify.com/books): The Memory Layer is a free book by Safi Shamsi, Founder and CEO of Graphify Labs. It follows machine memory from graph theory and ontologies through hallucination to a weekend pipeline, for engineers whose coding agent starts from zero every session. Free PDF, 139 pages, unlocked with an email address.

## Security and deployment

- [Security](https://graphify.com/security): With the open-source engine nothing leaves your machine: 36 bundled tree-sitter grammars parse locally, the graph is three files in your own repository, no telemetry (not off by default, absent), Apache 2.0 so you can confirm it. Graphify adds no channel of its own; your assistant still sends its prompts wherever it did before. Controls: SOC 2 Type II engagement started, no report yet; SSO over OIDC and JWT and OAuth 2.1 on the MCP server, SAML available with Enterprise; exportable audit logs and TLS 1.3 / AES-256 on the early-access track; self-host, BYOC or air-gapped VPC; your data is never trained on or sold
- [Solutions for security teams](https://graphify.com/solutions/security-teams): Parsed on-device, no telemetry, self-hosted when it has to be
- [Enterprise](https://graphify.com/enterprise): The same graph, plus automated legacy migration, SAML single sign-on, an engineering digest, Jira and Atlassian, on-prem or VPC, and audit logs. Formal verification and graph-aware review are in every plan. Early access, licensed per seat, no repository leaves your network
- [graphify.net vs graphify.com](https://graphify.com/graphify-net-vs-graphify-com): graphify.com is official; graphify.net is not affiliated with Graphify Labs

## Docs

- [Quickstart](https://docs.graphify.com/quickstart): Install, build, query, MCP setup, PR review
- [Install guide](https://docs.graphify.com/installation): uv, pipx or pip; per-assistant registration for 20 assistants; strict mode; PATH troubleshooting
- [CLI reference](https://docs.graphify.com/reference/overview): install, uninstall, /graphify, query, path, explain, prs, with every flag
- [MCP tools reference](https://docs.graphify.com/reference/mcp-tools): The ten local graph tools with parameters and defaults, serving modes, .mcp.json
- [MCP server and per-assistant connect snippets](https://graphify.com/mcp): Hosted endpoint plus exact config for Claude Code, Codex, Copilot CLI, Cursor, VS Code, Windsurf, Cline, Continue, JetBrains, Goose, Zed and Gemini CLI
- [Docs MCP server](https://docs.graphify.com/mcp/docs-search): Search these docs from inside your agent: Streamable HTTP at https://docs.graphify.com/mcp
- [Verification docs](https://docs.graphify.com/platform/verification): Differential formal verification, end to end
- [FAQ](https://graphify.com/faq): Sixteen questions with answers written to be quoted whole
- [Changelog](https://graphify.com/changelog): What's new, from GitHub releases

## Comparisons

- [Comparisons hub](https://graphify.com/vs): Five side-by-side reads
- [Graphify vs RAG](https://graphify.com/vs/rag): Ten rows on why traversal answers what similarity cannot
- [Graphify vs vector databases](https://graphify.com/vs/vector-databases): Pinecone, Weaviate, pgvector: where nearest neighbour ends and structure begins
- [Graphify vs Sourcegraph](https://graphify.com/vs/sourcegraph): Platform versus assistant memory
- [Graphify vs CodeRabbit](https://graphify.com/vs/coderabbit): Review bot versus code memory
- [Graphify vs Cursor indexing](https://graphify.com/vs/cursor): Not either or; Graphify plugs into Cursor over MCP
- [Graphify vs CodeGraph](https://graphify.com/vs/codegraph): Graphify maps code, docs, PDFs and Office files into one graph and flags pull requests that collide; CodeGraph is a lean code index for one agent. Open source compared with open source, then Graphify Cloud
- [Graphify vs codebase-memory-mcp](https://graphify.com/vs/codebase-memory-mcp): Graphify links code to the docs and recordings that explain it; codebase-memory-mcp indexes 162 languages of code. Open source compared with open source, then Graphify Cloud
- [Graphify vs code-review-graph](https://graphify.com/vs/code-review-graph): Graphify reads every open pull request against one graph, flags collisions and, on Graphify Cloud, verifies changed functions with a solver; code-review-graph scores one pull request in your own CI
- [Side by side on the homepage](https://graphify.com/#compare): Graphify, CodeRabbit, Greptile and Sourcegraph across nine rows: differential verification, cross-repo blast radius, typed code graph, multi-hop reasoning, auditable answer, provenance, deployment, any AI assistant, licence

## Company

- [About](https://graphify.com/about): Graphify Labs, backed by Y Combinator (S26). Memory that reasons, answers that trace
- [Customers](https://graphify.com/customers): Public adopters with linked proof: Rootly AI Labs, Superagent (YC W24), HKUST KnowComp
- [GitHub](https://github.com/Graphify-Labs/graphify): Source, issues, README, Apache 2.0
- [Contribute](https://graphify.com/contribute): GitHub issues and Reddit posts from the last 30 days, mixed for the UTC day
- [GraphGuild](https://graphify.com/graphguild): The community program. Contributor, Content Creator, Ambassador, Event Speaker
- [PyPI](https://pypi.org/project/graphifyy/): The `graphifyy` package
- [Discord](https://graphify.com/discord): The community server: help, release announcements, and community posts. Invite: https://discord.gg/graphify
- [Contact](https://graphify.com/contact) · [Careers](https://graphify.com/careers) · [Brand](https://graphify.com/brand)

## Blog

- [Vercel integration](https://graphify.com/blog/vercel-integration): Graphify's Vercel integration adds a hosted MCP token to the projects you choose. Connect Account, pick the projects, then redeploy.
- [Graphify passed 125,000 GitHub stars](https://graphify.com/blog/125000-github-stars): Graphify passed 125,000 GitHub stars. On 12 October 2026 the public count was 125,736, with more than 12,000 forks.
- [Gemini CLI: how to connect Graphify](https://graphify.com/blog/gemini-cli-how-to-connect-graphify): Install Graphify for Gemini CLI, build a local graph of the repository, and ask which function calls which.
- [Graphify Startups Program: to help founders build](https://graphify.com/blog/graphify-startups-program): The Graphify Startups Program is open. Pre-Seed and Seed startups under $1M in revenue get 50% off Teams for up to 6 months. Apply with one form.
- [JetBrains MCP: how to connect Graphify](https://graphify.com/blog/jetbrains-mcp-how-to-connect-graphify): Install Graphify MCP in a JetBrains IDE, paste the connection into AI Assistant, and ask about a repository you have already indexed in Graphify Cloud.
- [OpenClaw MCP: how to connect Graphify](https://graphify.com/blog/openclaw-mcp-how-to-connect-graphify): Install the OpenClaw MCP plugin from ClawHub, sign in to Graphify, and ask about a repository you have already indexed in your Graphify Cloud workspace.
- [Graphify is now a ChatGPT plugin](https://graphify.com/blog/graphify-chatgpt-plugin): The Graphify ChatGPT plugin connects ChatGPT, Codex, and Dots to repositories you have indexed, so they can trace calls and judge what a change reaches.
- [Eight million downloads in six months](https://graphify.com/blog/eight-million-downloads-in-six-months): Graphify passed 8 million PyPI downloads six months after the first commit, with nearly 12,000 forks.
- [The first YC company to hit 100k stars during its batch](https://graphify.com/blog/first-yc-company-100k-stars): Graphify crossed 100,000 GitHub stars 117 days after the first commit, during our Y Combinator batch.
- [100,000 GitHub stars](https://graphify.com/blog/100000-github-stars): One hundred thousand stars, 117 days after the first commit, and a look back at what the community built with Graphify.
- [How to give Claude Code a code knowledge graph (2026 guide)](https://graphify.com/blog/how-to-give-claude-code-a-code-knowledge-graph): Install the skill, then build a local knowledge graph Claude Code can query before it searches your repo.
- [How to give Cursor a code knowledge graph (2026 guide)](https://graphify.com/blog/how-to-give-cursor-a-code-knowledge-graph): Four commands take Cursor from grep-and-read loops to querying a persistent, on-device knowledge graph of your codebase.
- [Best codebase-context tools for AI coding assistants (2026)](https://graphify.com/blog/best-codebase-context-tools-for-ai-coding-assistants-2026): The best codebase context tools depend on the job: a string, similar prose, a relationship, org-wide search, or pull-request review.
- [How to give GitHub Copilot codebase context that persists](https://graphify.com/blog/how-to-give-github-copilot-codebase-context): GitHub Copilot codebase context persists when you build a graph once and let Copilot query it, rather than searching the repo again each session.
- [Code knowledge graph vs RAG: why structure beats similarity](https://graphify.com/blog/code-knowledge-graph-vs-rag): RAG pulls back text that resembles the question. A graph follows the relationships that answer it, and code is the worst case for similarity.
- [What is a code knowledge graph? (And why it beats grep for AI agents)](https://graphify.com/blog/what-is-a-code-knowledge-graph): A code knowledge graph stores calls and imports as typed edges, so an agent can follow a path that grep cannot see.
- [Why graphs beat vectors for agent memory](https://graphify.com/blog/why-graphs-beat-vectors): A code graph vs a vector database keeps the relationships for the next session, instead of searching similar text again.
- [Grounded answers: how Graphify tags what it knows](https://graphify.com/blog/grounded-answers-confidence-tags): Confidence tags label every Graphify edge EXTRACTED, INFERRED, or AMBIGUOUS, so an agent can see what was parsed and what was guessed.

## Optional

- [Full index](https://graphify.com/llms-full.txt): Per-problem Q&A, full CLI and MCP reference, pricing FAQ, security controls, all 17 assistant guides, all 36 languages, and the glossary
- [Integrations](https://graphify.com/integrations): Per-assistant setup guides under /integrations/{slug}
- [Languages](https://graphify.com/languages): Per-language pages under /languages/{slug}
- [Glossary](https://graphify.com/glossary): Fourteen terms under /glossary/{slug}
- [Blog](https://graphify.com/blog): Guides, concepts, product notes, and engineering notes
- [Privacy](https://graphify.com/privacy) · [Terms](https://graphify.com/terms) · [Subprocessors](https://graphify.com/subprocessors) · [Code of Conduct](https://graphify.com/coc) · [Challenge Rules](https://graphify.com/challenge-rules) · [Event Terms](https://graphify.com/event-terms-and-conditions)