What is Graphify?
Graphify is an AI coding assistant skill that turns a folder of code, docs, papers, images, diagrams, screenshots, videos, or other project material into a queryable knowledge graph. Instead of making an AI assistant repeatedly scan raw files, Graphify creates a structured map of your project: important files, functions, concepts, relationships, communities, “god nodes,” and surprising connections. It supports assistants including Claude Code, Codex, OpenCode, Cursor, Gemini CLI, GitHub Copilot CLI, VS Code Copilot Chat, Aider, OpenClaw, Factory Droid, Trae, Hermes, Kiro, and Google Antigravity. (GitHub)
The official Python package name is:
graphifyy
But the command you run is:
graphify
The latest PyPI version I found is graphifyy 0.5.0, released on April 23, 2026. It requires Python >=3.10 and <3.14. (PyPI)
Why Graphify is useful
AI coding assistants are powerful, but they often waste time and tokens when working with large projects. They may grep too many files, read irrelevant folders, miss hidden relationships, or forget architecture after the session ends.
Graphify helps by creating a persistent project graph.
After running Graphify, you get output like:
graphify-out/
├── graph.html
├── GRAPH_REPORT.md
├── graph.json
└── cache/
graph.html is an interactive graph, GRAPH_REPORT.md summarizes important nodes and communities, graph.json stores the persistent queryable graph, and cache/ helps avoid reprocessing unchanged files. (PyPI)
This is useful for:
Large codebases
Legacy projects
Monorepos
Architecture understanding
Debugging complex flows
Onboarding new developers
Reducing token usage
Improving AI coding accuracy
Finding hidden dependencies
Explaining how modules connect
Basic mental model
Without Graphify:
Ask AI → AI searches files → AI guesses structure → AI edits code
With Graphify:
Build graph → AI reads graph/report → AI understands structure → AI edits better
Graphify does not replace tests, code review, or human judgment. It gives your AI assistant better context before it touches the code.
Prerequisites
You need:
Python 3.10+
pip or pipx
One supported AI coding assistant
A project folder or document folder to analyze
Graphify supports many assistants, but this guide focuses on:
Claude Code
OpenAI Codex
Install Graphify
Option 1: Install with pip
pip install graphifyy
Option 2: Install with pipx
This is cleaner if you want Graphify available globally without mixing it into your project’s Python environment.
pipx install graphifyy
Check installation:
graphify --help
Check version:
graphify --version
Upgrade Graphify
Because Graphify is moving quickly, upgrade before setting it up:
pip install --upgrade graphifyy
Or with pipx:
pipx upgrade graphifyy
As of the latest release info I found, version 0.5.0 added direct GitHub repo cloning, cross-repo graph merging, and data-loss protection for updates. (GitHub)
Create .graphifyignore
Before running Graphify on a real project, create a .graphifyignore file.
This prevents Graphify from wasting time on dependencies, logs, caches, build output, database dumps, and secrets.
Example:
cat > .graphifyignore <<'EOF'
.git/
vendor/
node_modules/
storage/
bootstrap/cache/
public/build/
dist/
build/
coverage/
.env
*.log
*.sql
*.dump
*.zip
*.tar
*.gz
*.bak
EOF
For Laravel:
cat > .graphifyignore <<'EOF'
.git/
vendor/
node_modules/
storage/
bootstrap/cache/
public/build/
public/hot
.env
.env.*
*.log
*.sql
*.dump
*.zip
*.bak
EOF
For Node/React:
cat > .graphifyignore <<'EOF'
.git/
node_modules/
dist/
build/
coverage/
.next/
.nuxt/
.env
.env.*
*.log
*.zip
EOF
For Python:
cat > .graphifyignore <<'EOF'
.git/
.venv/
venv/
__pycache__/
.pytest_cache/
.mypy_cache/
dist/
build/
.env
*.log
*.sqlite
*.db
EOF
Build your first graph
Go to your project folder:
cd /path/to/your/project
Run:
graphify .
If you are inside Claude Code, you can use:
/graphify .
If you are inside Codex, use:
$graphify .
Graphify’s docs note that Codex uses $ instead of / for skill calling. (GitHub)
What Graphify generates
After a successful run, check:
ls -la graphify-out
You should see something like:
graphify-out/
├── graph.html
├── GRAPH_REPORT.md
├── graph.json
└── cache/
GRAPH_REPORT.md
This is the most important file for day-to-day AI coding.
It gives a high-level summary of:
Important nodes
Communities
Core files
Surprising connections
Suggested questions
Architecture hints
graph.json
This is the persistent machine-readable graph. Graphify query commands use this file later.
graph.html
This is an interactive visual graph you can open in a browser.
cache/
Graphify uses cache so repeated runs do not need to process every file again.
Use Graphify with Claude Code
Claude Code has the deepest Graphify integration. Graphify can install both a CLAUDE.md directive and a PreToolUse hook, so Claude checks the knowledge graph before file search operations like Glob and Grep. (Graphify)
Step 1: Install Graphify
pip install graphifyy
Or:
pipx install graphifyy
Step 2: Install Claude integration
From inside your project folder:
graphify claude install
The general install command is also documented as:
graphify install
For Claude Code on Linux/Mac, the README lists graphify install; for the explicit always-on installer, it lists graphify claude install. (GitHub)
Step 3: Build the graph
Inside Claude Code:
/graphify .
Or directly from terminal:
graphify .
Step 4: Ask Claude architecture questions
Example prompts:
Use the Graphify report first. Explain the authentication flow.
Use graphify-out/GRAPH_REPORT.md before searching files. Where is payment status updated?
Use the knowledge graph to identify the files involved in user registration.
What the Claude integration does
Graphify’s Claude integration writes rules into CLAUDE.md and installs a PreToolUse hook in settings.json. The hook fires before Claude uses file-search tools and tells Claude to read GRAPH_REPORT.md if a graph exists. (Graphify)
That means Claude is guided toward:
Read graph/report first
Understand communities
Find god nodes
Then inspect raw files only when needed
This is much better than random grep-first exploration.
Use Graphify with Codex
Codex integration works differently from Claude Code. Claude Code supports a pre-tool hook, but Codex uses AGENTS.md as the always-on mechanism. Graphify writes guidance into AGENTS.md so Codex knows to check the Graphify report before raw file searching. (Graphify)
Step 1: Install Graphify
pip install graphifyy
Or:
pipx install graphifyy
Step 2: Enable Codex multi-agent support
For parallel extraction, Codex users need:
[features]
multi_agent = true
in:
~/.codex/config.toml
Graphify’s README and Claude integration docs both mention this for Codex parallel extraction. (GitHub)
Create or edit the file:
mkdir -p ~/.codex
nano ~/.codex/config.toml
Add:
[features]
multi_agent = true
If you already have a [features] block, do not duplicate it. Add multi_agent = true under the existing block.
Bad:
[features]
memories = true[features]
multi_agent = true
Good:
[features]
memories = true
multi_agent = true
Step 3: Install Codex integration
From inside your project folder:
graphify codex install
The README also lists the platform installer as:
graphify install --platform codex
Both are documented installation paths for Codex. (GitHub)
Step 4: Build the graph
Inside Codex, use:
$graphify .
Do not use:
/graphify .
Codex uses $graphify, not /graphify. (GitHub)
You can also run directly from terminal:
graphify .
Step 5: Ask Codex to use the graph
Example prompts:
Before searching raw files, read graphify-out/GRAPH_REPORT.md and identify the relevant modules.
Use Graphify first. Which files are involved in the checkout flow?
Use graphify query before grep. Find how booking status moves from pending to completed.
Important Graphify commands
Build graph for current folder
graphify .
Claude Code:
/graphify .
Codex:
$graphify .
Build graph for a specific folder
graphify ./src
Claude:
/graphify ./src
Codex:
$graphify ./src
Deep mode
graphify . --mode deep
Use this when you want more aggressive inferred relationships.
Update existing graph
graphify . --update
This re-extracts changed files and merges them into the existing graph. Graphify v0.5.0 added data-loss protection so --update refuses to overwrite graph.json with a smaller graph. (GitHub)
Cluster only
graphify . --cluster-only
This reruns clustering on an existing graph without re-extracting everything. (Graphify)
Skip visualization
graphify . --no-viz
This produces report and JSON output without generating HTML. (Graphify)
Watch mode
graphify . --watch
Watch mode keeps the graph fresh as files change. The docs say code saves can trigger an AST-only rebuild, while docs/images may notify you to run --update. (Graphify)
Query the graph
Once you have graphify-out/graph.json, you can query it.
Ask a natural-language question
graphify query "show the authentication flow"
Use DFS/path-style tracing
graphify query "show the payment flow" --dfs
Limit returned context
graphify query "how does booking cancellation work?" --budget 1500
Find path between two nodes
graphify path "User" "Payment"
Explain a node
graphify explain "BookingController"
The CLI reference documents query, path, and explain as direct ways to query graph.json without needing the assistant in the loop. (Graphify)
Export options
Graphify can export your graph in several useful formats.
Generate wiki-style markdown
graphify . --wiki
Generate Obsidian vault
graphify . --obsidian
Export SVG
graphify . --svg
Export GraphML
graphify . --graphml
Useful for tools like Gephi or yEd.
Export Neo4j Cypher
graphify . --neo4j
Push to live Neo4j
graphify . --neo4j-push bolt://localhost:7687
Start MCP server
graphify . --mcp
These export commands are listed in the Graphify CLI reference. (Graphify)
Keep the graph fresh
Option 1: Manual update
Run this after changes:
graphify . --update
Option 2: Git hooks
Install hooks:
graphify hook install
Check hook status:
graphify hook status
Uninstall hooks:
graphify hook uninstall
Graphify’s CLI reference says the hook install writes post-commit and post-checkout rebuild hooks. (Graphify)
Option 3: Watch mode
graphify . --watch
Use this while actively editing.
New in Graphify 0.5.0
The latest release I found is v0.5.0, published April 23, 2026. Important additions include direct GitHub repo cloning, cross-repo graph merging, and data-loss protection during updates. (PyPI)
Clone a GitHub repo directly
graphify clone https://github.com/karpathy/nanoGPT
Graphify clones repos into:
~/.graphify/repos/<owner>/<repo>
and reuses existing clones on repeat runs. The release notes also mention support for --branch and --out. (GitHub)
Merge graphs across repositories
graphify merge-graphs repo1/graphify-out/graph.json repo2/graphify-out/graph.json
Every node carries a repo tag so you can filter by origin. (GitHub)
This is useful for:
Microservices
Monorepos
Frontend + backend repos
Package ecosystems
Multi-app Laravel setups
Cross-repo architecture analysis
Recommended workflow for Claude Code
One-time setup
pipx install graphifyy
cd /path/to/project
graphify claude install
First graph build
graphify .
or inside Claude:
/graphify .
Daily workflow
1. Open Claude Code in the project folder.
2. Ask architecture/debugging question.
3. Claude reads GRAPH_REPORT.md first.
4. Claude inspects only relevant files.
5. Make small change.
6. Run tests.
7. Run graphify . --update after meaningful changes.
Good Claude prompt
Use Graphify before searching raw files. Read graphify-out/GRAPH_REPORT.md first, identify the relevant community and god nodes, then inspect only the files needed to fix the bug.
Recommended workflow for Codex
One-time setup
pipx install graphifyy
mkdir -p ~/.codex
nano ~/.codex/config.toml
Add:
[features]
multi_agent = true
Then:
cd /path/to/project
graphify codex install
First graph build
Inside Codex:
$graphify .
Or from terminal:
graphify .
Daily workflow
1. Start Codex inside the exact project folder.
2. Use $graphify . for first build.
3. Ask Codex to read graphify-out/GRAPH_REPORT.md first.
4. Use graphify query/path/explain before broad grep.
5. Edit only relevant files.
6. Run tests.
7. Run graphify . --update after major changes.
Good Codex prompt
Use Graphify first. Read graphify-out/GRAPH_REPORT.md before searching files. Identify the relevant files for this issue, explain why they matter, then make the smallest safe change.
Best practices for large projects
Run Graphify inside the smallest useful folder
Good:
cd apps/api
graphify .
Risky:
cd huge-parent-folder
graphify .
Smaller scope usually means:
Less noise
Lower cost
Faster graph build
Better AI answers
Fewer irrelevant relationships
Always use .graphifyignore
Do not graph:
vendor/
node_modules/
logs/
cache/
build output/
database dumps/
.env files/
generated files/
Read GRAPH_REPORT.md first
For most coding tasks, start with:
cat graphify-out/GRAPH_REPORT.md
Then use:
graphify query "your question"
Only after that should you inspect raw code.
Use graph commands instead of grep for architecture questions
Better:
graphify query "how does authentication work?"
Less ideal:
grep -R "auth" .
Use grep when you need exact text. Use Graphify when you need relationships.
Example: Laravel project workflow
cd /path/to/laravel-project
Create ignore file:
cat > .graphifyignore <<'EOF'
.git/
vendor/
node_modules/
storage/
bootstrap/cache/
public/build/
public/hot
.env
.env.*
*.log
*.sql
*.dump
*.zip
*.bak
EOF
Build graph:
graphify .
Ask:
graphify query "how does user login work?"
graphify query "which files handle booking status changes?"
graphify explain "BookingController"
Then ask Codex or Claude:
Use Graphify first. Based on GRAPH_REPORT.md and graphify query results, identify the controller/model/routes involved in booking status updates. Do not scan vendor or storage.
Example: Node/React project workflow
cd /path/to/react-project
Create ignore file:
cat > .graphifyignore <<'EOF'
.git/
node_modules/
dist/
build/
coverage/
.next/
.env
.env.*
*.log
EOF
Build graph:
graphify .
Query:
graphify query "how does routing work?"
graphify query "which components depend on the auth context?"
graphify explain "AuthProvider"
Example: Multi-repo workflow
With Graphify 0.5.0, you can clone and graph repos directly:
graphify clone https://github.com/example/backend
graphify clone https://github.com/example/frontend
Then merge graphs:
graphify merge-graphs backend/graphify-out/graph.json frontend/graphify-out/graph.json
Use this when you want to understand relationships across:
Frontend and backend
API and worker service
Main app and admin app
Package and consumer app
Multiple microservices
The v0.5.0 release notes describe direct GitHub cloning and cross-repo graph merging. (GitHub)
Troubleshooting
graphify: command not found
If installed with pip:
python -m pip install --upgrade graphifyy
Check your PATH:
which graphify
If installed with pipx:
pipx ensurepath
Then restart your terminal.
Wrong package installed
The official package is:
graphifyy
The command is:
graphify
Do not assume every similarly named package is this project. PyPI lists the project as graphifyy. (PyPI)
Graph is too noisy
Improve .graphifyignore.
Exclude:
dependencies
cache
logs
test snapshots
generated files
large assets
database dumps
compiled frontend builds
Then rebuild:
rm -rf graphify-out
graphify .
Assistant still greps too much
For Claude:
graphify claude install
For Codex:
graphify codex install
Then prompt clearly:
Use Graphify first. Read graphify-out/GRAPH_REPORT.md before grep/search.
Claude has a stronger hook-based integration; Codex uses AGENTS.md as its always-on mechanism. (Graphify)
Graph is outdated
Run:
graphify . --update
Or install hooks:
graphify hook install
Or use watch mode:
graphify . --watch
Codex parallel extraction is not working
Check:
cat ~/.codex/config.toml
Make sure you have:
[features]
multi_agent = true
Graphify docs mention this requirement for Codex parallel extraction. (GitHub)
Security notes
Do not include secrets in your graph.
Avoid graphing:
.env
private keys
database dumps
production logs
customer exports
access tokens
SSH keys
API credentials
Use .graphifyignore aggressively.
Example:
cat >> .graphifyignore <<'EOF'
.env
.env.*
*.pem
*.key
*.crt
*.p12
*.sql
*.dump
secrets/
private/
EOF
Best prompt templates
For Claude Code
Use Graphify before searching raw files. Read graphify-out/GRAPH_REPORT.md first. Identify the relevant community, god nodes, and files. Then inspect only the minimum files needed.
For Codex
Use Graphify first. Read graphify-out/GRAPH_REPORT.md and use graphify query/path/explain before broad grep. Make a small targeted change only.
For debugging
Use the Graphify graph to trace the flow related to this bug. Show the likely files involved, explain the relationship between them, then propose the smallest fix.
For onboarding
Use Graphify to explain this codebase. Start with the major communities, god nodes, important flows, and surprising connections.
For refactoring
Use Graphify to identify dependencies before refactoring. Show what modules depend on this file and what may break if it changes.
Recommended complete setup
For Claude Code:
pipx install graphifyy
cd /path/to/project
graphify claude install
graphify .
Then inside Claude:
/graphify .
For Codex:
pipx install graphifyy
mkdir -p ~/.codex
nano ~/.codex/config.toml
Add:
[features]
multi_agent = true
Then:
cd /path/to/project
graphify codex install
graphify .
Inside Codex:
$graphify .
Final summary
Graphify gives AI coding assistants a structured map of your project.
Use it like this:
.graphifyignore = exclude noise and secrets
graphify . = build the graph
GRAPH_REPORT.md = human/AI architecture summary
graph.json = persistent queryable graph
graphify query = ask architecture questions
graphify path = trace relationships
graphify explain = inspect one node
graphify --update = refresh changed files
Claude integration = CLAUDE.md + PreToolUse hook
Codex integration = AGENTS.md + $graphify command
Best mental model:
Graphify is not a replacement for your AI coding assistant.
Graphify is the map your AI coding assistant should read before walking through the codebase.