🛠️ Practical step-by-step guide

Graphify is written in Python (requires 3.10+) and the uv is a fast Python tools installer. Check your version with python --version before moving on.

The right foundation ensures that the graphify install it cleanly, with no version conflicts. This is the prerequisite that prevents most installation errors.

python --version · uv · PATH.

Run uv tool install graphifyy (the package has two 'y's); alternatively, pipx install graphifyy or pip install graphifyy. This installs the binary graphify that you’re going to call.

It's the course's main program — without it, nothing runs. One command leaves the graphify available in the terminal.

graphifyy · uv tool · uv tool update-shell.

graphify install writes ~/.claude/skills/graphify/SKILL.md; with --project it writes inside the current repository. That's what teaches Claude Code to use Graphify.

This is the step that activates the command /graphify within Claude Code. Without registering the skill, only the headless CLI is available.

skill · SKILL.md · --project.

Download Obsidian from obsidian.md, install and open it—it’s free and runs on desktop. You don’t need to create anything yet, just have it ready.

It's where the generated vault will live and be explored. Having it open now shortens the path when the markdown arrives.

Obsidian · vault · desktop.

Running via /graphify inside Claude Code, you do NOT need a key; only headless mode (plain terminal for documents) requires the ANTHROPIC_API_KEY. AST-based code extraction doesn’t use any keys.

Avoids getting stuck thinking you need to configure a key. Knowing when it’s needed saves time and confusion.

ANTHROPIC_API_KEY · skill vs headless · tree-sitter without a key.

Run graphify --help and make sure there is ~/.claude/skills/graphify/SKILL.md. If both respond, the environment is ready.

Catching a problem now is much cheaper than discovering it during extraction. This is the sanity check that completes the installation.

--help · checklist · sanity check.

Graphify accepts a code base OR one document corpus (PDF, markdown). The choice determines the type of source it will read.

It changes how it extracts information—code becomes a graph through the AST (no key required), while documents go through an LLM. Deciding early avoids rework.

code base · corpus · choice.

Ask Claude Code itself to download the official documentation to a local folder, for example ./claude-code-docs. This is the corpus used in the video example.

Having a real, known corpus makes it easier to compare your results with the video (they got ~145 documents there). A good starting point before using your own sources.

local folder · docs · 145 docs (example).

Put the files in a dedicated, clean folder (no drafts or temporary files). This folder is exactly what Graphify will scan.

A clean root creates a cleaner graph with less noise. Whatever goes into the folder becomes a node in the graph.

dedicated folder · structure · noise.

Start by pointing to a subset of the files, not the entire corpus at once. You can expand the scope after the workflow works.

A smaller extraction is faster and cheaper to test and refine. Iterating on a small scale avoids waiting (and paying) for a graph that might not work for you.

scope · subset · iterate.

Remove binaries, builds, duplicates, and anything that doesn’t carry meaning. Keep only the files that describe the knowledge.

Each additional file is potential noise in the graph. Less clutter means more relevant nodes and relationships.

exclusions · style .gitignore · signal/noise.

Run Graphify at the project root; the output goes to a folder graphify-out/ right there. The current directory (cwd) determines where the files appear.

Knowing where to run it makes output paths predictable. You always know where to find the graph.json later.

cwd · graphify-out/ · project root.

Inside Claude Code, use /graphify ./claude-code-docs; in a plain terminal, use graphify extract ./claude-code-docs. Both generate the same graph through different paths.

It’s the command that kicks off the extraction. Knowing both modes lets you choose what fits the moment.

skill vs headless · extract.

It reads the files, extracts entities and relationships, and detects communities with the Leiden algorithm. The result is cached so it doesn't have to redo everything each time.

Understanding the wait and the cache prevents anxiety and unnecessary reruns. You know the time is turning into nodes and edges.

extraction · communities · cache.

Open graphify-out/graph.html in the browser—it’s a self-contained file, with no server. It displays the nodes, connections, and communities interactively.

It’s the first time you see your actual graph. Exploring the visual builds the intuition the rest of the course relies on.

graph.html · browser · interactive.

O graphify-out/GRAPH_REPORT.md is a text audit that lists the god nodes and suggests questions. It works like an index of what the graph knows.

It tells you where to explore without guessing — the hubs and useful questions are ready to go. A great entry point into a large graph.

GRAPH_REPORT.md · god nodes · suggested questions.

Use graphify explain "Context Window", graphify path "Hooks" "Subagents" e graphify query "..." to query the graph. These are answers straight from the structure, without opening the vault.

Provides quick answers about concepts and the paths between them. It's the lightest way to use the knowledge already extracted.

explain · path · query.

graphify update . reprocesses only the changed files; --watch automatically rebuilds on save. Both avoid reprocessing the entire corpus.

Keeps the graph alive as the source changes, without paying the full cost every time. Incremental updates are what make the stack sustainable.

update · watch · incremental.

Inside Claude Code, run /graphify ./claude-code-docs --obsidian --obsidian-dir ~/vault/graphify/claude-code. O --obsidian enables the vault export.

This flag only exists in the skill, not in headless mode—it’s the detail many people get wrong. It’s what turns the graph into notes.

--obsidian · --obsidian-dir · skill-only.

O --obsidian-dir defines the output folder; without it, the skill creates its own directory (a kind of quarantine). You control where the files go.

Pointing to the destination prevents Markdown files from getting scattered in the wrong place. The isolated default is safe, but choosing gives you organization.

destination · dedicated folder · isolated default.

One file is generated .md per node, with [[wikilinks]] for the related ones, plus a graph.canvas with the communities grouped. It’s the navigable vault.

Understanding what each file is removes the mystery from the export. One node equals one note is the mental model for the entire vault.

md per node · wikilink · graph.canvas.

The export is regenerated from scratch on every run, always from the graph.json. There’s no manual merge—the graph is the source of truth.

This means the vault always reflects the current graph, with no intermediate states. You can rerun it as often as you like without worrying about inconsistencies.

regeneration · idempotent · source of truth.

/graphify ./docs --wiki generates articles by community with a index.md as an entry point. It’s another export format, geared toward reading.

It's a text-based, navigable alternative, good for people and agents that prefer to read articles. It's worth learning about before deciding between a vault and a wiki.

--wiki · index.md · article per community.

Check the destination folder — count the files .md and see if the graph.canvas is there. It’s a quick check on the file system.

Make sure the export worked before you invest time in Obsidian. Catch empty or truncated exports early.

note count · canvas · verification.

In Obsidian, open it in the bottom-left corner Manage vaults → Open folder as vault and choose the generated folder. Obsidian will treat that folder as a vault.

Obsidian needs to be pointed to the directory—it won't find it on its own. This is the step that connects the generated markdown to the interface.

manage vault · open folder as vault · recognize.

Open a hub note and follow the [[backlinks]] for the concepts connected to it. Each click takes you from one idea to its neighbor.

It's the second brain in action — you navigate knowledge through relationships, not search. Practicing this navigation is the module's goal.

note-node · backlink · navigation.

Open the graph.canvas in Obsidian and view the communities as named groups on a board. This is the bird’s-eye view of the corpus themes.

The canvas gives you the big picture that individual notes don't. Good for choosing which topic to start exploring.

canvas · community · named group.

Each node stores its provenance in the graph.json; bring the source documents closer and link each node to its source file (a signpost). That way, the concept points to the full text.

Lets the agent go from the concept to the full document when it needs more detail. Closes the gap between the summary and the source.

provenance · source doc · source link.

Obsidian's graph view draws links between Markdown notes—it's a mirror, not the Graphify graph. It shows links between notes, not the original typed relationships.

The video specifically warns you about this so you don’t confuse one thing with the other. Adjusting your expectations prevents frustration.

graph view · mirror · ≠ original.

There’s a ready-made prompt: ask Claude Code to bring in the source documents and link each node to its origin inside the vault folder. It automatically handles the linking step.

Automates the manual work from topic 4 with a single command. It’s the shortcut that makes connecting sources practical.

prompt · wire · automation.

Keep the generated vault as its own, separate vault. It stands alone, without mixing with the rest.

It’s good for anyone who only wants the knowledge inside the Obsidian ecosystem, without integrating it. It’s the default and safest behavior.

standalone · isolated · default.

Drop everything into a subfolder of your main vault (e.g., graph-imports/claude-code-docs) that you can delete entirely. It stays in context, but can be isolated.

Brings the knowledge closer with no risk — if you don’t like it, delete the folder and that’s it. It’s the middle ground between isolated and integrated.

quarantine · subfolder · deletable.

Ask Claude Code to bring in only the relevant notes (e.g., the ~100 about subagents) and ignore the rest. You get a slice, not the entire corpus.

Avoids dumping 600 files you’ll never use. Curation keeps the main vault lean.

harvesting · selection · curation.

Claude Code redistributes each note to the subfolder in your vault that makes the most sense. The knowledge gets diluted into your existing structure.

Gives you the greatest consistency with what you already have, but is the hardest to undo. It's a conscious choice to trade reversibility for integration.

redistribution · coherence · risk.

Ready-to-use prompt: ask it to move the generated vault structure into the main one, inside its own subfolder. It transfers the files for you.

Integrates the content in under a minute, without dragging folders one by one. It’s the practical execution of the quarantine strategy.

move · subfolder · prompt.

Rule of thumb — codebase? Stop at Graphify. Want it in Obsidian by itself? standalone. Integrate safely? quarantine. Curate? harvest. Total consistency? redistribution.

It gives you a decision path so you don’t get stuck when it’s time to integrate. Each option is a trade-off between consistency and reversibility.

decision · trade-off · reversibility.