⚙️ Graphify under the hood

O Graphify is the tool that builds the second brain. It has two sides that seem like the same thing but do different jobs: one CLI (a program you run in the terminal — the package is called graphifyy, with two "y"s) and a skill that it installs inside in Claude Code. Understanding this duality avoids 90% of the confusion in the next tracks.

In practice, you install it once and get both sides. The installation command puts the CLI on your system; a second command registers the skill in Claude Code (it writes a SKILL.md in ~/.claude/skills/graphify/). Inside Claude Code, you doesn't need an API key: the session itself provides the model.

# 1) instala a CLI (recomendado, com uv)
uv tool install graphifyy

# 2) registra a skill /graphify dentro do Claude Code
graphify install

Once you’ve done that, you can trigger the skill in Claude Code by pointing it to a folder. The <isto-voce-troca> is the path to the source you want to map:

/graphify <./pasta-da-fonte>

↑ One source goes in, the graphify processes, and everything lands in graphify-out/. O graph.json is the center: the visual and the report (topic 3) derive from it.

Graphify uses two extraction engines, and which one runs depends on what you pointed to. If the source is code, it reads the AST via tree-sitter — fast, deterministic, and no API key. If the source is document (Markdown, PDF, image), it uses a LLM to understand the meaning from the text and extract the entities and relationships.

↑ Two paths, the same destination (the graph). Code goes through form (AST, no key); documents go through the meaning (LLM). Inside Claude Code, the model already comes from the session— no key; only headless use in a plain terminal requires ANTHROPIC_API_KEY.

When Graphify finishes, it doesn’t return “an answer” — it creates a folder call graphify-out/ with several files. Knowing which is which prevents the panic of “now what do I open?” on the first run. There are three main characters and one supporting character.

graphify-out/
├── graph.json          # fonte de verdade — tudo deriva daqui
├── graph.html          # visual interativo (abre no navegador)
├── GRAPH_REPORT.md     # auditoria: god nodes + perguntas sugeridas
└── cache/              # cache por arquivo (não re-chama o LLM à toa)

The supporting player is the folder cache/: it stores the result per file (identified by the hash of the content) so you don’t pay for the LLM call again when nothing has changed. That’s why the second run is usually much faster than the first.

Graphify points to two source types, and the choice changes everything that comes after. You can map a code base (a code repository) or a document corpus (a collection of PDFs, markdown files, notes). It’s not “better or worse”—they have different goals.

To map a code repository in a plain terminal, the command is the CLI's headless interface. Change the <.> using the project path (the dot means “current folder”):

# extrai o grafo do repositório na pasta atual
graphify extract <.>

# ou de uma pasta específica
graphify extract <./src>

Choosing between the two corpora also determines where the result goes: code usually produces a graph you query in Graphify itself (the subject of Track 3); documentation is what’s worth taking to Obsidian, where it fits into the project’s broader context. In this course, we follow the document path.

The raw graph (graph.json) is great for machines, but you still want a browse this knowledge. That's where two export modes come in—and they exist only in the skill (/graphify, inside Claude Code), not in the headless CLI. They are the --obsidian e o --wiki.

The Obsidian mode command inside Claude Code points to the source and tells it where to save the vault. Change the source path and the --obsidian-dir using whichever destination you want:

# exporta um vault Obsidian (um .md por nó + canvas)
/graphify <./docs> --obsidian --obsidian-dir <~/vault/graphify/claude-code>

# ou: artigos por comunidade, estilo Wikipédia
/graphify <./docs> --wiki

Here’s the honest truth of this module: on its own, the Graphify graph lives in a vacuum. It knows that corpus you provided inside out—and only it. It doesn't know about your other notes, your other projects, or the broader context where this knowledge should live. It's a silo: complete on the inside, isolated on the outside.

And that's exactly why the course doesn't stop at Graphify. Taking the graph to the Obsidian (the mode --obsidian from topic 5) is what takes knowledge out of a vacuum: inside the vault, it fits into broader context — alongside your other notes, linkable and integrable. The graph stops being an island and becomes a neighborhood in your second brain.