Graphify Review and Alternatives: Tested on FastAPI

Graphify is an open-source skill and CLI that turns a folder of code, docs, PDFs and images into a queryable knowledge graph, so a coding agent can look up relationships instead of grepping files one by one. As of October 2026 it has about 138,000 stars on GitHub and is Apache-2.0 licensed.

We installed it, ran it on fastapi/fastapi, indexed the same checkout with repowise, and asked both the questions an agent asks. Disclosure: we build repowise. Everything about Graphify below is from its repository or from the run described here.

What does Graphify do?

Graphify parses source code locally with tree-sitter (the project says about 40 languages), links symbols, imports and calls into a graph, groups the graph into communities, and writes graph.json and a GRAPH_REPORT.md of the most connected nodes. Documents, PDFs and images go through an optional model pass using your assistant's model or an API key you provide, and the code pass needs neither.

It started on 3 April 2026 and was created by Graphify-Labs. The repository README describes it as a /graphify skill for Claude Code, and graphify install also registers it for Codex, Gemini CLI, Cursor, OpenCode, Aider and others.

How do you set up Graphify for Claude Code?

Install the CLI, register the skill, then run /graphify . inside Claude Code. The PyPI package is graphifyy with two y's; the repository warns that other graphify* packages are not affiliated.

uv tool install graphifyy      # or: pipx install graphifyy / pip install graphifyy
graphify install               # registers the skill for the assistants it detects
# then, inside Claude Code:
/graphify .

Two more commands change how it behaves in Claude Code. graphify claude install writes a section to CLAUDE.md and adds a PreToolUse hook that points Claude at the graph before broad searches. graphify hook install adds git hooks that rebuild the graph after commits. Python 3.10 or newer is required.

Does Graphify have an MCP server?

Yes, as an optional extra. uv tool install "graphifyy[mcp]" adds an MCP server that serves a graph.json over stdio or HTTP (python -m graphify.serve graphify-out/graph.json, with --transport http for the HTTP form; the graphify-mcp command is the same entry point). graphify install does not register an MCP connection for you, so you add the server to your client yourself, for example claude mcp add graphify -- graphify-mcp graphify-out/graph.json. We confirmed the serve options from --help but did not wire the server into a client in this run; we used the CLI.

Does Graphify need an API key?

Not for code. graphify extract <path> --code-only runs the tree-sitter pass offline. Docs, PDFs and images need a model: your assistant inside the skill, or one of Gemini, Moonshot, Anthropic, OpenAI, DeepSeek, Ollama or Bedrock credentials for headless graphify extract. GRAPHIFY_BACKEND=none turns every model backend off.

What did Graphify produce on FastAPI?

On fastapi/fastapi at commit 79cab5b, graphify extract . --code-only finished in 50 seconds and wrote a graph of 9,261 nodes and 19,962 edges. We ran it on 29 October 2026 on a Windows 11 desktop; Graphify used 32 worker processes. A second step, graphify cluster-only ., took 8 seconds and wrote the report.

The checkout has 131,859 Python lines across 3,233 files, and 22,748 of those lines are in the fastapi/ package itself. The rest is tests and the docs_src/ tutorial examples, which both tools index. Both ran on a depth-1 clone, so neither saw git history beyond one commit.

Three details from the Graphify run matter in practice:

• No graph.html. The README sets a 5,000-node default for the interactive viewer; above it, export html renders an aggregated community view and --node-limit raises the cap. At 9,261 nodes our cluster-only run wrote the JSON and the report but no graph.html.
• Placeholder community names. With no model backend, communities stay named after their top node or Community N. The label step uses a model.
• A 2,000-token default answer budget. graphify query stopped at 70 of 211 matching nodes and said so; --budget raises it.

What can Graphify answer?

Graphify answers structural questions from graph.json with query, path, explain, affected and god-nodes. Here is what each returned on FastAPI.

Graphify's explain output is the strongest piece: for solve_dependencies it listed 26 connections, each tagged EXTRACTED or INFERRED with a file and line. The report says 94% of edges were extracted and 6% inferred, which is a useful honesty signal on a call graph. repowise returns the same kind of edge with a numeric confidence and a resolution note (same_file, import_scoped).

On dead code, 236 of the 260 repowise findings are files under docs_src/ (234 tutorial snippets) or docs/ (2 JavaScript files for the docs site); the other 24 are unused symbols in tests and scripts. The tutorial files are examples that nothing imports, so they are reported as unreachable. repowise grades every finding 40% confidence and marks none deletion-ready, which is the intended reading: a list to review, not a delete script.

Where does Graphify fit well?

Graphify fits best when your material is a mixture. It is the only tool in this group that treats PDFs, Markdown notes, screenshots, SQL schemas and video as first-class inputs next to code, and the README lists extras for SQL, Postgres, Terraform, Office files and more. A research folder, a monorepo with a design-doc archive, or a data team's repo of schemas and papers all suit it.

It also ships more export routes than the others: graph.html, a markdown wiki (--wiki), GraphML for Gephi and yEd (--graphml), Cypher for Neo4j (--neo4j), SVG (--svg), and an opt-in Obsidian vault (--obsidian), per the skill's command list. graphify merge-graphs joins several repos' graphs, graphify watch rebuilds on change, and graphify update re-extracts code with no model.

The code-only extraction is fast. 50 seconds for 1,229 files on one desktop is quicker than repowise's 112 seconds on the same checkout, which is expected because repowise also computes git signals, health scores and dead-code analysis in that pass.

Where does Graphify stop?

Graphify stops at structure. In this run its CLI exposed query, path, explain, affected and god-nodes, and none of them read git history, ownership, code health, dead code or change risk. If your agent asks "is this file a hotspot?" or "who owns this?", the graph does not contain the answer.

Four other limits showed up in the run:

1. Result size. A natural-language query is a breadth-first traversal, not a ranked answer. On "what calls get_dependant" it returned callers and callees together, truncated at 58 of 86 nodes.
2. Test and tutorial noise. The affected output for one function included seven docs_src tutorial imports and several test files alongside the production callers, because they are all in the graph. Hub rankings do the same: a generic post() node had 672 edges.
3. Name quality. Community labels need a model backend to read as names; without one the report's hubs are symbol names.
4. Freshness is yours to manage. The graph records its build commit. You keep it current with graphify update, a git hook, or watch.

We did not run the document and PDF pass, which needs a model and is where Graphify differs most from the others, so we make no claim about its quality.

Which Graphify alternatives are there?

The main alternatives are Serena, GitNexus, CodeGraph, code-review-graph and repowise, and they differ more in what they index than in how they install. This table is checked against each project's repository on 29 October 2026.

Two license notes matter before you adopt anything. GitNexus is under PolyForm Noncommercial 1.0.0, which permits noncommercial use only, so using it for paid work at a company needs a separate commercial license from its authors. Serena's application code is GPL-3.0-or-later, which affects how you can redistribute it.

For measured numbers across Serena, Graphify, CodeGraph and repowise (agent tokens, retrieval coverage, index time) read the four-way benchmark. For a wider list of graph servers see best code graph MCP servers, and for the product page see Graphify alternative.

How does repowise differ from Graphify?

repowise indexes the repository's call graph and also the repository's history. In the same 112-second init on FastAPI it built the graph, scored code health, ranked dead-code candidates and mined git signals, and agents reach all of it through ten MCP tools such as get_context, get_risk, get_dead_code and get_answer.

repowise init --yes --no-prose --no-editor-setup   # local, no API key, no model calls
repowise search solve_dependencies --mode symbol
repowise context fastapi/dependencies/utils.py::get_dependant --include callers
repowise dead-code

Adding a model with repowise generate writes prose wiki pages on top. Graphify's strength, documents and PDFs, is not something repowise tries to match; repowise indexes code and what git knows about it. See agent context for how the tools are used from Claude Code, Cursor and Codex.

Graphify vs Obsidian: what is the difference?

Obsidian is a notes app and Graphify is a graph builder, so they are not competitors. Obsidian's graph view draws the links you write between notes. Graphify extracts relationships from code and documents on its own, and with the --obsidian flag (optional, off by default) it writes a vault, one note per node, that you can open in Obsidian.

Our code-only FastAPI run did not pass that flag and wrote no vault, so we did not test the Obsidian output. If you keep research notes in Obsidian and want an agent to query them, Graphify is a fit. If you want an agent to understand a codebase, the vault is optional.

Which one should you pick?

Pick Graphify if your corpus mixes code with PDFs, notes and diagrams, if you want the graph exported to Obsidian (opt-in), Neo4j or GraphML, or if a fast, offline, structure-only index is enough. Pick Serena if your agent mostly needs to read and edit exact symbols. Pick CodeGraph for a lean call graph and one-tool simplicity. Pick GitNexus for impact and rename previews if a noncommercial license works for you. Pick repowise if the questions include history, risk, ownership or dead code. Use two together if you want it: Graphify's graph for the documents, repowise for the code.

To decide on your own repo, run both in a scratch clone and ask your five most common agent questions:

git clone --depth 1 https://github.com/<you>/<repo> scratch && cd scratch
uv tool install graphifyy && graphify extract . --code-only
repowise init --yes --no-prose --no-editor-setup