Graphify: Turn Any Folder Into a Knowledge Graph Your OpenClaw Agent Can Query

Graphify is a new open-source skill that adds a /graphify command to OpenClaw (and a dozen other AI agents). Point it at any folder — a codebase, a notes dump, a research archive — and it builds a persistent, queryable knowledge graph. The headline number: 71.5x fewer tokens per query compared to reading raw files.

The Problem It Solves

Andrej Karpathy has a /raw folder where he drops papers, tweets, screenshots, and notes. The graphify README calls this out directly: that folder is a classic problem for AI agents — too much unstructured content to dump into context, no structure to query against.

The same problem shows up everywhere: a codebase you're trying to understand, a research dump, years of markdown notes, a client project folder. Your agent can read individual files, but it can't reason about the relationships between them without loading all of them — which burns tokens and blows context limits.

Graphify builds a persistent graph of concepts and relationships across all those files once, then your agent queries the graph instead of re-reading the raw files every session.

What It Produces

Running /graphify . on any folder outputs:

graphify-out/
├── graph.html        # interactive graph — click nodes, search, filter
├── GRAPH_REPORT.md   # god nodes, surprising connections, suggested questions
├── graph.json        # persistent graph — query weeks later without re-reading
└── cache/            # SHA256 cache — re-runs only process changed files

The GRAPH_REPORT.md is particularly useful — it surfaces "god nodes" (concepts that appear everywhere), surprising connections you wouldn't have found manually, and suggested questions worth exploring. The graph.html is an interactive visual you can open in any browser.

Fully Multimodal

Graphify doesn't just handle code. It processes:

• Source code — 25 languages via tree-sitter AST (Python, JS/TS, Go, Rust, Java, C/C++, Ruby, C#, Kotlin, Swift, and more)
• PDFs and markdown
• Screenshots and diagrams (including whiteboard photos and images in foreign languages)
• Video and audio — transcribed with Whisper using a domain-aware prompt derived from your corpus

Everything goes into one unified graph, cross-referenced.

How to Use It With OpenClaw

Install via pip:

pip install graphifyy

Then in your OpenClaw agent, just type:

/graphify /path/to/your/folder

The agent runs the extraction, builds the graph, and saves the output. On subsequent sessions, it queries graph.json directly — no re-reading files, no re-running extraction unless files changed (SHA256 cache handles that).

To exclude folders (same syntax as .gitignore):

# .graphifyignore
node_modules/
dist/
vendor/
*.generated.py

The Token Math

The 71.5x token reduction claim comes from querying the graph structure vs. loading raw files. A codebase with hundreds of files might take 500K+ tokens to load entirely; querying the graph for "what calls the payment module?" returns the relevant subgraph in a fraction of that.

For OpenClaw users running on API billing, this is directly relevant. Large workspace contexts are one of the biggest drivers of API cost. If you're working with a complex codebase or large research archive, graphify could cut your per-session token spend significantly.

OpenClaw-Specific Notes

The graphify README notes that OpenClaw uses sequential extraction (parallel agent support is still early). This means large folders will take longer to process on first run compared to Codex or Claude Code (which support parallel extraction). For most use cases this is a one-time cost — the cache handles incremental updates efficiently.

Use Cases Worth Trying

• Understanding a new codebase — run graphify before diving in, let the GRAPH_REPORT.md orient you
• Research archive — papers, notes, bookmarks accumulated over years; ask "what themes show up?" without reading everything
• Client project context — index all project files so your agent can answer questions about any part without context overflow
• Workspace memory extension — complement OpenClaw's built-in memory.md with structured graph knowledge for large/complex domains

GitHub: safishamsi/graphify · PyPI: graphifyy