Graphify: a navigable map for an agent to understand a repository

Everything you need to know about safishamsi/graphify, now redirected to Graphify-Labs/graphify: a skill and CLI that turns code and associated materials into a queryable knowledge graph.

What Graphify is

Graphify turns a directory into a local knowledge graph. For code it uses deterministic syntactic analysis with Tree-sitter; for documentation, PDFs, images, video, and audio it offers a semantic pass through the assistant’s model or a configured key. The result is saved in graphify-out/ as graph.html, GRAPH_REPORT.md, and graph.json.

The proposal is not a vector index: the README and the site explicitly contrast it with RAG and text search. Every relationship keeps provenance: EXTRACTED if it comes explicitly from the source, INFERRED if Graphify resolves it, and in some results AMBIGUOUS. The goal is for an assistant to traverse and be able to justify a path, instead of rereading or searching for repository fragments in every session.

Relationship graph with edges labeled EXTRACTED and INFERRED against a dark background, representing the traceability of the connections Graphify generates.

The origin: from a Karpathy idea to a project and a company

The original safishamsi/graphify repository was created on April 3, 2026, according to the GitHub API. The official page places the conceptual spark in a post by Andrej Karpathy about a model-readable “wiki” so the assistant would not have to deduce code structure from scratch every session; Graphify presents itself as its open, local interpretation of that idea.

The GitHub profile of Safi (safishamsi) identifies him as founder and CEO of Graphify Labs. The company created its GitHub organization on June 28, 2026; the historical URL now redirects to Graphify-Labs/graphify. The transition leaves a useful signal about its evolution: it moved from a personal repository to an organization and a commercial early-access platform, while the CLI remains under the Apache-2.0 license.

Conceptual illustration of an isolated code file transforming, across a bridge of light, into an organized corporate network, symbolizing the move from a personal repository to an organization.

There is contemporary evidence of the launch, though no extensive independent chronicle. On April 6, 2026, tanelpoder opened Hacker News thread 47668188, which described the skill for turning folders into queryable graphs. Two days later, in 47696872, lilwing, author of Ix, attributed the initial interest to a Karpathy post and said Graphify had been built in 48 hours. That is a claim from the author of a competing project, not an independent measurement or proof of the exact timeline.

Philosophy and principles

Local-first for code. Code file analysis is done with Tree-sitter ASTs, with no model or machine code output. Documentation and media are the optional boundary that may require a model provider.
Traceability before an opaque answer. Edges carry provenance labels, and the path and explain commands show connections and sources.
Structure, not similarity. The product argues for a graph of entities and relationships over vector fragments or grep results.
Persistence for the team. graphify-out/ is meant to be versioned; the project offers a Git hook to rebuild the map and merge tooling for graph.json.

These are the project’s own positions, not an independent demonstration that a graph outperforms RAG or conventional search across every repository.

Abstract syntax tree made of blue and magenta neon optical fibers branching out into the void, as a metaphor for deterministic Tree-sitter analysis.

How it works

The recommended installation is:

uv tool install graphifyy
# or: pipx install graphifyy
graphify install

The package is called graphifyy on PyPI, with two ys; the executable is called graphify. After that, the minimal flow is /graphify . inside the assistant. To limit the scope to the repository you can use graphify install --project; the installation creates a skill and, depending on the platform, an instructions file or a hook.

Futuristic black terminal with green neon text running the /graphify . command, from which a small three-dimensional knowledge graph emerges as it forms.

The README documents adapters for Claude Code, CodeBuddy, Codex, OpenCode, Kilo Code, GitHub Copilot CLI, VS Code Copilot Chat, Aider, OpenClaw, Factory Droid, Trae, Cursor, Gemini CLI, Hermes, Kimi Code, Amp, Agent Skills, Kiro, Pi, Devin CLI, and Google Antigravity. In Claude Code and Gemini CLI, hooks steer searches toward the graph; on platforms like Codex, OpenCode, or Cursor that steering is implemented through persistent instruction files.

Holographic hexagonal grid with minimalist icons representing different coding assistants connected to a shared core, over a dark metallic surface.

The main commands are:

/graphify .                         # build the map
/graphify ./docs --update            # update changed files
/graphify . --no-viz                 # produce report and JSON without HTML
/graphify query "what connects authentication and database?"
/graphify path "UserService" "DatabasePool"
/graphify explain "RateLimiter"
graphify hook install                # update after every Git commit
graphify merge-graphs a.json b.json

It also exposes the graph over MCP: python -m graphify.serve graphify-out/graph.json. The standard transport is stdio; the HTTP option lets a team point to a shared process. The documentation warns that, if exposed beyond 127.0.0.1, an API key should be used.

Central cyan neon cube representing an MCP server in a dark server room, with holographic data streams flowing in and out via stdio and HTTP, next to an API key lock icon.

Among the standout features are community detection with Leiden, highly connected nodes, cross-file links, import/call/inheritance relationships, extraction of motivation comments, and documentation references. The README states AST support for around 36 grammars, plus MCP configurations, package manifests, SQL, documentation, and several office and multimedia formats through extras.

Official and semi-official status

Graphify is an open project published on PyPI as graphifyy and under the Apache-2.0 license. The published version PyPI returned during this investigation is 0.9.32. The README displays a Y Combinator S26 badge and links to a Graphify Labs profile; it also announces early access to an enterprise platform ahead of a public 1.0 release.

No evidence was retrieved that Graphify has been accepted into an official marketplace from Anthropic, OpenAI, Google, Cursor, GitHub, or another vendor. Its installation across many assistants should be read as technical compatibility documented by the project, not as certification, vendor endorsement, or a formal standard. Its star volume, the PyPI package, and the multi-agent adapters do point to broad adoption, but “de facto standard” is not a designation verified in the sources consulted.

The ecosystem

The author’s and the organization’s repositories

The Graphify-Labs organization API returned only two public repositories: the main repository and Graphify-Labs/.github (profile and community-health files; 0 stars). No additional lab, evaluation harness, or official marketplace was identified under that organization at the time of measurement.

The official ecosystem within the repository itself includes documentation translated into Simplified and Traditional Chinese, Japanese, Korean, Spanish, French, German, Hindi, Portuguese, Russian, Arabic, Persian, Italian, Polish, Dutch, Turkish, Ukrainian, Vietnamese, Indonesian, and other languages. These are translations maintained in docs/translations/, not independent forks.

Holographic globe made of code and graph nodes, surrounded by floating banners displaying the word "Graphify" in several different languages and scripts.

Forks, ports, and community extensions

The forks API and GitHub search allowed verification of the following derivatives or extensions. The figures are stars observed on August 3, 2026; they do not equal support from the main project.

elbruno/graphify-dotnet: a .NET 10 port that states it uses the GitHub Copilot SDK and Microsoft.Extensions.AI; 90 stars.
TtTRz/graphify-rs: a Rust rewrite; 57 stars.
sjhorn/graphify: a Go port and extension that explicitly links to the original repository; 8 stars.
Rootly-AI-Labs/rootly-graphify-importer: an importer that turns Rootly incidents, alerts, and teams into a queryable graph; 41 stars. Rootly also published the integration article linked by Graphify.
chencore/graphify-knowledge-graph-docs: community installation and usage documentation in Chinese; 26 stars. It is a non-English resource separate from the official set of translations.
gaodes/pi-graphify: a Pi extension that wraps the CLI; 9 stars.
yetanotheraryan/graphify-chokidar: watches for changes to keep the graph up to date without running the semantic pass; 6 stars.
Among the most visible forks returned by the API are m8e/graphify (19 stars) and salvatorecastellitti/graphify-qwen (11 stars). They are described as forks/skills; no evidence was retrieved that they are distinct, officially backed products.

Dense constellations of yellow and green nodes connected by glowing edges, with a few radiant hub nodes shooting light out to smaller, distant clusters, in a dark digital space.

Repository numbers

Measured: August 3, 2026, GitHub API and web page.

Metric	Value
Stars	101,638
Forks	9,867
Real subscribers	345
Commits	1,342
Open issues reported by the API	776
Primary language	Python
Current license	Apache-2.0
Created	April 3, 2026
Latest code push	August 1, 2026
Latest release	`v0.9.32`, August 1, 2026

The total of 1,342 commits comes from the final page indicated in the API’s pagination header. The top contributors returned by the API were safishamsi (944 contributions), TPAteeq (27), oleksii-tumanov (21), Synvoya (17), and Rishet11 (16).

The API returns watchers_count equal to the stars; that is why subscribers_count is reported here as the real subscriber figure. open_issues_count may mix issues and open pull requests, so it should not be read as an issue-only count. The web page showed 352 issues and 424 pull requests at the time of query, a breakdown that illustrates that caution.

How to contribute

No CONTRIBUTING.md, pull request template, or explicit contribution flow was retrieved in the repository. There are tests/, docs/ directories, and GitHub Actions workflows, and the discussions page offers categories for ideas, Q&A, demos, and announcements. The repository therefore shows community activity, but it would be irresponsible to infer a branching policy, mandatory tests, or a contribution-acceptance process that is not documented.

How the community received it

The observable reception mixes curiosity about the persistent map, later integrations, and technical reservations:

On Hacker News 47668188, submitted by tanelpoder on April 6, Graphify got 2 points and 1 comment. kazishariar specifically asked whether it could semantically map a folder of PDFs, books, quotes, and data; that is a signal of interest in documentary scope, not a conclusive positive review.
The thread 48717184, submitted by mdrzn, reached 4 points and 1 comment. gkorland called Graphify a “great project” and suggested trying it with FalkorDB, with Cypher export commands. That is individual praise and an integration suggestion, not a comparative evaluation.
In 47890749, a question about legacy codebases received 13 points and 8 comments. sds357 linked Graphify and explained it would help an agent find the codebase’s structure and relationships. The context, raised by thinkingtoilet, was a codebase more than twenty years old and the cost of the assistant rereading large chunks; it explains the problem Graphify applies to, not a verified cost reduction.
The most specific criticism retrieved is in a comment by Madsn inside 47696872, a thread with 2 points and 6 comments. He said he had initially picked Graphify because he uses OpenCode, but questioned conclusions that Sonnet had generated when comparing Graphify with Ix, pointed out that Ix also had an OpenCode plugin, and expressed his rejection of Graphify’s hook rebuilding the graph after every Git commit because he wanted to version the graph files himself. That is personal experience; it does not prove the behavior is wrong in general.

No large-scale discussion was retrieved that would support a claim of community consensus. Hacker News metrics are modest next to GitHub popularity and should not be mistaken for a quality evaluation.

Graphify versus other proposals

Proposal	Verifiable overlap	Verifiable difference
`ix-infrastructure/Ix`	Both present themselves as open CLIs that generate a persistent architectural map for assistants.	In the HN thread, its author describes Ix as an agent-integration tool with a Claude Code plugin; Graphify documents adapters for more than fifteen assistants and provenance labels on its edges. No independent benchmark between the two was retrieved.
`getzep/graphiti`	Both use knowledge graphs for model queries.	In an HN comment, `SEJeff` grouped them together for using Tree-sitter and graphs for LLM use; Graphify is explicitly oriented toward mapping local files and a repository, while that source is not enough to claim an architectural or performance equivalence.
`trailofbits/trailmark`	Also cited by `SEJeff` as a Tree-sitter- and graph-based tool for LLMs.	The retrieved source only establishes that category relationship; not enough documentation was obtained for a stronger functional comparison.

The verifiable comparison is by approach, not a ranking of winners: Graphify fits when you need a versionable artifact, a visualization, and auditable paths over code and documentation; the data retrieved does not prove it outperforms Ix, Graphiti, or Trailmark in accuracy, cost, or coverage.

Use cases and who this repository can help

Teams maintaining large or legacy repositories can generate graph.json, query searches, path routes, and explain explanations to locate dependencies and relationships between modules without starting every session by manually searching for files.
Teams combining application code, SQL schema, configuration, and architecture documentation can bring those materials together in a single representation. The value depends on reviewing INFERRED edges and deliberately configuring the semantic pass for non-code materials.
Distributed teams using different assistants can version graphify-out/, install the skill per project, and use the documented adapters for Codex, Claude Code, Cursor, Gemini CLI, Copilot, and others; the Git hook and merge-graphs specifically target keeping a shared map in sync.
People who need inspection or traceability can use the provenance labels, graph.html, and the MCP server so the agent’s answers indicate which path of the graph they traversed. If the graph is shared over HTTP, they should apply the authentication measures the project documents.

Resources

Repository: https://github.com/Graphify-Labs/graphify
Documentation and installation: https://graphify.com/docs
Official package: https://pypi.org/project/graphifyy/
Official skills and integrations: https://github.com/Graphify-Labs/graphify#pick-your-platform-20-assistants-click-to-expand
Project benchmarks: https://github.com/Graphify-Labs/graphify/blob/v8/BENCHMARKS.md
Reviews and conversations: https://news.ycombinator.com/item?id=47668188, https://news.ycombinator.com/item?id=48717184, https://news.ycombinator.com/item?id=47696872
Community and Discord: https://discord.gg/598Ad9zQZ
Site and early access: https://graphify.com/

Note: this article combines Graphify’s README, documentation, and site, the GitHub and PyPI APIs, repository search, and Hacker News threads retrieved on August 3, 2026. Figures change over time; the project’s performance claims and users’ experiences are attributed to their sources.