Big Idea

The argument in one line.

Graphify extracts concept-level relationships from any documentation corpus, and routing that graph into Obsidian wires it into your existing vault so Claude Code can navigate it as connected knowledge rather than isolated search results.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You use Claude Code on large codebases or documentation sets and find it loses track of how things relate.
You already have an Obsidian vault and want Claude Code to draw on it intelligently rather than treating it as a flat file dump.
You have Graphify installed but only use it in isolation — this shows how to fold its output into a broader system.
You want a single natural-language Claude Code prompt to download, graph, and vault an entire documentation site.

SKIP IF…

You need a from-scratch intro to Graphify or Obsidian — the video assumes both are already installed and familiar.
You work on small, self-contained projects where a flat folder of files is already enough context for Claude Code.

TL;DR

The full version, fast.

Graphify maps any documentation corpus into a concept graph — not file-by-file, but semantically, pulling concepts and their relationships. Running it on the Claude Code docs produces 591 nodes and 685 connections from 145 pages. The built-in --obsidian flag converts every node into a backlinked markdown file that Obsidian can render. Four integration patterns let you choose how aggressively to merge this graph into your main vault, from a standalone silo to full redistribution. The recommended starting point: a quarantine subfolder that holds everything and can be deleted in one move if it does not fit.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 02:41

01 · Graphify + Obsidian: the case for combining

Why Graphify alone is siloed (no connection to broader project context) and why Obsidian alone lacks semantic structure — combining them closes both gaps.

02:41 – 02:51

02 · Sponsor / course mention

Claude Code Masterclass inside Chase AI+ plug.

02:51 – 05:00

03 · Setup and demo scope

Requirements: Graphify and Obsidian already installed. Demo target: Claude Code documentation corpus (145 pages). Single Claude Code natural-language prompt runs the full pipeline.

05:00 – 07:00

04 · Inside the knowledge graph

145 docs produce 591 concept nodes with 685 connections across 67 communities. Context Window and Subagent shown as major hubs with visible relationship clusters.

07:00 – 08:45

05 · Graphify to Obsidian translation

How --obsidian converts each node into a backlinked markdown file. A bare stub vs. a wired node with its source document — why the source link matters.

08:45 – 11:00

06 · Four integration options

Standalone vault, quarantine dump, selective harvest, redistribution — trade-offs and reversibility of each approach.

11:00 – 13:00

07 · Moving into the main vault

Demo of the recommended path: standalone build first, then import as graph-imports/claude-code-docs subfolder. Result: 658 concept stubs + 146 full source docs.

13:00 – 14:30

08 · Wiring source docs to nodes

Second Claude Code command links every concept stub to the originating source document so queries return full text, not bare node metadata.

14:30 – 16:36

09 · Final state and closing

Obsidian graph view shows the new Claude Code docs cluster integrated with existing vault. When to stop at Graphify vs. push to Obsidian depends on use case.

Atomic Insights

Lines worth screenshotting.

Graphify does not index files — it extracts concepts from files, so 145 documents become 591 nodes with 685 edges between them.
A knowledge graph lets Claude Code follow relationships rather than grep for keywords, so it finds what a concept connects to, not just where it appears.
The --obsidian flag is built into Graphify — you do not need a separate export step to generate a vault from a knowledge graph.
Every Graphify node becomes a markdown file with automatic backlinks, which Obsidian renders as a connected graph you can inspect visually.
Injecting 600 markdown files into a working vault is a real risk — a quarantine subfolder is the safest default because it is deletable in one move.
A bare Obsidian node from Graphify is nearly useless to Claude Code on its own; it needs to be wired to the source document that originated it.
Selective harvest beats full import when you only need a slice of the graph — one Claude Code command filters 600 files down to whatever subset matters.
The Graphify knowledge graph and the Obsidian vault solve different problems: one is semantic structure, the other is organisational context — combining them closes both gaps.
A standalone Graphify vault and a quarantine subfolder differ only in whether the graph is inside your main vault directory — both are equally easy to open in Obsidian.
Redistribution (having Claude Code re-file nodes into your existing folder taxonomy) is the most powerful option and the hardest to undo — start with quarantine first.

Takeaway

How a concept map makes Claude Code faster on large projects.

WHAT TO LEARN

When Claude Code searches a flat folder of files it grep-matches — when it navigates a knowledge graph it follows relationships, which is why the same question gets a better answer.

Graphify does not index files, it extracts concepts from files — 145 documents become 591 concept nodes, each representing an idea rather than a page.
A knowledge graph tells Claude Code what is connected to a concept, not just where the word appears — so asking about sub-agents surfaces agent teams, context windows, and spawn patterns automatically.
Bare Obsidian concept stubs are nearly useless to Claude Code; each node needs to link back to its source document before the graph has real retrieval value.
The quarantine subfolder pattern imports all nodes under one deletable folder — you can always redistribute later, but you cannot easily un-redistribute.
Selective harvest beats full import when you only need a slice of the knowledge graph — having Claude Code cherry-pick 100 relevant files out of 600 is one command.
Graphify communities (auto-clustered concept groups) are a free categorisation layer — they reveal the hidden topic structure of a corpus without you having to define it manually.
The --obsidian flag is the entire integration bridge — one flag converts a knowledge graph into a backlinked markdown vault; the rest is just deciding where to put it.
This stack is most valuable on large documentation sets and codebases; on small projects a flat folder of files is already sufficient context for Claude Code.

Glossary

Terms worth knowing.

Graphify: A Python tool that reads any directory of files and produces a knowledge graph of the concepts found inside them and how those concepts relate, expressed as nodes and edges.
Knowledge graph: A data structure that represents information as concepts (nodes) and the relationships between them (edges), allowing queries to follow connections rather than match keywords.
Community (Graphify): A cluster of closely related nodes within a knowledge graph — Graphify automatically groups concepts that reference each other frequently into named communities.
Obsidian vault: A local folder of markdown files that Obsidian treats as a knowledge base, rendering backlinks between files as a visual graph and enabling search across the whole collection.
Backlink: In Obsidian, a wikilink from one markdown file to another using double-bracket syntax; Graphify generates these automatically when converting nodes to markdown.
Concept stub: A minimal markdown file produced by Graphify's --obsidian export that contains a concept's name and its connections but not the full source text — useful as a map node, but needs wiring to a source document to carry real content.
--obsidian flag: A Graphify command-line option that converts the knowledge graph output into a folder of backlinked markdown files compatible with Obsidian, creating either a standalone vault or an importable file set.

Resources

Things they pointed at.

02:41productChase AI+ Claude Code Masterclass ↗

02:51toolGraphify ↗

02:51toolObsidian ↗

03:40linkClaude Code Docs ↗

Quotables

Lines you could clip.

06:20

“This is where we make our money with Graphify — the idea of pulling concepts from things and mapping them.”

Tight thesis statement for the whole tool, no setup needed→ TikTok hook↗ Tweet quote

08:00

“Just willy nilly injecting 600 documents into this thing we built may not be exactly what we want.”

Relatable pain point for any Obsidian power user→ IG reel cold open↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

This might be the best stack for giving Claude code a second brain that we have ever seen. Everybody's been going crazy over using Obsidian or Graphify to help improve Claude code's memory. But what if instead of choosing between one tool or the other, we just combined all of them?

What if we use Graphify to turn any repository, whether that's a code base or a series of documents, into a knowledge graph and then folded that knowledge graph into Obsidian so Cloud Code could query it at will?

Well, that is exactly what I'm gonna show you how to do in today's video. So let's jump into it. So the first question we need to answer is why.

Why do we care about combining Graphify over here on the right and Obsidian over here on the left? Well, the answer is that by combining these two tools, Cloud Code is able to better answer questions about large repositories within the context of our vault.

Now what do I mean by that? Well, remember what Graphify does. Graphify allows us to point Claude code at any repository, any code base, and create a knowledge graph out of it.

That knowledge graph acts as a map for Claude code, showing it what's going on inside the code base or what's going inside the documentation, the different concepts, how they relate, and the why. This map, when given to CloggedCode, allows it to more quickly and efficiently answer questions about the code base.

However, the one downside of that within Graphify is that it's in a vacuum. It's just that code base. It's just that set of documents.

It doesn't relate at all to what's going on in our grander project that we might be, you know, taking a look at inside of our vault because the Obsidian vault can be rather wide ranging. And there may be scenarios where you've taken a look some sort of repositories or series of documents with Graphify, and you wanna know how that fits into the grander scheme of things.

This is where Obsidian comes in. We can take everything we found inside of Graphify and put it into our vault.

Or if you just like Obsidian in general and you want that whole Graphify construct to be its own standalone Obsidian vault, you can do that too. So there's sort of, like, two reasons to bring it to Obsidian.

One is, hey. I figured all this stuff out with Graphify. I want it to now be part of the larger context of some project.

Hey. We pretty much put it right into here. Or you're just like, I love everything Obsidian related.

I wanna be inside the Obsidian infrastructure. I want the add ons. I like the UI, all that.

That's an easy one too. So that's the why you should care. And before we go into the how, a quick word from today's sponsor, me.

So I just released the Cloud Code Masterclass, and it is the number one way to go from zero to AI dev, especially if you don't come from a technical background. I update this every single week, and there is a ton of content related to Obsidian inside of here, including how to build your own CloudOS command center, which we will probably touch on today.

So if you wanna get your hands on it, there's a link in the pinned comment. You'll find it inside of Chase a a plus. So to get this Graphify plus Obsidian stack working, you obviously need Graphify and Obsidian.

This video is not going to be a tutorial on how to use both of these tools from the ground up. I have content that already covers all of that, and I will link it above or you can take a look at my profile if this is all brand new to you. So the first thing we need is Graphite.

We need some sort of documentation or some sort of code base that we want to eventually pull into Obsidian. Again, there are two options here. One, we're looking at a true code base, or two, you're just looking at stuff that isn't code, documentation, PDFs, images, video, whatever, just some sort of corpus of information, some directory that Graphify is gonna take a look at, extract all the meanings and the connections, and we'll turn that into a vault.

And today, that's what we're gonna do. We're gonna look at this non code base vault scenario.

And for our demo, we're gonna be pulling in the Claude code documentation. So we're gonna download the Claude code docs. We're going to point Graphify at the docs.

It's gonna create a knowledge graph, and then we're gonna push all that to Obsidian. That's gonna be the demo. Now the great thing about Graphify is it kinda already has this built in.

So we don't have to do anything special on the Obsidian side. We have to do, like, one or two things, and I'll show you that. But the vast majority of this is handled via Claude, sorry, via Graphify commands because there is an actual Graphify flag that says, hey, create a vault of everything we just found.

And you can see that right here. Graphify dash dash Obsidian generates an Obsidian vault for us.

So to do this is pretty easy because remember, once we've installed the Graphify, that includes the Graphify skills, so we just use natural language. So all I need to do is hop into Cloud Code and say download the official Cloud Code documentation, point Graphify at it, then use the Graphify Obsidian command to turn it into a vault.

That's it. And you can see what that actually looked like. So it went ahead and fetched the documentation.

It was a 171 pages. It downloaded them all to a standalone folder, and then it began running the Graphify knowledge graph sequence on it.

Now the knowledge graph it created from the documentation was this one, but let's dive a little bit more into how it actually created these nodes. Like, where are these nodes coming from? Is are each of these nodes, like, one of the pages it downloaded?

Not necessarily. So the amount of documents Graphify grabbed from the official cloud cloud code documentation was a 145 documents.

Now every document does not relate to a node. What Graphify does is it takes a look at all those documents and it pulls concepts from those documents.

And in fact, it pulled 591 nodes and it had 685 connections.

Remember, each of these nodes is not a document. It's not a web page that was downloaded.

It's a concept from the page, and then it connects them. And we can see that here. So, like, if I look at context window, what's connected to it?

Well, we see stuff like path scoped rules and sub agent separate context window and post tool use hook and extended 1,000,000 token context. So context window is the big node here and you see all these, like, related concepts.

So a 145 docs, 591 concepts, 685 connections, and 67 communities.

Remember, what's a community? Communities are just groupings of these concepts.

So something like context is probably a community. You can kinda see them over here at things like checkpointing, cloud and web, LLM gateway skills, etcetera.

If you remember from our previous Graphify video, this is where we make our money with Graphify, the idea of pulling concepts from things and mapping them. Because now Cloud Code, if I give it this knowledge graph, this map, it can very easily figure out answers about the documentation.

If I ask it a question about sub agents, well, it's very easy for it to figure out what's related to sub agents, things like agent teams, etcetera, because it's not just grepping it. It's not just control f ing it. It has the map.

It knows the connections. It understands the why. But right now, even though this is great and all inside of graphite, this is in a vacuum.

Okay? This has nothing to do with my Obsidian Vault. My Obsidian Vault has tons of stuff to do with Cloud Code.

I have Cloud Code projects, Cloud Code content, tons of stuff related to Cloud Code where Cloud Code documentation information would be a valuable asset. So now the question is, how do I pull all that into here, into this quote, unquote knowledge graph I have inside Obsidian?

Although, remember remember, this isn't exactly the same as a true knowledge graph when we're looking at Obsidian. It's just a bunch of connected markdown files.

Now this transition between the Graphify knowledge graph and Obsidian is made easy for us because, as I stated, Graphify does this automatically. What Graphify does when we call that Obsidian flag is it's gonna go to every single node, like sub agent, for example, and it's gonna create a markdown file for sub agent.

And it's gonna create automatic backlinks, you know, the things that allow us to have connections inside of Obsidian with all of these nodes that are connected to it.

So it's gonna create 591 markdown files with 685 appropriate links between those markdown files and instantly insert that into Obsidian.

That's a lot. That's a lot of markdown files that are about to get just straight up injected into our current Obsidian vault and our current Obsidian structure.

Now on one hand, that's a good thing because there's probably a lot of valuable information there. But on the other hand, just willy nilly injecting 600 documents into this thing we built may not be exactly what we want. It might be a little bit too much.

So what are our options for handling all this new data that's about to be injected? Because if you're like me and you've created an entire CloudOS Obsidian command center, you're kind of wary about just throwing things into the system. You wanna handle on what goes in and out.

I'm not worried, and my end game isn't to just have a cool looking Obsidian knowledge graph. Like, this is part of a coherent system. Well, to mitigate or have a better handle of this flood of markdown files going to our vault, we really have four options.

So the first option, and this is more if you're someone who just wants to get the information into the Obsidian ecosystem. You don't really care about it being in your, quote, unquote, main vault, and that's to have it just create a standalone vault for all this information.

That means, hey. I have this knowledge graph, and I'm just gonna make this its own vault. It's still gonna be in a vacuum, but it's a vacuum inside of Obsidian.

For some people, that's great. That's what they want. And in fact, this is sort of the default thing that will happen with Graphify.

When you ask it to create the Obsidian vault, it's just gonna put it inside of its own directory to begin with. It sort of, like, quarantines it. Your second option is to kinda have a quarantine dump.

What do I mean by that? Well, we can look here inside of my Obsidian. I have a number of folders over here on the left.

What we can do is we can take this new Claude code documentation series of markdown files, all 600 of them, and just give them their own specific subfolder in the vault and just call it, like, Claude code documentation.

That allows us to if, hey. We get this flood of documents. We don't actually like how it fits into the grand scheme of things.

What we always like to do is delete a single subfolder and everything is solved. So we bring it into context, but we have an easy way out.

The third option is we sort of just harvest whatever information we want. So what we do is we have Claude Code take a look at that standalone directory of all those markdown files Graphify created, and we have Claude Code go through and say, okay.

Let's bring this in, ignore that, bring that, ignore that, etcetera, etcetera. So you don't need all 600. Maybe you just want, like, a 100 of the files related to sub agents or something like that.

So you kinda just piecemeal it. Option four is the most complicated, and that's redistribution. So and this is sort of a case by case basis.

So remember, we talked about giving all these Claude code documents their own specific subfolder that we could delete at will if we didn't like it. Well, we also have the option of having Claude code again go through all the markdown files that were created by Graphify and then redistributing them to whatever subfolder it thinks makes the most sense.

So it really makes it coherent within your Big Vault structure. Just understand that's more difficult to undo. So you have options.

It's not all or nothing when it comes to integrating the Graphify knowledge graph into whatever you have going on with Obsidian. My suggestion and what I'll show you here today is we're gonna first have it create its own separate vault, which is very simple because it automatically does that.

And then we're just gonna bring it in as its own subfolder so it's easy to delete it if we need to. So we can see here what it built. It has to graphify stuff, but we've been looking at the graph.html and obviously graph dot JSON.

But over here is where it created that standalone vault. So inside of my chase folder under vaults, there is a c c dash docs, which is a standalone Obsidian vault.

Now Obsidian still needs to recognize this thing. So even after it creates a standalone Obsidian vault, what we have to do is we have to hop into Obsidian and point it at this directory. So what you gotta do is you need to open up Obsidian, come down to the bottom left where it says manage Vault, then we're gonna open folder as Vault.

So you're just gonna go to your file directory. For me, that's going to Vaults and then CC Docs. This is whatever folder it created, then selecting the folder.

And now we have an Obsidian vault based on that knowledge graph. Now we aren't done here yet because, yes, it was able to take the knowledge graph.

It was able to take all these nodes and essentially turn these nodes into markdown files. But the issue is these markdown files are just like what you see here. It's just pretty bare bones.

It's basically the title of that particular concept, like agent threat model prompt injection, and then the actual connections to it. Like, where is it?

What are the edges in the graph? This in and of itself doesn't do a whole lot for us. Like, what are we gonna do if I tell Claude code to look up the agent's command stuff and it's just this?

Right? So what we have to do now is we need to bring in the source documents that all this was based on. That way when we hand Claude code this knowledge graph map, but in its Obsidian view, it's not just reading random nodes.

When it reads a certain node like data retention in the same way it does that inside of Obsidian, it then links it to the appropriate source document.

So if I said, hey. You know, talk to me about auto mode.

It's not just gonna get brought to this markdown file. It's gonna see this markdown file. It's gonna see everything related to it, and it's gonna see the source document where it can extract all the information.

Again, this is kinda like a signpost on the map that points Claude code in the right direction to get information. So the command I gave it was pull the source docs in and wire every node to its origin in the CC docs folder.

So now as I click through any of these markdown files, I have a clear source doc link. So if I click on this, this brings me to the original documentation that's now inside Obsidian.

So if I ask Cloud Code something about, say, bundled skills, it would come to the bundled skills doc, which links to the skills documentation. So, this is sort of the map app work.

This is how we're able to translate this sort of knowledge graph into a markdown mirror of it that works inside of Obsidian. And now that we have this created inside of this standalone Obsidian vault, the next step is to just move this vault into our big vault.

Right? Whatever our primary vault is. Like I said, we have those four options.

We could do it piecemeal. We could do it however we want. But in this video, I'll show you how simple it is.

Just move it right over. So I just wrote, now move this CC docs vault structure into our main vault within its own subfolder. I was able to do that in under a minute.

So now inside of our main vault, we should have a graph imports subfolder and then the Claude code docs subfolder underneath that. We have 658 concept stubs.

Those are the markdown files that are related to the nodes in the knowledge graph from Graphify, and all those link to one of the 146 full source documents.

And so hopping into the main vault, if I go to graph imports, Claude code docs, right, we can see all that over here.

So work tree flag, I click on that. Here's the full document and on and on and on. And you should see already sort of a difference in what the Obsidian graph structure looks like.

You can see all this over here on the right. And And this is kinda everything we just inserted when it comes to Claude code documentation. Just sort of a visual representation of how this is now, you know, inserted into the greater context of all the Claude work we do.

And like we talked about in the beginning, that's the cell. It's the fact that we now have all this Claude code documentation. Again, insert that for whatever you want, for whatever makes sense for you, and it's now in the greater Obsidian Vault ecosystem versus just being this thing in a siloed area.

Right? The ultimate value of that really depends on your use case because there are tons of use cases.

We're just having it siloed, I think, especially in terms of code bases and that sort of thing. Probably makes sense to stop at Graphify, but I think there is a large contingent of people who really do love Obsidian and how Cloud Code plays into it and building something like a command center. And so having that option that I showed you here today, again, it's just one tool in your toolbox.

It's not a one size fits all. You have to know when to use it. And luckily, I don't think it's too difficult of a, you know, thing to execute when it comes to this sort of thing like I showed you.

So that is where I'm gonna leave you in this video. That is how you are able to take something you've generated inside of Graphify, whether that's some sort of unstructured documents like we did today or a code base and bring it into Obsidian, whether that's in a siloed process or you're bringing it into some sort of larger context.

I think both these tools are awesome, Obsidian and Graphify. And so the more you can get used to playing with these sort of things together, the the more kind of stuff you unlock. So as always, let me know what you thought.

Make sure to check out Chase AI plus. It's linked down in the description if you wanna get your hands on my ClawdCode masterclass. And besides that, I'll see you around.

The Hook

The bait, then the rug-pull.

The promise is simple and the execution is a single natural-language Claude Code prompt: point Graphify at any documentation corpus, let it extract concept-level relationships, then fold the resulting knowledge graph into Obsidian so Claude Code can navigate your existing vault as a connected map rather than a flat pile of files.

Frameworks