Obsidian + Graphify: Let Your Notes Grow Their Own Knowledge Graph

Introduction

“Your notes aren’t too few — they’re too scattered.”

Recently, AI luminary Andrej Karpathy published a Gist with an idea that made me slap my forehead — LLM Wiki. The concept is simple: stop making AI search documents from scratch every time. Instead, let it maintain a continuously growing, self-updating knowledge base.

Karpathy’s original post: https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f

Great idea, but Karpathy only gave us the philosophy, not the tool. Within days, the open-source community built one — Graphify, a Claude Code skill that turns any folder into an interactive knowledge graph with a single command.

Graphify project: https://github.com/safishamsi/graphify/tree/v4

I ran it on 65 articles in my repository, and the results were stunning. Today I’ll walk you through the whole process — from theory to hands-on practice.

🔥 What Did Karpathy Say?

Most people use AI for knowledge management via RAG: upload a bunch of files, AI retrieves relevant snippets when you ask a question, then generates an answer.

The problem: every question, AI starts from zero.

Ask a question that requires synthesizing 5 documents, and AI has to search and piece them together all over again. Knowledge isn’t accumulated or structured.

Karpathy proposed a fundamentally different approach:

Let the LLM continuously and incrementally build and maintain a wiki — a set of structured, interlinked Markdown files. Each time you add new material, the LLM doesn’t just index it — it reads, extracts key information, and integrates it into the existing wiki.

The core architecture has three layers:

Raw (Source Materials): Your articles, papers, screenshots — immutable, AI reads only
Wiki (Knowledge Graph): AI-generated concept pages, entity pages, comparison pages — all interlinked
Schema (Rule Files): Tells AI how to maintain the wiki

In Karpathy’s own words: “Obsidian is the IDE, LLM is the programmer, wiki is the codebase.”

🛠️ Graphify: From Concept to Product

Graphify is the complete implementation of Karpathy’s vision.

It’s a Claude Code Skill that turns your folder into a knowledge graph with one command. It supports more than just Markdown — code, PDFs, screenshots, flowcharts, whiteboard photos, throw them all in.

What Does It Do?

Graphify extracts in two rounds:

Round 1: Structural Extraction (Free, No LLM Needed) Uses tree-sitter for AST analysis on code files, extracting classes, functions, and import relationships. Runs entirely locally with zero token consumption.

Round 2: Semantic Extraction (Requires LLM) Parallel-dispatches Claude sub-agents to process documents, PDFs, and images, extracting concepts, relationships, and design motivations (not just “what was done” but “why it was done this way”).

The results from both rounds are merged, then clustered using the Leiden community detection algorithm, producing three outputs:

Output File	Description
`graph.html`	Interactive knowledge graph visualization, nodes colored by community
`GRAPH_REPORT.md`	Analysis report: God Nodes, surprising connections, suggested questions
`graph.json`	Persisted graph data, usable across sessions

Key Highlights

Honest Auditing: Every relationship is labeled EXTRACTED (explicitly present in source), INFERRED (reasonable inference with confidence score), or AMBIGUOUS (has ambiguity). You always know what was actually found vs. what AI guessed
Token Compression: Official test data shows a 52-file knowledge base (code + papers + images) reduces per-query token consumption by 71.5x
Incremental Updates: SHA256 caching mechanism — re-runs only process changed files

📦 Install Graphify in 5 Minutes

Prerequisites: Python 3.10+, Claude Code

Step 1: Install Graphify

pip install graphifyy && graphify install

The PyPI package is temporarily named graphifyy (because graphify was still being recycled), but the CLI and Skill commands are both graphify.

Step 2: Run Full Build

In Claude Code, type:

/graphify .

That’s it — one command. Graphify auto-detects file types, dispatches sub-agents in parallel, and generates a complete knowledge graph.

My repository ran for about 5 minutes, producing:

Corpus: 89 files · ~51,110 words
316 nodes · 277 edges · 66 communities
Top God Nodes: MCP (16 edges), Skills (8), CLAUDE.md (8)

Step 3: Set Up Persistent Mode (Recommended)

After the graph is built, run in your project directory:

graphify claude install

This does two things:

Writes rules to CLAUDE.md telling Claude to read GRAPH_REPORT.md before answering questions
Installs a PreToolUse hook that auto-injects graph context on every file search

Once configured, Claude Code automatically references the knowledge graph even without you manually typing /graphify.

🔍 Real Results: What Did My 65 Articles Become?

After running, I got an interactive knowledge graph with 66 communities, each colored differently.

Opening graph.html, the most striking realization was:

I had no idea there were so many hidden connections between my articles!

God Nodes (Core Hubs)

The graph revealed the most central concepts in my knowledge base:

MCP (Model Context Protocol) — 16 connections, undisputed hub king
Skills (AI Agent Skill System) — 8 connections
CLAUDE.md Persistent Memory — 8 connections
Claude Code — 7 connections

This shows my writing has been consistently focused on AI tooling, with MCP as the central thread running through everything.

Surprising Connections

The most exciting part was the “Surprising Connections” section. Graphify discovered associations I never noticed:

Google Translate Real-time Conversation and Transformer Self-Attention Mechanism were linked — makes sense, real-time translation runs on Transformer
nvm (Node Version Manager) and SDKMAN (Java Version Manager) were recognized as semantically similar — both are macOS version management tools
WSL2 Backend for Docker and WSL2 Networking built cross-file connections — WSL2 knowledge from two different articles was automatically associated

These are connections you’d never discover managing notes manually.

🌐 Pairing with Obsidian Web Clipper: A Closed-Loop Workflow

A knowledge base isn’t a one-time project — it needs ongoing maintenance. Here’s the perfect companion: Obsidian Web Clipper.

What Is It?

An official, free browser extension from Obsidian, supporting Chrome, Edge, and Firefox. See a good article? Clip it to your Obsidian vault in one click.

Configuration

Install the Obsidian Web Clipper extension in your browser
Open extension settings, click the “Default” template on the left
Change “Note Location” to raw/articles
If you have multiple vaults, add the vault name in “General” settings, then select it in the template

Now every clipped article automatically saves to the raw/articles/ directory.

My Daily Maintenance Workflow

Browse web → Find good article → Web Clipper one-click save → Stored in raw/articles/
        ↓ (accumulate 2-3 days)
Open Claude Code → "Check new materials, update knowledge base"
        ↓ (auto-executed)
Read new files → Update wiki concept pages → Update graph → Done

No need to memorize commands — just tell Claude Code in natural language.

📊 Graphify Command Quick Reference

Command	Description
`/graphify .`	Full knowledge graph build
`/graphify . --update`	Incremental update (changed files only)
`/graphify query "your question"`	Query the knowledge graph
`/graphify path "Concept A" "Concept B"`	Find path between two concepts
`/graphify explain "concept name"`	Explain a node in natural language
`/graphify add <url>`	Fetch a webpage and add to graph

For daily use, you only need two:

Added new material → /graphify . --update
Want to look up knowledge → /graphify query "your question"

💡 Why Is This Worth Trying?

Looking back, the core problem Graphify solves is:

The pain point of knowledge management isn’t reading and thinking — it’s organizing and maintaining.

Why do people abandon their wikis? Because cross-referencing, syncing updates, and finding contradictions is tedious grunt work. LLMs don’t get bored, don’t forget to update a cross-reference, and can modify 15 files at once.

Your job is curating materials, guiding analysis, and asking good questions. AI handles everything else.

As Karpathy said, this idea traces back to Vannevar Bush’s 1945 Memex concept — a private, carefully curated knowledge base where connections between documents are as valuable as the documents themselves. The problem Bush couldn’t solve: who does the maintenance? Now, LLMs are here.