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.
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.
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 →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.
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.
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.
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.
Things they pointed at.
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.”
08:00
“Just willy nilly injecting 600 documents into this thing we built may not be exactly what we want.”
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.
00:00This 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?
00:15What 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?
00:28Well, 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.
00:35Why 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.
00:52Now 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.
01:02That 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.
01:17However, 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.
01:24It 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.
01:44This is where Obsidian comes in. We can take everything we found inside of Graphify and put it into our vault.
01:50Or 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.
02:02One is, hey. I figured all this stuff out with Graphify. I want it to now be part of the larger context of some project.
02:08Hey. We pretty much put it right into here. Or you're just like, I love everything Obsidian related.
02:13I wanna be inside the Obsidian infrastructure. I want the add ons. I like the UI, all that.
02:17That'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.
02:24So 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.
02:41So 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.
02:52This 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.
03:07We 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.
03:34And today, that's what we're gonna do. We're gonna look at this non code base vault scenario.
03:40And 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.
03:48It'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.
03:57So 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.
04:14And you can see that right here. Graphify dash dash Obsidian generates an Obsidian vault for us.
04:19So 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.
04:36That's it. And you can see what that actually looked like. So it went ahead and fetched the documentation.
04:41It was a 171 pages. It downloaded them all to a standalone folder, and then it began running the Graphify knowledge graph sequence on it.
04:52Now 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?
05:02Not necessarily. So the amount of documents Graphify grabbed from the official cloud cloud code documentation was a 145 documents.
05:11Now 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.
05:20And in fact, it pulled 591 nodes and it had 685 connections.
05:27Remember, each of these nodes is not a document. It's not a web page that was downloaded.
05:32It'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?
05:39Well, 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.
05:54So a 145 docs, 591 concepts, 685 connections, and 67 communities.
06:00Remember, what's a community? Communities are just groupings of these concepts.
06:04So 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.
06:12If 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.
06:27If 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.
06:38It 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.
06:44Okay? This has nothing to do with my Obsidian Vault. My Obsidian Vault has tons of stuff to do with Cloud Code.
06:50I 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?
07:04Although, 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.
07:12Now 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.
07:31And 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.
07:41So it's gonna create 591 markdown files with 685 appropriate links between those markdown files and instantly insert that into Obsidian.
07:54That'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.
08:03Now 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.
08:16So 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.
08:31I'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.
08:45So 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.
08:59That 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.
09:07For 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.
09:12When 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.
09:21What 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.
09:27What 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.
09:40That 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.
09:46What 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.
09:53The 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.
10:07Let'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.
10:17So 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.
10:24So 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.
10:43So it really makes it coherent within your Big Vault structure. Just understand that's more difficult to undo. So you have options.
10:51It'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.
11:07And 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.
11:19But 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.
11:29Now 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.
11:45So 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.
11:54And 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.
12:02It 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.
12:15It'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?
12:23What 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?
12:33Right? 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.
12:45When 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.
12:55So if I said, hey. You know, talk to me about auto mode.
12:59It'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.
13:08Again, 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.
13:19So 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.
13:30So 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.
13:41This 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.
13:57Right? Whatever our primary vault is. Like I said, we have those four options.
14:01We could do it piecemeal. We could do it however we want. But in this video, I'll show you how simple it is.
14:05Just 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.
14:13So 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.
14:22Those 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.
14:33And so hopping into the main vault, if I go to graph imports, Claude code docs, right, we can see all that over here.
14:41So 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.
14:52You 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.
15:06And 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.
15:25Right? The ultimate value of that really depends on your use case because there are tons of use cases.
15:31We'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.
15:50It'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.
16:00So 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.
16:17I 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.
16:28Make 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.
Named ideas worth stealing.
08:45list
Four Vault Integration Options
- Standalone: separate Obsidian vault, no impact on main vault
- Quarantine dump: one named subfolder in main vault, trivial to delete
- Selective harvest: Claude Code cherry-picks only relevant nodes
- Redistribution: Claude Code re-files nodes into existing folder taxonomy
A decision framework for how aggressively to merge a Graphify knowledge graph into an existing Obsidian vault, ordered from least to most integrated.
Steal forAny decision about whether to integrate a new data source into an existing system vs. keeping it isolated
How they asked for the click.
MENTIONED ON CAMERA
FROM THE DESCRIPTION
PRIMARY CTAWhere the creator wants you to go next.
OTHER LINKSAlso linked in the description.
