Graphify: Queryable Knowledge Graph for Any Codebase in AI Coding Assistants

What Graphify Solves and Who It Is For

When working in a large or unfamiliar codebase, developers spend significant time tracing relationships between files, understanding where a concept is defined, and discovering how subsystems connect. Graphify addresses this by building an explicit graph of nodes (concepts, functions, classes, files) and edges (calls, imports, inherits, mixes_in) from the source files and then making that graph queryable through the AI assistant's native command interface.

The primary audience is developers who already use an AI coding assistant and want to query their codebase structurally rather than relying on the assistant to read raw file contents. The README positions this as a /graphify skill that registers itself inside Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, and 15 or more other assistants.

How It Works: Tree-Sitter AST, No Vector Store

The code parsing layer uses tree-sitter with language grammars for about 40 languages listed in pyproject.toml, including Python, TypeScript, Go, Rust, Java, C, C++, Kotlin, Scala, Swift, Zig, and others. AST parsing is deterministic: the same source file produces the same nodes and edges every run, without calling a language model. Nothing from the code parsing step leaves the local machine.

The README distinguishes this from vector-based code search tools. Instead of embedding source text into a vector index and performing approximate nearest-neighbour queries, Graphify builds a real graph where edges carry explicit labels: EXTRACTED (the connection is explicit in the source) and INFERRED (resolved by graphify's cross-file resolution). This labelling lets a developer know whether a connection was read directly from the code or derived.

The README's capabilities table describes what the graph provides out of the box: God nodes (the most-connected concepts everything flows through), Communities (subsystems detected with the Leiden algorithm and labelled without a language model), cross-file links (calls, imports, inherits, mixes_in resolved across files), query/path/explain commands, rationale and doc refs from source comments (NOTE and WHY comments and ADR/RFC citations become first-class graph nodes), and beyond-code support for docs, PDFs, images, and video.

Docs, PDFs, images, and video go through a separate semantic pass that calls a language model or configured API key. That pass is optional and only needed for non-code material.

Installing Graphify and Running the First Graph

The README describes the quickstart as taking 30 seconds. Install the CLI:

uv tool install graphifyy

Alternatively with pipx:

pipx install graphifyy

Then register the skill with the AI assistant:

graphify install

From inside the AI assistant, run the scan on the current directory:

/graphify .

The command produces three files in a graphify-out/ directory: graph.html (an interactive browser page with clickable nodes, filtering, and search), GRAPH_REPORT.md (a summary of key concepts and suggested questions), and graph.json (the full graph for offline querying). The package name on PyPI is graphifyy (with two y characters), which is distinct from the graphify command that runs after installation.

CLI Commands: explain, path, and query

After building a graph, the CLI provides three querying commands. The README shows example output for each:

The explain command shows a node's source location, community membership, connection degree, and all its edges with their labels and directions:

graphify explain "APIRouter"
Node: APIRouter
  Source:    routing.py L2210
  Community: 2
  Degree:    47

The path command finds the shortest path between two nodes:

graphify path "FastAPI" "ModelField"
Shortest path (3 hops):
  FastAPI --uses--> DefaultPlaceholder <--references-- get_request_handler() --references--> ModelField

The query command takes a plain-language question and returns a scoped subgraph. All three commands operate on graph.json locally without re-reading source files.

Running as an MCP Server with Docker

Graphify includes a Dockerfile for running it as a Streamable HTTP MCP server. The Dockerfile comment shows the build and run commands:

docker build -t graphify .

Then mount the graph.json at runtime:

docker run -p 8080:8080 -v "$(pwd)/graphify-out:/data" graphify /data/graph.json --transport http --host 0.0.0.0 --api-key "$SECRET"

The Docker image uses the mcp extra (pulling mcp, starlette, and uvicorn) and runs as a non-root user on port 8080. The graph.json is mounted at runtime rather than baked into the image, so the same image can serve different codebases by changing the volume mount. This approach allows a shared MCP server for a team where the graph was built locally and then shared.

Limitations and Cases Where Graphify Is the Wrong Tool

Graphify builds a static graph from a snapshot of the codebase at a point in time. The graph does not update automatically as files change; a new /graphify . run is needed to reflect code changes. For codebases that change frequently, this means the graph can become stale.

The code parsing covers about 40 languages via tree-sitter. Languages not on that list (infrastructure configuration languages, domain-specific file formats, or newer languages without stable tree-sitter grammars) appear only as nodes without structural edges, which reduces the value of the graph for mixed-technology projects.

The semantic pass for docs and media calls an external API. Teams in air-gapped environments or with strict data residency requirements cannot use this feature unless they configure an on-premises language model endpoint. The code-only graph still works locally, but documentation relationships are then absent.

Alternative: Obsidian and the Difference in Approach

Obsidian is the most commonly compared alternative in the search data. Obsidian is a note-taking and knowledge management application that builds a graph from Markdown files linked with [[wiki links]]. A user creates the connections manually by writing links in notes. Graphify creates connections automatically by parsing source code with tree-sitter and resolving cross-file references deterministically.

The practical difference is the input and the audience. Obsidian is for personal knowledge management with human-authored notes. Graphify is for codebase navigation with machine-derived structure. Both produce a browsable graph.html, but the nodes in Graphify are code entities (functions, classes, modules) rather than notes, and the edges are code relationships (calls, imports) rather than document links.

Maintenance, License, and Supported Platforms

The repository is not archived and the last push was on 2026-09-26. The v0.9.71 release was published on 2026-09-28. The project releases frequently: v0.9.70 appeared on 2026-09-27 and v0.9.69 on 2026-09-26, which reflects rapid iteration on a pre-1.0 product.

The project is licensed under Apache-2.0. The NOTICE file and dual LICENSE files (Apache-2.0 and MIT) are present in the repository. The README notes that the Graphify platform at app.graphify.com is a separate commercial product offering always-on, background-updating graph generation, distinct from the open-source CLI and MCP server in this repository.

Editorial conclusion

Graphify is worth adopting for developers who need to understand a large or unfamiliar codebase quickly and want to use their AI coding assistant to query the structure rather than grep files. The code parsing is local and free; the semantic pass over docs and media requires a configured API key. Verify that your assistant platform is among the supported ones listed in the README before installing, and test with a small directory before mapping a monorepo, since graph build time grows with codebase size.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes