Graphify added 437 stars in a daily GitHub Trending snapshot. GitHub's repository metadata put the Python project at 119,284 stars overall. The spike is landing on a specific change to AI-assisted coding: build a map of the repository before an agent starts opening files, then let the agent ask the map where to look.
Graphify turns source code and supporting material into a knowledge graph. Functions, classes, files, imports, calls and inheritance relationships become nodes and edges. The agent can query that structure, trace a path between two symbols or inspect the connections around one concept. For developers watching agents burn turns on repeated search and file reads, the pitch is easy to understand. Context selection becomes a prepared artifact instead of a fresh scavenger hunt in every session.
Today's spike sits on a larger codebase. GitHub shows a repository created on April 3, 2026, with 1,810 commits on its current branch. PyPI lists graphifyy 0.9.63, published on September 16. The double "y" belongs to the package name; the installed command is graphify.
A map the agent can interrogate
The documented install is short:
uv tool install graphifyy
graphify install
According to the repository README, running Graphify on a project produces graph.html for browsing, GRAPH_REPORT.md for a written overview and graph.json for direct queries. A developer or agent can then ask a question such as:
graphify query "what connects auth to the database?"
graphify path "UserService" "DatabasePool"
The path command captures the project's governing idea. Text search can locate both names, but it does not automatically explain the chain of calls or references between them. Graphify's query layer tries to preserve that structure and return a smaller subgraph, giving the agent a route through the code rather than a stack of matching lines.
For source code, the extractor uses tree-sitter grammars locally. The README says it resolves cross-file relationships across roughly 40 languages and tags edges as EXTRACTED, INFERRED or AMBIGUOUS. A parsed import is different from a relationship inferred through name resolution, and a reviewer needs to know which kind is driving an answer.
The graph can include Markdown, PDFs, SQL schemas, office files and media through optional extras. The project's privacy documentation says code-only extraction can run without an API call, while documents, PDFs and images go through the coding assistant's model or a configured model backend. Video and audio transcription can run locally with faster-whisper. A team that permits local source analysis may still need a separate rule for design documents, screenshots or meeting recordings.
The latest release is mostly about edge quality
Version 0.9.63 does not add a flashy interface. Its release notes focus on whether graph edges point to the right place. Rust calls using self.method() can now resolve across split impl blocks. Ruby member calls can resolve through a superclass when the ancestry is unambiguous. The release also creates typed stub nodes for imported external modules instead of leaving dangling endpoints in graph.json.
These maintenance details can alter an agent's explanation of an architecture or its prediction about the effect of a change. A code graph is derived data. Its usefulness depends on parsers preserving language semantics and on resolvers declining to guess when two symbols share a name. The 0.9.63 notes repeatedly describe cases where Graphify leaves a relationship unresolved rather than forcing a match. That restraint matters as much as adding another language rule.
A correct map can still be outdated. Graphify's documented workflow can install Git hooks that rebuild the AST graph after commits and branch switches, but users must run graphify update . after a pull or merge. The documentation warns that a background rebuild on a large repository may lag by a few seconds. An agent querying during that gap can receive a coherent answer about yesterday's graph. Teams need to treat graph.json like any generated index: record how it was built, update it predictably and fall back to source when the map looks stale.
A useful benchmark with a small code test
Graphify publishes more evaluation detail than a bare speed claim. In the project's own benchmark harness, a fixed coding agent answered questions about ERPNext, a Python codebase of roughly one million lines. Adding one Graphify tool raised reported fact coverage from 70.8% with grep, read and list tools to 82.0%.
That result comes from six graded questions, and the Graphify condition used about 140,000 tokens per query, according to the same benchmark report. Six questions can expose a useful effect, but they cannot establish how the tool behaves across languages, repository shapes or everyday maintenance work. The harness is maintained by the project rather than an independent evaluator.
The larger memory tests contain mixed results. On 300 LOCOMO questions, Graphify reported 45.3% answer accuracy and 0.497 recall at ten retrieved items. Supermemory reached higher answer accuracy at 49.7%, although its reported ingest cost was much higher. On the 50-question English subset of LongMemEval-S, Graphify tied dense retrieval at 76% answer accuracy, while dense retrieval had slightly higher recall, 0.848 against 0.844.
The comparison method used Kimi K2.6 for model roles, a shared token budget and a model judge checked against a second judge. The project reports 90.6% agreement and a Cohen's kappa of 0.81 between the two judges. The tables disclose where another system wins. They still leave the most relevant developer question open: does the graph improve the tasks and languages in your repository enough to repay its build, review and update costs?
Installation changes the repository workflow
graphify install can do more than add a command. The platform instructions say that, depending on the target assistant and whether project mode is selected, it writes skill files, assistant instructions or hooks. For Codex, persistent guidance goes into AGENTS.md; for Cursor it goes into an always-applied rule. Claude Code and some other hosts can use hooks that steer search activity toward the graph.
Those files put Graphify inside the agent harness and can change which tools an assistant reaches for first. The team setup also allows a generated graph to be committed so colleagues share the same map. Both choices deserve code review because they alter repository behavior and add files that can drift.
Our hands-on Graphify review covers that setup reality. In a sandbox run against version 0.9.50, 4,541 project tests passed, 24 Terraform cases failed because the optional HCL grammar was unavailable and 212 were skipped. The result supports trying the base parser, while also showing why a team should test its own optional languages and inspect generated hooks before committing them. It does not certify the current 0.9.63 release.
There is one documentation conflict worth fixing. The README's environment-variable table says local query logging is off unless the user enables it. The current query-log implementation and its tests agree: without GRAPHIFY_QUERY_LOG or GRAPHIFY_QUERY_LOG_ENABLE, the logger returns without writing a file. A later privacy bullet in the same README still says every query is logged and tells users how to opt out. The code points to opt-in behavior, but privacy documentation should not require a source inspection to settle the default.
What to watch after the star surge
GitHub stars measure attention, and 437 in a day says developers are looking for a better way to orient coding agents. It does not show that the graph improved a production change or caught a regression. The next useful evidence would be independent trials across more than six code questions, with stale-index failures and false edges counted alongside correct answers.
For a team testing Graphify now, compare the files an agent reads and the turns it spends finding them. Then judge the resulting change under the same review with and without the graph. Keep source links in every consequential answer. A lower search bill matters only when the map still points to the right code when the change ships.