Graphify-Labs/graphify for Claude Code | Awesome Skills
Decision brief
What problem does Graphify solve?
Graphify is aimed at the moment when a coding assistant needs to understand relationships rather than merely find matching text. A large repository can scatter the answer to one question across routes, models, schema definitions, comments, design notes, and package metadata. Opening files one after another works for a narrow change, but it becomes a poor way to investigate a cross-cutting concern. The project turns those materials into a graph so that a question can begin with an entity or a plain-language prompt and return a smaller connected area to inspect.
That distinction matters. Search is useful when you know the exact term to look for. A graph is more useful when you want to ask what depends on a component, how two concepts connect, or where an unfamiliar name sits in the system. The documented query, path, and explain commands fit that second job. The output also distinguishes edges obtained directly from source from edges derived by resolution. That makes the result easier to treat as a map for investigation instead of an opaque summary.
The scope goes beyond application source. The repository describes inputs such as SQL schemas, shell scripts, documentation, papers, images, and media, alongside code relationships. For a team whose architecture is partly encoded in prose and operational files, that broader input model can make an investigation less fragmented. It is less compelling when the relevant answer genuinely lives in one small, well-known file tree; in that case, ordinary navigation is usually quicker and easier to verify.
Codex uses skills to help package capabilities that teams and individuals can use to complete specific tasks in a repeatable way. This repository catalogs skills for use and distribution with Codex.
Learn more:
- [Using skills in Codex](https://developers.openai.com/codex/skills)
- [Create custom skills in Codex](https://developers.openai.com/codex/skills/create-skill)
- [Agent Skills open standard](https://agentskills.io)
## Installing a skill
Skills in [
Free, local tool to track AI coding token usage and cost across 31 tools and agents (Claude Code, Cursor, Codex, Gemini and more), by model, project, and task. npx codeburn
The practical workflow is to build a graph before asking an assistant to reason about an unfamiliar codebase, then use the graph to narrow the investigation. A reviewer could start from a changed route or data model, trace connected entities, and open the returned source locations to confirm what matters. An engineer joining a project could use the report to locate the concepts with many connections before deciding which subsystem deserves a deeper read. Neither workflow asks the graph to replace source review. It reduces the amount of source that must be read before a meaningful review can begin.
Graphify also has a clear integration story for coding-agent environments. The README documents platform-specific installation commands and a project-scoped option. That is useful for a team that wants the same repository to carry its assistant guidance instead of relying on each contributor to remember a personal setup. The value here is consistency: a coding agent can be directed toward a scoped graph query before it starts broad search or sequential file reading.
Use the tool after the repository has a question worth tracing. Architecture review, change impact analysis, onboarding, and incidents with unclear ownership are plausible starting points because they involve links across files and documents. A routine edit with a known target is not. The cost of building and maintaining a derived representation only pays off when the questions repeatedly need that wider context.
Start with the installation details rather than assuming the package name and command are identical. The documented package is graphifyy, while the command users run is graphify. The preferred path uses uv tool install graphifyy; Python 3.10 or later is listed as a requirement, and pipx is described as an alternative. After the command-line tool is available, the README directs users to register the assistant skill and offers a project-scoped mode for repository-local configuration.
That setup has operational implications. A team should decide whether the tool belongs in an individual developer environment, in checked-in project configuration, or both. The project-scoped option is attractive when assistant behavior needs to be repeatable in review and onboarding. It also means the team should review generated instruction or hook files with the same care it gives any other developer tooling. The fact that several hosts are documented does not mean every host behaves identically, so begin with the exact platform command rather than treating compatibility as a generic checkbox.
Data handling deserves a separate check. The README states that source-code parsing is local through tree-sitter, but it also describes optional backend work for some semantic treatment of documents and media. That can be a good fit for a repository with a clear local-processing requirement for code, but the backend choice and the types of non-code material included should be evaluated before using it on sensitive material. Treat optional extras as separate adoption decisions, not as part of the default install.
Do not choose Graphify merely because a repository is large. If the work consists of a contained bug in a familiar module, a focused test, code search, and direct source reading will usually produce a faster and more reviewable answer. The graph is most useful when the relation between concepts is the hard part. Adding a graph-building step to a question whose answer is already obvious creates process without much return.
It is also the wrong tool when a team needs every relationship to be treated as a confirmed fact. The README's confidence tags are a strength because they expose which edges are extracted and which are inferred or ambiguous. They are also a reminder that an inferred connection needs source confirmation before it becomes the basis for a security decision, migration plan, or production change. Use graph output to prioritize investigation, then inspect the cited locations and tests.
Finally, be cautious about accepting benchmark figures as a substitute for local evaluation. The repository provides tables, methodology notes, and reproduction material, which is better than making an uncheckable performance claim. Even so, the relevant corpus, language mix, repository layout, and assistant workflow will vary. A pilot on one representative project is more informative than an abstract comparison. If the team cannot allocate time to validate the graph against known architecture questions, the tool will be difficult to evaluate responsibly.
Choose Graphify when the recurring problem is navigation through relationships: impact analysis across modules, tracing an unfamiliar dependency chain, connecting code to design rationale, or giving an assistant a bounded context before it starts an investigation. Its documented file coverage and report structure make that use case more credible than a generic claim that it simply understands a repository. The project is especially worth piloting when both code and supporting documents influence engineering decisions.
Run a small evaluation with questions whose answers your team already knows. Ask the graph to locate a dependency path, identify a high-connectivity concept, and surface the documentation that explains a design choice. Then compare the returned subgraph with the source and record where it was useful, incomplete, or misleading. This checks the exact property that matters: whether the graph helps a reviewer reach the right files sooner without causing them to skip verification.
Installation breadth should be a secondary criterion. The README shows explicit paths for common coding agents, including Codex and Cursor, and that reduces integration uncertainty. It does not remove the need to test the host-specific setup in your own repository. Start with the documented uv installation, use a project-scoped integration only after reviewing the generated files, and keep the pilot narrow. Expand after the team has evidence that graph queries improve the questions it actually asks.
Project-scoped installs write under the current directory, for example
.claude/skills/graphify/SKILL.md or .agents/skills/graphify/SKILL.md (plus a
references/ sidecar the skill loads on demand), and
print a git add hint for files that can be committed.
Per-platform commands that support project-scoped installs accept the same flag,
for example graphify claude install --project or graphify codex install --project.
PowerShell note: Use graphify . not /graphify . — the leading slash is a path separator in PowerShell.
graphify: command not found?uv tool install / pipx install put the graphify command in their tool bin dir (~/.local/bin). If your shell can't find it right after install — common on a fresh macOS + zsh setup — that dir isn't on your PATH yet: run uv tool update-shell (or pipx ensurepath), then open a new terminal. With plain pip, add ~/.local/bin (Linux) or ~/Library/Python/3.x/bin (Mac) to your PATH, or run python -m graphify.
Running with uvx / uv tool run instead of installing? Name the package, not the command: uvx --from graphifyy graphify install. Plain uvx graphify … fails (No solution found … no versions of graphify) because uv tool run reads the first word as a package, and the package is graphifyy — the graphify command lives inside it.
Avoid pip install on Mac/Windows if possible. The skill resolves Python at runtime from graphify-out/.graphify_python; if that points to a different environment than where pip installed the package, you'll get ModuleNotFoundError: No module named 'graphify'. uv tool install and pipx install isolate the package in their own env and avoid this entirely.
Git hooks and uv tool / pipx:graphify hook install embeds the current interpreter path directly into the hook scripts at install time, so the post-commit hook fires correctly even in GUI git clients and CI runners where ~/.local/bin is not on PATH. If you reinstall or upgrade graphify, re-run graphify hook install to refresh the embedded path.
Platform
Install command
Claude Code (Linux/Mac)
graphify install
Claude Code (Windows)
graphify install (auto-detected) or graphify install --platform windows
CodeBuddy
graphify install --platform codebuddy
Codex
graphify install --platform codex
OpenCode
graphify install --platform opencode
Kilo Code
graphify install --platform kilo
GitHub Copilot CLI
graphify install --platform copilot
VS Code Copilot Chat
graphify vscode install
Aider
graphify install --platform aider
OpenClaw
graphify install --platform claw
Factory Droid
graphify install --platform droid
Trae
graphify install --platform trae
Trae CN
graphify install --platform trae-cn
Gemini CLI
graphify install --platform gemini
Hermes
Codex users also need multi_agent = true under [features] in ~/.codex/config.toml for parallel extraction. CodeBuddy uses the same Agent tool and PreToolUse hook mechanism as Claude Code. Factory Droid uses the Task tool for parallel subagent dispatch. OpenClaw and Aider use sequential extraction (parallel agent support is still early on those platforms). Trae uses the Agent tool for parallel subagent dispatch and does not support PreToolUse hooks, so AGENTS.md is the always-on mechanism.
--platform agents (alias --platform skills) targets the generic cross-framework Agent-Skills locations: the spec's user-global ~/.agents/skills/ (read by npx skills and spec-compliant frameworks) for a global install, and ./.agents/skills/ for a project (--project) install. The bare graphify install stays single-platform (Claude Code) by design — use the named agents platform when you want the skill discoverable by any framework that reads .agents/skills.
graphify: command not found after installing
The CLI is installed but its bin directory isn't on your shell's PATH. Pick the fix for how you installed:
uv (uv tool install graphifyy): the command lands in uv's tool bin dir (~/.local/bin), which a fresh macOS/zsh setup often doesn't have on PATH. Run uv tool update-shell, then open a new terminal. (Find the dir with uv tool dir --bin.)
pipx (pipx install graphifyy): run pipx ensurepath, then open a new terminal.
pip (pip install graphifyy): pip installs scripts to a user bin dir that may not be on PATH — add ~/Library/Python/3.x/bin (macOS) or ~/.local/bin (Linux) to your PATH in ~/.zshrc/~/.bashrc, or just run python -m graphify.
uvx graphify … or uv tool run graphify … fails to resolve graphify
The PyPI package is graphifyy; graphify is only the command it provides. treats the first word as a , so it looks for a package called and reports . Name the package explicitly: (same as ). Or once and then call directly.
Anthropic Claude API (--backend claude, uses ANTHROPIC_API_KEY)
uv tool install "graphifyy[anthropic]"
bedrock
AWS Bedrock (uses IAM, no API key)
uv tool install "graphifyy[bedrock]"
azure
Azure OpenAI Service (--backend azure, uses AZURE_OPENAI_API_KEY + AZURE_OPENAI_ENDPOINT)
uv tool install "graphifyy[openai]"
sql
SQL schema extraction
uv tool install "graphifyy[sql]"
postgres
Live PostgreSQL introspection (--postgres DSN)
uv tool install "graphifyy[postgres]"
dm
BYOND DreamMaker .dm/.dme AST extraction (may need a C compiler + python3-dev if no wheel matches your platform)
uv tool install "graphifyy[dm]"
terraform
Terraform / HCL .tf/.tfvars/.hcl AST extraction
uv tool install "graphifyy[terraform]"
pascal
Pascal / Delphi .pas/.dpr/.dpk/.inc AST extraction (more accurate calls/inherits edges; falls back to a regex extractor when absent)
uv tool install "graphifyy[pascal]"
chinese
Chinese query segmentation (jieba)
uv tool install "graphifyy[chinese]"
all
Everything above
uv tool install "graphifyy[all]"
uv tool run
package name
graphify
No solution found … no versions of graphify
uvx --from graphifyy graphify install
uv tool run --from graphifyy graphify install
uv tool install graphifyy
graphify
python -m graphify works but graphify command doesn't
Your shell's PATH doesn't include the bin directory the command was installed to. Prefer uv tool install / pipx install over plain pip, then run uv tool update-shell / pipx ensurepath and open a new terminal (see the install notes above).
/graphify . causes "path not recognized" in PowerShell
PowerShell treats a leading / as a path separator. Use graphify . (no slash) on Windows.
Graph has fewer nodes after --update or rebuild
If a refactor deleted files, the old nodes linger. Pass --force (or set GRAPHIFY_FORCE=1) to overwrite even when the rebuild has fewer nodes.
Graph has duplicate nodes for the same entity (ghost duplicates)
Ghost duplicates (same symbol appearing twice — once from AST extraction with a source location, once from semantic extraction without) are now automatically merged at build time. If you see this in a graph built before v0.8.33, run a full re-extract to clean up:
graphify extract . --force
Ollama runs out of VRAM / context window exceeded
The KV-cache window is auto-sized but may be too large for your GPU. Reduce it:
LLM returned invalid JSON / Unterminated string warnings
The model's JSON response hit its output-token limit and was cut off mid-string. graphify auto-recovers (it splits the chunk and re-extracts the halves, and an oversized single document is first sliced at heading/paragraph boundaries so the whole file is still covered), so these warnings are noisy but not data loss. To reduce the churn, raise the output cap or shrink each chunk's output:
GRAPHIFY_MAX_OUTPUT_TOKENS=16384 graphify extract . --mode deep # lift the cap
graphify extract . --mode deep --token-budget 4000 # smaller input chunks -> smaller output
With a cloud gateway like OpenRouter, prefer --backend openai (set OPENAI_BASE_URL) over the Ollama shim — it's a cleaner OpenAI-compatible path. If the model has its own max-output ceiling, lowering --token-budget is the reliable lever.
Graph HTML is too large to open in a browser (>5000 nodes)
Skip HTML generation and use the JSON directly:
graph.json has conflict markers after two devs commit at once
Run graphify hook install — it sets up a git merge driver that union-merges graph.json automatically so conflicts never happen.
Extraction returns empty nodes/edges for docs or PDFs
Docs, PDFs, and images require an LLM call — code-only corpora need no key. Check that your API key is set and the backend is correct:
ANTHROPIC_API_KEY=sk-... graphify extract ./docs --backend claude
Skill version mismatch warning in your IDE
Your installed graphify version is different from the skill file. Update:
Claude Code prompt cache invalidated after every graphify extract
Graphify writes output files (graph.json, graphify-out/) into the workspace. If those paths aren't ignored, every write invalidates Claude Code's prompt cache, forcing a full re-upload at cache-write rates on the next turn. Add them to .claudeignore: