# Obsidian second brain with AI: MCP, qmd, and a 3,600-note vault > [!summary] TL;DR > Starting late 2024, tools like Claude Code, Claude Desktop, and Cursor learned the Model Context Protocol, so an agent can open, search, and write your Markdown notes directly: no copy-paste, no re-explaining projects from scratch, no plugin per client. Four years of disorganized Obsidian notes become a corpus you can query. The working stack is `mcp-obsidian` (with the Local REST API plugin) as the bridge, `qmd` for retrieval, and `basic-memory` for memory across sessions. ## Key points - About four years of notes in Obsidian: daily journals, reading highlights from Readwise, architecture decisions at work, half-formed ideas from walks, meeting notes, project retrospectives, notes about notes. - The vault sits at around 3,600 Markdown files, closer to 4,000 across the personal and work vaults combined. - Native Obsidian search is keyword-only, which stops being useful somewhere around a few hundred notes: "find everything I've written about distributed tracing" returns either the whole vault or none of it. - The starting point was Tiago Forte's *Building a Second Brain*: a trusted external system in plain Markdown, organised loosely with PARA. His core argument: we can't use our heads to store everything we need to know, so we have to put it somewhere else. - Starting late 2024, Claude Code, Claude Desktop, and Cursor learned the Model Context Protocol, so an agent can open, search, and write Markdown directly. - `qmd` is a small CLI by Tobi Lütke: BM25 for lexical matching, local vector embeddings for semantics, and a reranker to combine them. It runs entirely offline, indexes on save, and is the layer everything else in the stack calls into. - `mcp-obsidian` (with the Local REST API plugin) bridges the vault to any MCP-speaking client. - `basic-memory` persists structured observations across sessions, so a conversation next week has last week's notes to draw on. - Smart Connections and Khoj are the off-the-shelf options if you don't want to build your own retrieval. - Andy Matuschak's evergreen notes: notes should be "written and organized to evolve, contribute, and accumulate over time, across projects." Each note makes the next one more valuable. - An ADR written eight months earlier surfaced in a session and saved an afternoon of re-deriving the trade-off from scratch. - A reading highlight captured in February surfaced in May on a seemingly unrelated topic; the agent spotted the connection. - "What did I work on this week" becomes "summarise my devlog notes for the past 7 days," done in seconds. ## The shift: agents that read your notes I've been keeping notes in Obsidian for about four years, starting after reading Tiago Forte's *Building a Second Brain* and liking the premise: a trusted external system, all in plain Markdown, organised loosely with PARA. The core argument that stuck: we can't use our heads to store everything we need to know, so we have to put it somewhere else. I never did the canonical PARA reorganisation the books recommend; I just kept dumping things into the vault. Something genuinely shifted in late 2024: tools like Claude Code, Claude Desktop, and Cursor learned to speak the Model Context Protocol. An agent can now open, search, and write your Markdown directly. No copy-paste, no re-explaining projects from scratch, no plugin per client. Four years of disorganised notes became a corpus I could actually query. ## The retrieval stack - `qmd` (a small CLI by Tobi Lütke) is the tool I reach for most. It does BM25 for lexical matching, local vector embeddings for semantics, and a reranker to combine them. It runs entirely offline, indexes on save, and is the layer everything else in my stack calls into. - `mcp-obsidian`, with the Local REST API plugin, bridges the vault to any MCP-speaking client. - `basic-memory` persists structured observations across sessions, so a conversation next week has last week's notes to draw on. - If you don't want to build your own retrieval, Smart Connections and Khoj are the two I'd point you at. Their READMEs are better than my paraphrase would be. ## Why notes compound There's an idea originally articulated by Andy Matuschak in his work on evergreen notes: notes should be "written and organized to evolve, contribute, and accumulate over time, across projects." Each note makes the next one more valuable. Knowledge compounds. I never managed the discipline Matuschak describes; my notes aren't evergreen, they're a mix of journals, half-drafts, snapshots, and links. But the compounding principle plays out anyway, accidentally, with AI in the loop. Every time a session leaves a structured note behind, the next session has more to draw on. The vault gets denser. The agent gets sharper at your context, not because the model is getting smarter, but because it has more of your actual thinking to read. ## Moments from the last month - I asked Claude to help me revisit an architectural decision on a Go side project. It pulled an ADR I'd written eight months earlier, one I'd half-forgotten, and reminded me what I'd already concluded about the trade-off. Saved me an afternoon of re-deriving the argument from scratch. - A reading highlight I'd captured in February surfaced in a session in May, when I was thinking about something seemingly unrelated. The agent spotted the connection. I would never have surfaced that link manually. - "What did I work on this week" (a grind when writing a retrospective or a status update) turns into "summarise my devlog notes for the past 7 days" and the agent does it in seconds. None of these are magic. They're just years of accumulated context, finally legible to something that can act on it. ## The minimum useful stack, in order 1. An Obsidian vault, or any folder of Markdown files with some accumulated content. 2. A bridge: `mcp-obsidian` plus the Local REST API plugin. 3. A client: Claude Code, Claude Desktop, or Cursor with the MCP config pointing at the bridge. That's the floor. Add semantic retrieval on top when keyword search runs out: Smart Connections or Khoj off the shelf, or `qmd` by Tobi Lütke as I do. Add `basic-memory` when you want structured memory persisting across sessions. ## The honest limits Most of my notes are still messy and my PARA folders have weeds growing through them. The fully automated devlog I'd like (pulling from GitHub, Jira, calendar, and Things into a daily entry) is half-built: some days it writes itself, most days I do it by hand. I still occasionally lose notes because I can't remember which vault I put them in. There is no complete, polished system to copy here; anyone selling a finished system in this space is selling you the box, not the contents. The habit was always the moat. The system can come later, or never. Whatever shape your notes are in, if you have years of them in plain Markdown, an AI agent can read them today. If you have been keeping notes for years and wondering whether the effort was worth it: yes, but for a different reason than the second-brain books predicted. You probably won't go back and re-read them. Something else will. ## FAQ ### Can AI read my Obsidian vault? Yes. Since late 2024, tools like Claude Code, Claude Desktop, and Cursor speak the Model Context Protocol, so an agent can open, search, and write your Markdown directly. No copy-paste, no re-explaining projects from scratch, no plugin per client. ### How do I connect Claude Code to Obsidian? Use `mcp-obsidian` with the Local REST API plugin as the bridge, then point the MCP config of Claude Code, Claude Desktop, or Cursor at that bridge. ### What is qmd? A small CLI by Tobi Lütke that does BM25 lexical matching, local vector embeddings for semantics, and a reranker to combine them. It runs entirely offline and indexes on save. ### How many notes before Obsidian search stops being useful? Native Obsidian search is keyword-only, which stops being useful somewhere around a few hundred notes. Queries like "find everything I've written about distributed tracing" return either the whole vault or none of it. Add semantic retrieval (Smart Connections, Khoj, or `qmd`) when keyword search runs out. ### Does my vault need to be well organized for AI to use it? No. My PARA folders are a mess and I forget where I put things constantly; the notes still compound. Every structured note a session leaves behind gives the next session more to draw on. You don't have to be doing this perfectly, you just have to be doing it. ### What is the minimum setup to try this week? An Obsidian vault (or any folder of Markdown), the `mcp-obsidian` bridge plus the Local REST API plugin, and a client (Claude Code, Claude Desktop, or Cursor) with the MCP config pointing at the bridge. Add `basic-memory` later for structured memory across sessions. ### What are evergreen notes? Andy Matuschak's term for notes "written and organized to evolve, contribute, and accumulate over time, across projects." Each note makes the next one more valuable. You don't need the full discipline for the compounding to happen with AI in the loop. ## Related - [[resources/documentation/Agents/Agents Workflow|Agents Workflow]] (series hub) - [[resources/documentation/Agents/Agents - One Memory, Many Harnesses|One Memory, Many Harnesses]] (one memory shared across harnesses) - [[resources/documentation/Agents/Agents - Daily Working System|Daily Working System]] (two Obsidian vaults searched with `qmd` in the daily workflow) - [[resources/documentation/Claude Focus Workflow|Claude Focus Workflow]] (related workflow) ## Sources - [Building a Second Brain (Tiago Forte)](https://www.buildingasecondbrain.com/) - [PARA method (Tiago Forte / Forte Labs)](https://fortelabs.com/blog/para/) - [Model Context Protocol (Anthropic)](https://modelcontextprotocol.io/) - [Claude Code](https://www.anthropic.com/claude-code) - [Claude Desktop](https://claude.ai/download) - [qmd (Tobi Lütke)](https://github.com/tobi/qmd) - [mcp-obsidian](https://github.com/MarkusPfundstein/mcp-obsidian) - [Obsidian Local REST API plugin](https://github.com/coddingtonbear/obsidian-local-rest-api) - [basic-memory](https://github.com/basicmachines-co/basic-memory) - [Smart Connections](https://github.com/brianpetro/obsidian-smart-connections) - [Khoj](https://github.com/khoj-ai/khoj) - [Andy Matuschak](https://andymatuschak.org/) - [Evergreen notes (Andy Matuschak)](https://notes.andymatuschak.org/Evergreen_notes)