How to turn any YouTube channel into a searchable AI knowledge base

Picture this: instead of scrubbing through three hours of video to remember which timestamp explained a specific workflow, you just ask your AI agent a question and it answers instantly — with a citation back to the exact video and moment where that idea came from. That's not a hypothetical. It's what happens when you turn a YouTube channel's transcripts into a proper markdown knowledge base your agent can actually navigate.

This isn't about summarizing videos into bullet points and dumping them into a folder. It's about building a structured, cross-linked wiki — the kind Andrej Karpathy popularized and Google just formalized into an open standard. In this guide, you'll learn what that structure actually looks like, why plain markdown beats vector databases for this use case, and how to build one from any YouTube channel, including your own.

What made Karpathy's "LLM wiki" idea take off?

Earlier this year, Andrej Karpathy described a workflow shift that resonated across the AI community: instead of pointing an LLM at raw documents every time you have a question, you let the model build and maintain a persistent, structured wiki of markdown notes over time. It's a personal knowledge management system built on plain markdown files, designed to be queried by an LLM rather than browsed manually.

The reasoning behind it is simple. Ask a subtle question that requires synthesizing five documents and the LLM has to find and piece together the relevant fragments every time — the knowledge is never built up. NotebookLM, ChatGPT file uploads, most RAG systems all work this way. Karpathy's alternative flips that. Instead of retrieving from raw documents at query time, an LLM incrementally builds and maintains a persistent wiki — an agent reads each new source and integrates it into a structured, interlinked collection of markdown files.

The idea spread fast. In April 2026, Andrej Karpathy posted on X about this workflow shift, and the post went viral — 16+ million views — with the follow-up GitHub Gist hitting 5,000+ stars within days. Since then, the pattern has forked in dozens of directions, with 200+ implementations and a Google spec both vindicating the bet that pure markdown, no database, actually works.

Why did Google turn this into an official standard?

Here's the problem Google noticed: every team building AI agents was reinventing the same wheel for storing context. Every system has its own way of storing and retrieving background knowledge — one tool expects a PDF, another wants a vector database, a third needs a custom API. The knowledge itself is solid, but getting it to the right agent at the right time is a mess.

So in June 2026, Google Cloud shipped a fix. They introduced the Open Knowledge Format (OKF), an open specification that formalizes the LLM-wiki pattern into a portable, interoperable format — a vendor-neutral, agent- and human-friendly standard. The format itself is refreshingly unglamorous. The format itself is almost boringly simple: an OKF bundle is a directory of markdown files with YAML frontmatter. That is it. Every concept gets one file, the file path is its identity, the frontmatter carries a small set of structured fields, the body is markdown, and concepts link to each other with normal markdown links.

Google was clear this is a first draft, not a finished product. OKF v0.1 is a starting point, not a finished standard — it will evolve as more producers and consumers emerge and as the community collectively learns what knowledge representations agents actually need. But the point of releasing it as open and vendor-neutral was deliberate. OKF isn't tied to any specific cloud, database, model provider, or agent framework, and never requires a proprietary account or SDK to read, write, or serve it — Google published it as an open standard because the value of a knowledge format comes from how many parties speak it, not who owns it.

If you want to read the spec directly, Google Cloud's announcement post walks through the format and their reference implementations.

How do you actually build a YouTube channel knowledge base?

The real-world proof of concept for this is a public GitHub repository built from a creator's entire long-form video catalog. The cole-medin-knowledge-base repo is exactly the kind of structure you want to replicate for any channel. It's an OKF (Open Knowledge Format) knowledge base plus a Karpathy-style LLM wiki synthesized from an entire long-form YouTube catalog — agentic coding, AI engineering, RAG, harnesses, memory systems, and more — designed to drop next to any project for agent-ready, cited reference, with no database and no embeddings.

What makes it genuinely reusable is how little setup it takes. You clone it next to your project, read its index.md and then SCHEMA.md files, and treat it as a linked wiki of concepts and entities mined from the videos — navigating it the OKF way by reading the index and following relative links into concepts/, entities/, and sources/, opening only the pages a question actually needs rather than loading the whole folder. Every answer your agent gives stays grounded in the source material, too. When you ask a question, the agent answers from the knowledge base and cites the concept or entity pages it used along with the source videos they came from — each page ends with a Sources section listing videos and timestamps — and if something isn't covered, it tells you instead of guessing.

Here's the part that makes this strategy work for literally any channel, not just one specific creator's videos: three Claude Code skills are included that replicate the full pipeline — just point them at a channel. That means the ingestion pattern (pull transcripts, extract entities and concepts, write markdown files, cross-link everything, cite sources) is reusable infrastructure, not a one-off script.

Which tool actually pulls the transcripts?

Before any of this markdown-and-linking magic can happen, you need clean transcript data for every video on a channel — and doing that by hand for a catalog of 100+ videos isn't realistic. This is where SerpApi's YouTube Video Transcript API comes in. It's built specifically for pulling transcript data programmatically instead of clicking "show transcript" on every video one at a time.

Here's what the API gives you back: it allows you to scrape video transcripts from YouTube, with details such as snippets, start time, end time, chapters, and language details. That timestamp data matters — it's what lets your knowledge base cite the exact moment in a video where a concept was explained, instead of just linking to the video as a whole.

Getting started only takes a few steps:

1. Create a free account at serpapi.com and grab your API key. First, ensure you register at serpapi.com to get your API key — you can get 250 free searches per month.
2. Set the engine parameter to youtube_video_transcript and pass the video ID. The API endpoint is https://serpapi.com/search?engine=youtube_video_transcript.
3. Loop through every video ID in a channel's upload list, saving each transcript response as a separate file.
4. Feed those raw transcripts into your agent (Claude Code, or whatever harness you're using) along with the OKF/wiki instructions, and let it handle extraction, linking, and file generation.

A basic request looks like this in Python:

import requests

params = {
    "api_key": "YOUR_SERPAPI_API_KEY",
    "engine": "youtube_video_transcript",
    "v": "VIDEO_ID_HERE",
    "type": "asr",
}
search = requests.get("https://serpapi.com/search", params=params)
response = search.json()

This is essentially the exact pattern SerpApi documents in its own tutorial — swap in your API key and any video ID and you're pulling structured transcript data in seconds instead of minutes.

How do you get your agent to build the wiki itself?

Once you have raw transcripts sitting in a folder, the wiki doesn't build itself — you need to hand your agent instructions for how to process them. This is where the "single prompt" approach comes in. Instead of manually writing hundreds of markdown files and manually cross-linking them, you give your coding agent (Claude Code, Cursor, Codex, whatever you're running) a system prompt that describes the OKF/LLM-wiki pattern, then let it do the tedious bookkeeping.

That bookkeeping is precisely the part Karpathy pointed out humans hate doing and LLMs are actually good at. Karpathy pointed out that humans abandon personal wikis because the bookkeeping — updating links, filing summaries, pruning old info — is tedious, but this grunt work is exactly what LLMs are good at. In the LLM Wiki paradigm, the human feeds raw sources to the AI, and the AI acts as a librarian, writing, updating, cross-referencing, and maintaining a persistent, compounding directory of markdown notes.

Concretely, that means your agent needs to do a few distinct jobs when processing a batch of transcripts:

• Extract entities and concepts — the recurring people, tools, and ideas that show up across multiple videos, each becoming its own file.
• Write atomic concept pages — one file per idea, written for a machine to parse quickly rather than a human to read casually. Traditional documentation is written for humans — it's wordy, narrative, and full of context that humans need but that LLMs either don't need or actively get confused by. An LLM wiki is written for machines: it's structured, atomic, and consistent.
• Cross-link everything — connecting concept pages to entity pages to source pages using normal relative markdown links, exactly the way OKF specifies.
• Preserve provenance — tagging every claim back to the specific video and timestamp it came from, so your agent never states something without a source.

How do you get all of this into Obsidian?

Because every file is plain markdown with YAML frontmatter, dropping the finished knowledge base into Obsidian takes zero conversion work — you just open the folder as a vault. This matters because Obsidian gives you the graph view and backlink panel that make the cross-linking actually visible, not just theoretical.

Karpathy's own setup leans on this pairing directly. His setup uses Claude Code as the LLM agent and Obsidian as the wiki viewer for graph view, markdown rendering, and local links, alongside tools like the Obsidian Web Clipper for converting articles to markdown and Git for version history — his phrase for it: "Obsidian is the IDE. The LLM writes the codebase; you browse it visually.

If you're setting this up for the first time, Obsidian's official Getting Started documentation covers vaults, folders, and linking — everything you need to know before pointing it at a generated wiki folder.

What should you actually do with this?

Start small. Pick one YouTube channel — yours, or one you reference constantly for work — and pull transcripts for even just 10-15 of the most useful videos using SerpApi. Feed them to an agent with OKF instructions, let it generate the concept and entity files, then open the result in Obsidian and click through the graph view. You'll immediately see the difference between "a folder of transcripts" and "a knowledge base your agent can actually reason over."

The bigger opportunity here isn't really about YouTube at all. It's that an open, boringly simple format — markdown plus YAML frontmatter — just became the thing multiple companies, tools, and creators are converging on for agent memory. The channel-to-wiki pipeline is just the most concrete, provable version of that idea you can build this weekend. Once you've done it for one channel, doing it for the next one is just changing which folder of transcripts you feed in.