All video notes
Video notes · Notes and PKM

How To Build LLM Wiki In Obsidian? 🧠 A Memory Layer For Any Agentic AI

Video by Wanderloots on YouTube · 34 min · uploaded May 2026

Notes and analysis by BrainTube, written from the video. Not affiliated with Wanderloots. Watch on YouTube

In short

Wanderloots shows how to turn an Obsidian vault into an LLM wiki: raw sources that never change, a compiled wiki the agent writes, and a schema layer (agents.md, templates, skills, a Python tool) that keeps the agent consistent. The structure is sound and the Git plus lint discipline is the best part. The vault firewall is weaker than it sounds, and the claim that this beats RAG is asserted rather than tested.

The argument

The video argues that an AI agent can maintain a structured knowledge base for you, but only if you give it a contract first. Raw material is captured once and kept untouched. The agent compiles it into concept, entity and topic notes that cite the raw file. A schema layer of rules, front matter, naming conventions, templates, repo-local skills and a deterministic Python script makes that compilation repeatable, and Git gives you a save point every time the agent edits the vault. Because the whole thing is plain markdown plus scripts, Callum (Wanderloots) says you can swap Codex for any other coding agent, or for a local model through Ollama, without rebuilding.

Key ideas, with timestamps

  1. 1:00

    Three layers: raw, wiki, schema

    Layer one is captured source material, layer two is the compiled wiki, and layer three is the schema that tells the agent how to build it. Every wiki note cites its raw source, so the original is preserved and claims stay traceable. He calls the schema the contract between you and the agent, which is the right mental model for the whole build.

  2. 4:00

    Five prerequisites, one of them optional

    He installs Python for repeatable scripts, Git for save points, Obsidian as the store, a coding agent (he uses Codex) and, optionally, a local model runner. His reason for Python is concrete: scripts save tokens and make results more accurate than asking the model to improvise each time.

  3. 6:01

    The vault becomes a Git repo first

    Before any notes exist, Codex initialises the empty vault as a repository, adds a .gitignore for Obsidian's churny config files and makes a first commit. The point is that an agent will eventually corrupt something, and you want to roll back to a known state. He commits after every structural step.

  4. 7:00

    Obsidian-aware skills and the CLI switch

    He installs a skill pack from Obsidian's CEO covering the Obsidian CLI, markdown, Bases, Canvas and Defuddle, so the agent writes proper double-bracket wiki links. At 8:30 he turns on the command line interface in Obsidian's settings, which is what lets the agent act on the vault directly. Skipping either step is a common reason agent-written vaults end up with broken links.

  5. 10:00

    agents.md as the constitution

    The agents.md file holds non-negotiable rules (never overwrite raw files, use normal tags, always write front matter) and points to schema files for required metadata, naming conventions, workflow recipes and a lint checklist. At 13:01 the agent also gains repo-local skills: query, ingest, maintain and lint. Change a naming convention in the schema and every new note follows it.

  6. 16:01

    A Python tool so the agent stops guessing

    The wiki_tool.py script builds the index and catalog, checks structure, searches the catalog, scans raw files, updates a source manifest and audits coverage. It also hard-codes an allowed tag list. He frames it as turning the schema into code, so the same command gives the same result whichever model runs it.

  7. 23:30

    The lint pass catches a real bug

    After ingesting his own theory video, he runs maintain, lint and query. The query check finds that "shared memory" did not resolve because catalog search was not reading body text, and the agent fixes the search. It is the most convincing moment in the video, because it shows the checks doing work rather than just existing.

  8. 27:31

    Vault firewall and a local model with review

    He wraps the Obsidian CLI skill in an "Obsidian safe" script with an allowlist of vaults, and at 29:01 the agent refuses to write into his tutorial vault. From 29:32 he adds Ollama: the local model drafts concepts into a proposed folder, he reviews them, then applies the draft and triggers maintenance. Double-click launchers at 31:01 turn the steps into buttons.

What it gets right

Immutable sources plus citations is the correct base. Most AI notes setups let the model rewrite the only copy of what you saved. Keeping raw files untouched and making every compiled note point back to one means you can always check a claim, re-run ingestion with a better model, or throw the wiki away and rebuild it.

Git before content. Committing the empty vault, then committing after each step, is cheap insurance that most tutorials skip. Pairing it with the wiki log gives you both a human summary and an exact diff of what the agent changed.

Deterministic code where it matters. Indexing, tag validation and coverage checks are jobs for a script, not a prompt. The video's split, where the model writes prose and Python enforces structure, is the pattern that holds up as a vault grows.

Review before apply for weaker models. The proposed-folder step for Ollama output is a sensible human-in-the-loop gate, and his advice at 26:30 to stabilise the system on a strong cloud model before going local is correct.

What it leaves out or overstates

The firewall is a convention, not a boundary. The allowlist wraps the Obsidian CLI skill. A coding agent with shell access can still write files into another vault's folder with ordinary file tools, and he concedes it only makes overriding "a little more difficult". If privacy between vaults matters, run the agent with filesystem access scoped to one folder, or a separate OS user, rather than trusting a skill.

"More efficient than RAG" is untested. At 13:01 he says reading an index and then opening only relevant pages beats retrieval-augmented generation. That works at tens or hundreds of notes. At the thousands of sources he predicts at 22:31, an index file itself becomes too long to read every time, and you are back to needing search. The video's own bug, where catalog search missed body text, hints at this.

The build is partly behind a paywall. The schema files and scripts are generated live, but the finished starter kit is offered to paying members, and a setup file is promised for later. Viewers get the architecture, not a reproducible repo.

No word on cost or contradictions. There are no token or time figures for ingesting a long transcript, and nothing on what happens when two sources disagree about the same concept. A compiled wiki needs a rule for that, such as keeping both claims with their citations.

How this applies to memory across AI tools

The video's strongest promise is portability: plain markdown that any agent can read. That holds for coding agents running on your machine. It does not hold for chat apps such as ChatGPT or Claude on the web, which cannot open a local folder. To share one store across those, it has to be reachable over a protocol they support, which today usually means an MCP server. See what an MCP memory server is.

If you want the compiled-wiki idea without maintaining the scripts yourself, BrainTube takes the hosted route: it saves YouTube videos with their transcripts, articles, PDFs and podcasts into one compiled knowledge base and exposes it as an MCP server that Claude, ChatGPT, Cursor and other MCP clients can search. The self-built vault gives you more control over schema and templates. The trade-off is that you own the lint, the backups and the access rules. For more options, see personal knowledge bases for AI.

Who should watch it

Watch it if you already use Obsidian and a coding agent such as Codex or Claude Code and want a structured way to let the agent maintain your notes. The core build runs from 5:01 to 25:30; the schema walkthrough at 10:00 to 15:30 and the lint fix at 23:30 are the parts to study. Jump to 27:31 for the vault firewall and 29:32 for the Ollama draft-and-review loop. Skip it if you do not want to run Python, Git and a terminal agent, or if you want a downloadable template: the finished kit is offered to channel members, not shown in full.

Frequently asked

What is an LLM wiki in Obsidian?
It is a vault where an AI agent reads raw sources you capture, such as transcripts and articles, and writes linked concept, entity and topic notes that cite those sources. A rules file and templates tell the agent how to name, tag and structure each note. You read and browse the result in Obsidian like any other vault.
Do I need Python and Git to build an LLM wiki?
Not strictly, but the Wanderloots build uses both for good reasons. Git lets you roll back when the agent damages notes, and Python scripts handle indexing and validation the same way every time. Without them you rely on the model to stay consistent on its own, which gets harder as the vault grows.
Can I run an LLM wiki with a local model like Ollama?
Yes. The video shows Ollama drafting new notes into a review folder, which you approve before they are applied. Local models make more mistakes than strong cloud models, so the review step matters. He suggests building and tuning the system on a cloud agent first, then moving to a local model.

Keep videos like this one searchable

BrainTube saves YouTube videos with their transcripts into one compiled knowledge base that Claude, ChatGPT, Cursor and other MCP clients can search.

Start free

Go deeper

More video notes

Are you the creator and want this page changed or removed? Contact us and we will act within 48 hours.