YouTube Instagram TikTok How it works FAQ

The fastest way to turn talking videos into clean, searchable text. Free, private and no account required.

About

Built by Rishav Raj with one goal: free transcripts for everyone.

rishav@yttotranscript.com

Transcribe

YouTube to text
YouTube with timestamps
Instagram Reels
TikTok videos

Learn

How it works
FAQ
YouTube transcripts guide

More

Chrome extension
Contact
Privacy policy
Terms of service

© 2026 YTtoTranscript. Made for creators & researchers.

Not affiliated with YouTube, Instagram or TikTok. Respect creators’ copyright.

Graphify + Obsidian + Claude Code = CHEAT CODE — Transcript · YTtoTranscript

Home/Transcripts/YouTube

YouTube Transcript

Graphify + Obsidian + Claude Code = CHEAT CODE

Chase AI · 3,396 words · 17 min read · EN-ORIG

Watch on YouTube

Share X LinkedIn WhatsApp

Below is the complete, readable transcript of Graphify + Obsidian + Claude Code = CHEAT CODE by Chase AI on YouTube. Read the full text, copy any part you need, or generate a transcript for any video with our free tool.

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 series of documents, into a knowledge graph and then folded that knowledge graph into Obsidian so Claude Code could query it at will? Well, that is exactly what I'm going to 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, Claude 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 Claude Code, 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 at some sort of repositories or series of documents with Graphify, and you want to know how that fits into the grander

Transcribe another video

Paste any YouTube, Instagram or TikTok link to get a free transcript.

Free · No sign-up · Unlimited

Add to Chrome — transcribe in one click

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 want to 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 Claude 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 Claude OS command center, which we'll probably touch on today. So, if you want to get your hands on it, there's a link in the pinned comments. You'll find it

inside of Chase AI 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 graphify. 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's going to 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 going to do. We're going to look at this non-code base vault scenario.

And for our demo, we're going to be pulling in the Claude Code documentation. So, we're going to download the Claude Code docs. We're going to point graphify at the docs. It's going to create a knowledge graph, and then we're going to push all that to Obsidian. That's going to be the demo. Now, the great thing about Graphify is

it kind of 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 Graphify that includes the Graphify skills, so we just use natural language. So, all I need to do is hop

into Claude Code and say, "Download the official Claude 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 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 Claude Claude Code documentation was 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. 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. 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 million token context. So, context window is the big node here and you see all these like related concepts. So, 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 kind of see them over here in things like checkpointing, cloud and web, LLM gateway, skills, etc. If you remember from our previous Graphifi video, this is where we make our money with Graphifi. The idea of pulling concepts from things and mapping them. Because now Claude 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, etc. 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 Graphifi, 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 Claude Code. I have Claude Code projects, Claude Code content, tons of stuff related to Claude

Code where Claude 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 Graphifi knowledge graph and Obsidian is made easy for us because, as I stated, Graphifi does this automatically. What Graphifi does when we call that Obsidian flag, it is going to go to every single node, like sub-agent for example, and it's going to create a markdown file for

sub-agent. And it's going to 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 going to 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 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 Claude OS Obsidian command center, you're kind of wary about just throwing things into the system. You want to 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} 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 going to make this its own

vault. It's still going to 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 going to put it inside of its

own directory to begin with. It sort of like quarantines it. Your second option is to kind of 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 flooded documents, we don't actually like how it fits into the grand scheme of things,

well, all we have 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, etc., etc." So, you don't need all 600, maybe you just want like 100 of the files related to sub-agents or something like that. So, you kind of just piecemeal it.

Option four is the most complicated and that's redistribution. So, in 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 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 going to first have it create its own separate vault, which is very simple cuz it automatically does that and then we're just going to 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 the Graphify stuff that we've been looking at, the graph.html and obviously graph.json, but over here is where it created that standalone vault. So, inside of my Chase folder under vaults there is a CC-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 got to do is you need to open up Obsidian, come down to the bottom left where it says manage vault. Then we're

going to open folder as vault. So, you're just going to 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 Asian 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 going to do if I tell Claude Code to look up the agents 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 going to get brought to this markdown file. It's going to see this markdown file. It's going to see everything related to it and it's going to see the source

document where it can extract all the information. Again, this is kind of 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 Claude code something about say bundled skills, it would come to the bundled skills doc, which links to the skills documentation. So, again, 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.

And 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 the CC docs vault structure into our main vault within its own subfolder." And it's 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 this is kind of 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 sell. 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 where just having it siloed, I think especially in terms of code bases and that sort of thing, probably makes sense to stop at Graphy Phi, but I think there is a large contingent of people who really do love Obsidian and how Claude 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 the sort of thing like I showed you. So, that is where I'm going to leave you in this video. That is how you are able to take something you've generated inside a Graphy Phi, 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 Graphy Phi. 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 want to get your hands on my Claude code masterclass. And besides that, I'll see you around.