Obsidian AI Vault Setup Guide (2026)

Updated January 2026 | 9 min read

Claude Code reads markdown files. Obsidian organizes markdown files. Put them together and you get AI that remembers everything you've ever told it.

This is the infrastructure guide. By the end, you'll have a vault that routes AI to the right context every time you ask it to do something.

Why Obsidian for AI Context

Every time you start a new Claude chat, it forgets who you are. You re-explain your business, your clients, your preferences. Every. Single. Time.

Obsidian fixes this three ways:

Local files. Your context stays on your machine. No upload limits. No token counts. No wondering what the AI company does with your business data.

Plain text. Markdown is human-readable and AI-readable. Write once, works forever. No proprietary formats. No platform lock-in.

Links everywhere. Obsidian's linking system lets you build a web of context. Client file links to project file links to template file. AI follows the chain.

Claude Code can read your entire vault. When you tell it to write client emails, it reads the client folder. When you ask about a project, it pulls the project file. No copy-paste. No context windows. Just memory that works.

Vault Architecture: The Three Layers

Your vault needs three layers. Each one serves a different purpose.

Layer 1: Root CLAUDE.md

This file sits at the root of your vault. It's the master instruction set. Every Claude session reads this first.

What goes in it:

• Who you are (name, roles, schedule)
• What domains you work in (business areas, clients, projects)
• How to route requests (keywords that trigger specific context files)
• Voice and output rules (how AI should write for you)
• Critical warnings (things AI should never do)

This file answers: "Who am I talking to and what are they trying to do?"

Layer 2: Domain Folders

Each major area of your work gets a folder. If you're a consultant with three clients, that's three folders. If you run a business with sales, operations, and content, that's three folders.

Name them with prefixes so they sort right:

01 - Client Work/
02 - Business Operations/
03 - Content Production/
04 - Personal/

Each folder gets a _context.md file. This is the domain-specific instruction set. It tells AI what's different about this area of work.

Layer 3: Project Files

Inside each domain folder, you have individual files for clients, projects, templates, logs.

These hold the actual work product: client details, project specs, past decisions, style guides, data.

The vault routes like this: Root CLAUDE.md → Domain context → Project files.

Step-by-Step Setup

Step 1: Create the Root CLAUDE.md

Open Obsidian. Create a new file at the root level called CLAUDE.md.

Start with this structure:

# [Your Name]'s Vault

## WHO
[Your name, roles, schedule]

## WHAT (Domains)
| Domain | Context File | Load when prompt mentions... |
|--------|--------------|------------------------------|
| [Domain Name] | [path to _context.md] | [keywords] |

## VOICE
[How you want AI to write]

## RULES
1. Read before edit
2. Ask if unclear
3. [Your specific rules]

## KEY FILES
[Important files AI should know about]

This gives AI the map. It reads this file first, figures out what you're asking for, then routes to the right domain.

Step 2: Build Your Domain Structure

Create folders for each major work area. Keep it simple. Three to five folders is plenty for most people.

Inside each folder, create _context.md. The underscore makes it sort to the top.

Your structure looks like this:

/CLAUDE.md
/01 - Client Work/
  /_context.md
  /ClientA.md
  /ClientB.md
/02 - Content/
  /_context.md
  /Style-Guide.md
  /Templates.md
/03 - Personal/
  /_context.md
  /Tasks.md

Step 3: Write Domain Context Files

Each _context.md file answers: "What's different about working in this domain?"

For a client work folder:

# Client Work Context

## Current Clients
- ClientA: [one-line description]
- ClientB: [one-line description]

## Deliverables
[What you produce for clients]

## Process
[Your workflow steps]

## Templates
[Links to template files]

## Active Projects
[What's in progress right now]

For a content production folder:

# Content Context

## Voice Rules
[How you write]

## Platforms
[Where you publish]

## Topics
[What you write about]

## Templates
[Article structures, post formats]

## Publication Schedule
[When things go out]

Keep these files under 500 words. If it's longer, split it into separate files and link to them.

Step 4: Set Up Naming Conventions

Consistent names help AI find things fast. Pick a convention and stick to it.

For people: FirstLast.md or Company - Contact.md

For projects: YYYY-MM-DD - Project Name.md or ClientName - Project.md

For templates: TEMPLATE - Use Case.md

For logs: _log.md (underscore keeps it at folder top)

Date-based naming is best for time-sensitive work. It sorts chronologically and makes finding recent stuff easy.

Step 5: Build Your Linking Strategy

Obsidian's real power is links. When AI reads one file, it can follow links to related files.

Link types that matter:

Upward links: Project files link back to client files. Client files link to domain context. This lets AI trace backward to find broader context.

Related links: Client A links to Client B if they're in the same industry. Template links to examples. This helps AI find relevant precedents.

Template links: Context files link to templates. When you ask AI to create something, it knows where to find the format.

Use [[wiki-style]] links. They're fast to type and Obsidian auto-completes them.

Add a "Related" section at the bottom of important files:

## Related
- [[Client Context]]
- [[Project Template]]
- [[Past Work Examples]]

Step 6: Create Your Routing Table

Back in your root CLAUDE.md, build the routing table. This tells AI which keywords trigger which context files.

## WHAT (Domains)

| Domain | Context File | Load when prompt mentions... |
|--------|--------------|------------------------------|
| **Client Work** | `01 - Client Work/_context.md` | client, project, deliverable, ClientA, ClientB |
| **Content** | `02 - Content/_context.md` | article, post, write, publish, blog |
| **Personal** | `03 - Personal/_context.md` | task, reminder, schedule, personal |

When you tell Claude "write the ClientA report," it sees "ClientA" and loads the Client Work context automatically.

Step 7: Add Voice and Rules

The VOICE section tells AI how to write for you. The RULES section tells it what never to do.

Voice example:

## VOICE

Write direct. Use contractions. Short sentences when they hit harder. Longer ones when the idea needs room to breathe.

No corporate speak. No buzzwords. No "solutions" or "leverage" or "synergy."

If it sounds like a press release, rewrite it.

Rules example:

## RULES

1. Read files before editing them
2. Ask before deleting anything
3. Use YYYY-MM-DD date format
4. Keep responses dense, no fluff
5. Never move files without confirmation (breaks Obsidian sync)

These override AI's defaults. Claude wants to be helpful and verbose. Your rules tell it to be useful and brief instead.

What You Get

With this vault setup, Claude remembers:

• Who your clients are and what they need
• How you write and what you sound like
• What projects are active and what's happened before
• Where templates live and when to use them
• What rules you follow and what mistakes to avoid

You type: "draft the weekly ClientA update."

Claude reads your CLAUDE.md, sees "ClientA," loads the Client Work context, finds the ClientA file, checks the template, and writes the update in your voice with the right details.

No copy-paste. No re-explaining. Just work that's actually useful.

Maintenance Loop

Vaults need upkeep. Not much, but some.

Weekly: Update active project statuses in context files. Mark what's done, what's in progress, what's next.

Monthly: Archive finished projects. Move completed client work to an Archive folder. Keep active context clean.

Quarterly: Review your routing table. Add new keywords as your work changes. Remove domains you're not using anymore.

The vault grows with you. It's not a one-time setup. It's a living system that gets smarter the more you use it.

Common Mistakes

Too many folders. Start with three to five domains. You can always split later. Too much structure up front makes everything harder to find.

No routing table. If you don't tell AI what keywords trigger what context, it guesses. Guessing wastes time.

Putting everything in CLAUDE.md. That file should be under 1,000 words. If it's longer, you're doing it wrong. Context files hold the details.

Forgetting to link. Isolated files are invisible. Link everything to something. If AI can't find it, it doesn't exist.

Writing for AI instead of humans. Your vault is for you. Write notes the way you think. AI is good at parsing human writing. It's bad at making sense of rigid formats designed "for the algorithm."

Next Steps

You've got the infrastructure. Now fill it with context:

• Write your root CLAUDE.md (30 minutes)
• Create domain folders and context files (1 hour)
• Move existing files into the structure (1 hour)
• Add links between related files (30 minutes)
• Test it: ask Claude to do something and see if it finds the right context

The vault works when Claude reads the right files without you telling it which ones to read.