Primary question: Is the token-reduction and graph-persistence gain worth depending on a 0.1.x skill and a temporarily named PyPI package?
RepoDaily adoption score
RepoDaily rates this as 92/100 (strong) for adoption: evidence, installation path, production risk, differentiation, license clarity, and AI/agent fit are scored from the article sources and adoption notes.
6 source(s) across 4 source category/categories, plus a RepoDaily-specific evidence module when available.
7 workflow step(s), 6 next-action step(s), and 3 command/install signal(s) were detected.
Trending momentum is +885 stars, with maintenance/release/issue signals counted when present.
Risk is marked medium, with 8 security note(s) and 4 explicit skip condition(s).
3 opportunity lens item(s), 4 alternative(s), and 3 type-specific section(s) support differentiation.
License source or license wording is present.
9 AI/agent-related signal(s) were detected in the article text and metadata.
Project overview
Graphify is a Claude Code skill that reads any folder you point it at, extracts concepts and relationships with Claude vision plus tree-sitter AST parsing, and assembles the result into a persistent knowledge graph. The pitch is concrete: instead of re-reading raw files for every query, you build the graph once and then query it repeatedly across sessions, with the README citing a 71.5x token reduction benchmark against reading raw files.
What makes graphify stand out in a crowded RAG and GraphRAG space is its multimodal ambition combined with an unusually disciplined security posture. It supports 13 programming languages through tree-sitter, accepts PDFs, markdown, screenshots, diagrams, whiteboard photos, and images in other languages, and emits artifacts you can actually use: an interactive HTML graph, an Obsidian vault, a Wikipedia-style agent-crawlable wiki, GraphML for Gephi, and Cypher for Neo4j.
The project is still early, with the current release at 0.1.x and a temporary PyPI package name of graphifyy while the canonical graphify name is being reclaimed. But the maintenance velocity is visible in the changelog: eight releases in April 2026 alone, each one closing real gaps such as follow-up questions being answered by re-exploring the directory instead of consulting the built graph.
Why it is trending now
- 885 period stars on a 0.1.x tool signals strong demand for skills that make AI coding assistants actually understand a whole codebase rather than guessing at fragments.
- The `/graphify .` command works on any folder and produces an interactive HTML graph, a persistent graph.json, an Obsidian vault, and optional Wikipedia-style wiki output, covering the formats real developers reach for.
- Changelog 0.1.6 fixed a serious latency bug where follow-up questions triggered up to 25 tool calls and roughly 90 seconds of work because the directory was re-explored instead of consulting graph.json; that kind of fix is what separates a demo from a usable tool.
- The README claims 71.5x fewer tokens per query compared with reading raw files, backed by a benchmark that the 0.1.4 release auto-runs on corpora over 5,000 words.
- Multimodal extraction via Claude vision covers screenshots, diagrams, whiteboard photos, and non-English images, which is rare among knowledge-graph tools that only parse source code.
Problem it solves
- Reading a large folder of code, papers, and notes repeatedly is expensive in tokens and slow in latency, especially inside an AI coding assistant that pays per call.
- Knowledge built in one session evaporates when the session ends, forcing the next session to re-read the same files.
- Code-only tools miss the conceptual relationships that span PDFs, tweets, screenshots, and prose notes, which is exactly the `/raw` folder pattern the README attributes to Andrej Karpathy.
- GraphRAG and RAG pipelines often require heavy infrastructure, vector databases, and custom embeddings before you can ask a single useful question.
- Node labels and file content in a graph visualization can leak untrusted text into HTML or into agent-facing output, creating injection risks if the tool is naive about sanitization.
How it works
- Install the Claude Code skill with `pip install graphifyy && graphify install`, noting that the PyPI package is temporarily named graphifyy while graphify is reclaimed.
- Open Claude Code in any directory and run `/graphify .` to trigger the skill, which then reads files, detects types, and extracts concepts and relationships.
- For source code, tree-sitter parses ASTs across 13 languages including Python, JavaScript, TypeScript, Go, Rust, Java, C, C++, Ruby, C#, Kotlin, Scala, and PHP.
- For PDFs, markdown, screenshots, diagrams, and images, Claude vision extracts concepts and relationships and links them into the same graph.
- The Leiden community detection algorithm, via graspologic, clusters the graph and splits oversized communities so navigation stays tractable.
- Artifacts land in graphify-out/: an interactive HTML graph, an Obsidian vault, an optional Wikipedia-style wiki, GRAPH_REPORT.md with god nodes and suggested questions, a persistent graph.json, and a SHA256 cache that skips unchanged files on re-runs.
- Query the graph with commands like `graphify query "..."`, `graphify path "DigestAuth" "Response"`, or `graphify explain "SwinTransformer"`, all of which read graph.json instead of re-reading the raw directory.
Architecture read: pipeline, modules, and extraction surface
The README and changelog describe a pipeline of detect, extract, build, cluster, analyze, report, and export, with an end-to-end integration test added in 0.1.5 that exercises every stage. Detection lives in detect.py and uses `os.walk(..., followlinks=False)` explicitly to avoid symlink traversal.
Extraction is split between AST parsing for code and semantic extraction for documents and images. Release 0.1.5 improved semantic extraction throughput from 12-15 files per chunk to 20-25 files per chunk, reducing subagent round trips, and code-only corpora now skip semantic dispatch entirely because AST handles them.
Community detection uses graspologic's Leiden implementation with oversized community splitting, and the resulting clusters drive the HTML renderer's community filter and the optional wiki's community articles. The 0.1.7 release added a dedicated `graphify/wiki.py` module with `to_wiki()` that emits cross-community wikilinks, cohesion scores, an audit trail, and a navigation footer.
The HTML renderer was replaced in 0.1.4: pyvis was removed in favor of a custom vis.js renderer that sizes nodes by degree, includes a click-to-inspect panel with clickable neighbors, a search box, a community filter, and physics clustering. This is a meaningful architecture detail because it removed a heavyweight dependency and gave the project direct control over the user-facing artifact.
Try-it path: install, run, and query in under 30 minutes
- Prerequisites: Claude Code and Python 3.10+, confirmed in pyproject.toml via `requires-python = ">=3.10"`.
- Install with `pip install graphifyy && graphify install`, or use `pipx install graphifyy` on macOS if pip fails with an externally-managed-environment error.
- On Windows, add `%APPDATA%\Python\Python3xx\Scripts` to PATH if `graphify` is not recognized after install, or use pipx which handles PATH automatically.
- Run `/graphify .` on any directory, then inspect `graphify-out/graph.html` for the interactive view and `graphify-out/GRAPH_REPORT.md` for god nodes and suggested questions.
- Run `/graphify ./raw --update` to re-extract only changed files and merge them into the existing graph, which is powered by the SHA256 cache in `graphify-out/cache/`.
- Try `graphify query "what connects attention to the optimizer?"` to confirm that follow-up questions now read graph.json instantly instead of re-exploring the directory.
Maintenance risk: version, packaging, and dependency posture
The project is at 0.1.x, with the pyproject.toml listing version 0.1.14, and SECURITY.md explicitly states that only 0.1.x is supported and anything below 0.1 is unsupported. The PyPI package is temporarily named graphifyy, and the README warns that the canonical graphify name is being reclaimed, which is a real operational risk for CI pipelines that pin package names.
Dependencies are pinned at the major-library level rather than exact versions: networkx, graspologic, tree-sitter, and a tree-sitter grammar per supported language. The optional-dependencies block exposes `mcp`, `neo4j`, `pdf`, `watch`, and `all` groups, which keeps the default install lean but requires users to opt into features like `graphify ./raw --neo4j` or `graphify ./raw --mcp`.
The changelog shows fast iteration with concrete fixes, including the 0.1.4 removal of 292 edge warnings per run by silently skipping stdlib and external edges, and the 0.1.6 fix that turned 25-tool-call follow-up questions into instant graph.json lookups. That is reassuring, but the 0.1.x major version and the package-name churn mean any team adopting graphify should pin the exact installed version in its tooling.
Who should pay attention?
Good fit if
- Developers who already use Claude Code daily and want persistent, cross-session knowledge of a codebase or research corpus
- Teams handling mixed corpora of source code, PDFs, markdown, and screenshots who need one graph that spans all of them
- Researchers maintaining a Karpathy-style `/raw` folder of papers, tweets, and notes who want queryable structure without a vector database
- Anyone who needs GraphRAG output in multiple formats: HTML, Obsidian, GraphML for Gephi, or Cypher for Neo4j
Skip for now if
- Projects that cannot use Claude Code or cannot send file contents to an LLM provider for extraction
- Teams that require stable, semver-major packaging guarantees before adopting a tool, given the 0.1.x version and temporary PyPI name
- Environments where installing tree-sitter grammars for 13 languages is impractical or where Python 3.10+ is unavailable
- Use cases that need a network-exposed knowledge-graph server rather than a local stdio-only MCP server
Risks and cautions
The tool is well-engineered and security-conscious, but it sits at 0.1.x, ships under a temporary PyPI package name, and depends on Claude Code plus an LLM provider for multimodal extraction.
- PyPI package is graphifyy, not graphify, while the canonical name is reclaimed; install scripts and CI pins must account for this.
- Only the 0.1.x line is supported according to SECURITY.md, so breaking changes between minor versions are possible.
- Multimodal extraction depends on Claude vision, which means file contents leave the local machine during the extract step unless you restrict inputs to local-only formats.
- Default install pulls in tree-sitter grammars for 13 languages, which is correct for general use but heavyweight for single-language teams.
- SECURITY.md states that graphify makes no network calls during graph analysis; the only network calls happen during explicit `ingest` URL fetches by the user.
- SSRF protection is enforced by `security.validate_url()`, which allows only http and https schemes, and `_NoFileRedirectHandler` blocks redirects to file://.
- Downloads are size-capped: `safe_fetch()` streams responses and aborts at 50 MB, while `safe_fetch_text()` aborts at 10 MB, and non-2xx HTTP responses raise HTTPError rather than being treated as content.
- Path traversal in the MCP server is blocked by `security.validate_graph_path()`, which resolves paths and requires them inside `graphify-out/`.
- XSS in graph HTML output is mitigated by `security.sanitize_label()`, which strips control characters, caps labels at 256 chars, and HTML-escapes all node labels and edge titles.
- Prompt injection via node labels is mitigated because sanitize_label is also applied to MCP text output, so source-file-controlled labels cannot break the text format returned to agents.
- The tool does not execute code from source files: tree-sitter parses ASTs without eval or exec, and no subprocess call uses shell=True.
- Symlink traversal is prevented because detect.py explicitly uses `os.walk(..., followlinks=False)`.
Alternatives to compare
| Approach | When to use | Trade-off |
|---|---|---|
LlamaIndex | You want a programmatic GraphRAG and RAG framework with fine-grained control over indexing and retrieval | Apache 2.0 |
LangChain | You need a broad orchestration layer for document loaders, embeddings, and graph stores across many providers | MIT |
Neo4j | You already run Neo4j and want a graph database backend rather than a local skill | GPLv3 / commercial |
Obsidian | You want a manual note-graph vault without an extraction pipeline | Free for personal use |
What this trend reveals
Persistent GraphRAG for coding assistants
Graphify's graph.json is designed to persist across sessions and to be queried weeks later without re-reading raw files, which directly addresses the amnesia problem in AI coding assistants. The benchmark cited in the README, 71.5x fewer tokens per query, is the kind of number that justifies adoption if it holds on a team's actual corpus.
Run `/graphify .` on a real 10,000-file codebase, measure tokens consumed for the first build, then measure tokens for five follow-up queries against graph.json versus re-reading the raw files.
Wiki output as an agent-navigation layer
The 0.1.7 release added a dedicated wiki module that generates an agent-crawlable wiki with cross-community wikilinks, cohesion scores, and a navigation footer. This is a distinct angle because it targets agent navigation rather than human navigation, and it could become a default interface for assistants that crawl their own context.
Generate the wiki with `graphify ./raw --wiki`, then point a second agent at `graphify-out/wiki/index.md` and measure whether it answers corpus questions more accurately than the raw HTML graph.
Security-first local GraphRAG
The SECURITY.md threat model is unusually explicit for a 0.1.x project, enumerating SSRF, oversized downloads, path traversal, XSS, prompt injection, YAML injection, encoding crashes, symlink traversal, and corrupted graph.json recovery. That specificity is a credible differentiator versus generic RAG tools that do not publish a threat model.
Attempt a redirect to file:// during `graphify add`, submit an oversized URL, and inject a node label containing HTML script tags, then confirm each is blocked by the documented mitigations.
RepoDaily verdict
Graphify is one of the most thoughtfully scoped Claude Code skills in the current wave: multimodal extraction, persistent graph.json, multi-format export, and a published threat model that addresses SSRF, path traversal, XSS, and prompt injection. The risk is real but bounded, the install command is wrong, not missing, the project just lives at graphifyy for now.