Making your Obsidian vault work with AI (it already does — here's the part that doesn't)

There’s a version of the “AI second brain” pitch that wants to sell you a new app. A smarter editor, a vault with an assistant baked in, an “AI-first” alternative to Obsidian. And every time one launches, the same reply shows up in the comments — the one that keeps winning the argument.

On the Show HN thread for OpenKnowledge (an AI-first Obsidian/Notion alternative, 381 points, on June 25), the top skeptical comment put it plainly:

“I don’t understand how Obsidian, a collection of markdown files, isn’t already AI friendly. It’s hard for me to imagine a more AI-friendly but still usable way to organize your notes.” — culi

And right below it:

“I just open the Obsidian folder (aka ‘vault’) in VS Code and BOOM, it is AI friendly. I just hack on the .md files like I would code with Copilot.” — outside1234

They’re right. If you’re deciding how to make your vault “work with AI,” the honest starting point is that it mostly already does — and the reason is the least glamorous thing about it. So this guide is going to split the problem into its two directions and be honest about which one is actually solved.

Direction one: AI reading your vault (mostly solved)

Your vault is a folder of plain Markdown files. That is the most machine-readable, future-proof, model-agnostic format a personal knowledge base could possibly be in. No proprietary schema, no database, no export step. A language model — or a person with grep — can read it directly.

Which is why “let an AI read my vault” is a problem the ecosystem has already mostly answered, and you don’t need to build anything to get it. A few honest options, from lightest to heaviest:

• Just point a coding agent at the folder. As outside1234 said: open the vault in your editor and let Copilot or Claude Code work over the .md files. For a lot of people this is genuinely the whole solution.
• Wire it up over MCP. If you want Claude or Claude Code to search and traverse your vault as a first-class thing, the servers already exist: mcp-obsidian, obsidian-mcp-server, or the official filesystem MCP that reads the files directly with no plugin at all. “Use Obsidian as Claude’s memory” is a documented, actively-used pattern, not a research project.
• In-vault plugins, if you want retrieval to live inside Obsidian itself, are a mature category too.

There’s a real limitation worth naming, because it’s the one honest gap on this side. A raw folder has no index and no link graph for the model to lean on — as one developer put it in a GitHub issue, “Claude Code sees a folder of markdown files with no search index, no link graph, and no retrieval, so every question means grepping the vault from scratch.” That’s a real cost at scale, and it’s exactly what the MCP-over-vault projects are racing to fix. But notice what it isn’t: it isn’t a reason to leave Markdown. It’s people building better retrieval on top of Markdown, precisely because the format is already the right one.

So: reading is handled. Pick the lightest option that fits and move on. The interesting problem is the other direction.

Direction two: your AI thinking reaching the vault (the actual gap)

Here’s the asymmetry nobody’s app fixes. Your vault can be read by any AI you like. But a growing share of your actual thinking now happens inside the AI — the messy first drafts, the explanation that finally clicked, the plan you talked your way into — and none of that ever lands in the vault at all.

It sits in a chat history behind a login, on a server you don’t control, in a format you can’t query. Your second brain has a hole in it, and the hole is shaped exactly like the conversations you had this week.

This is a real, repeated ask, not a hypothetical. Someone filed it as a feature request against an unrelated tool: developers “want to pipe notable AI sessions into their second brain… turning AI conversations into permanent notes.” The need is generic enough that people keep requesting it wherever they happen to be standing.

So the useful question isn’t “which AI app should replace my vault.” It’s: what would it take to get my AI conversations into the vault I already have — as good citizens, not as junk?

What a good inbound capture actually looks like

Dumping a chat transcript into your vault as a wall of text isn’t capture; it’s litter. A conversation earns its place in a second brain only if the vault’s own machinery — Dataview, the graph, tag search — can act on it like anything else. Concretely, that means:

• Frontmatter you can query. Stable, consistently-named YAML fields — source, title, dates, a link back — so a Dataview table can pull “every Claude chat about [[Project Atlas]], newest first” without manual cleanup.
• Tags and a wikilink-able title. Something the graph can see, and a title clean enough that [[that conversation]] autocompletes instead of forcing you to type a timestamped filename.
• Update in place, not duplicate. Re-running the capture should overwrite the existing file, matched by conversation id — not spawn conversation (3).md. The single loudest complaint about the copy-paste-and-scripts approach is “ran it twice, got 200 duplicates.”
• Body fidelity. Code fences stay code fences, tables stay tables, math stays math. Clean prose in, clean retrieval out — and paste-back-able code when you need it.
• No plugin, no API key, no self-signed certificate. The heavier “proper” integrations ask you to install a plugin, run a local REST server, and paste in a key. That’s a lot of ceremony for “save my chats,” and it’s why most people never finish. Your vault is already just a folder; anything that writes good Markdown to it is “Obsidian support.”

That last point is the one the app-sellers keep missing. You don’t need an AI layer bolted onto your notes. You need your AI conversations to become notes.

Doing it with Carry

Carry is a browser extension built for exactly this inbound direction. It’s the capture layer for your AI conversations — not another exporter, and not an app that wants to replace your vault. Here’s what it does today, and only that:

You point it at the folder Obsidian already opens, connect the provider you’re logged into (no API key, no developer account — it uses the session you already have), and sync from the popup. Carry pulls your recent conversations — around the last 20 per provider — and writes each one as a Markdown file with frontmatter you can query later:

---
conversation_id: "abc123"
source: claude
title: "Explain CRDTs like I'm five"
created: "2026-06-15T10:23:00.000Z"
updated: "2026-06-15T10:40:00.000Z"
synced: "2026-07-08T10:00:00.000Z"
url: "https://claude.ai/chat/abc123"
---

**Human**

Explain CRDTs like I'm five.

**Assistant**

Imagine two kids drawing on the same whiteboard...

Because it reads the provider’s own history rather than scraping the rendered page, code, tables, and LaTeX come through intact. Because each file is matched by its conversation id, re-syncing overwrites in place — so you can run it as often as you like and never end up with duplicates, even if you’ve renamed the file.

Sync is manual today — you open the popup and run it. Automatic, continuous capture is on the way, but it doesn’t ship yet, so I won’t pretend it does. What ships now is the honest version: a two-minute setup that turns “I meant to save that chat” into a folder of real Markdown files.

The second-brain payoff

Once your conversations are Markdown in your vault, they stop being a transcript you’ll never reopen and start being part of the graph. You can drop [[wikilinks]] into them, tag them, and pull them into a Dataview table next to everything else you know — “all my #research AI chats this month,” a weekly-review list, a per-project hub that auto-lists the conversations that fed it.

And it closes the loop with direction one. The same clean folder that makes a good Dataview citizen is the folder your filesystem or Obsidian MCP server reads — so the conversations you capture today become part of the corpus Claude Code queries tomorrow. Both directions, finally pointing at the same pile of Markdown.

Your vault was always AI-friendly. The point was never to make it smarter. It was to stop leaving half your thinking outside it.

---

Carry is local-only and open-source at its core — no server, no account, and only the providers you connect. It syncs Claude, ChatGPT, and Grok into your own folder as Markdown — see how it works to get started.