Obsidian AI Integration: Your Notes as Persistent Context

Updated January 2026 | 8 min read

Obsidian is a note-taking app. Except it's not.

It's a file browser that renders markdown. That distinction matters because it changes what's possible with AI integration.

Every note you write in Obsidian is a plain .md file stored on your computer. No database. No proprietary format. No cloud dependency.

Claude Code reads local files.

That's the entire integration. Your notes become AI context. Every conversation starts with your knowledge loaded. No uploads, no API calls, no temporary chat memory.

Why Most Note Apps Can't Integrate with AI

Notion stores your notes in a database. To give AI access, you'd need to build an API integration, authenticate, query the database, parse the results, then feed them to chat. It's possible. It's also fragile, slow, and breaks when Notion updates their API.

Evernote locks notes in a proprietary format. Export to HTML or text, lose formatting and structure. AI can't parse it cleanly.

Apple Notes syncs to iCloud. No local file access without reverse-engineering their sync protocol.

Obsidian stores notes as plain text files in a folder on your computer. Claude Code reads that folder. Done.

No API. No authentication. No parsing. Just file access.

The Architecture: Vault to Context to Output

Here's how Obsidian AI integration works at the system level:

1. You create an Obsidian vault (a folder with markdown files)
2. You write a CLAUDE.md file in the vault root (master instructions for AI)
3. You start a Claude Code conversation (CLI or IDE)
4. Claude Code loads CLAUDE.md automatically (session start hook)
5. You mention a keyword in your prompt ("Cryo," "Valley," "project")
6. Claude checks the routing table in CLAUDE.md (keyword → file path mapping)
7. Claude loads the matching context file (domain-specific notes)
8. Claude generates output using both files (master context + domain context)

The vault is your source of truth. The CLAUDE.md file is the router. The context files are modular memory.

Change a note, Claude sees it next conversation. Add a note, update the routing table, Claude loads it when relevant. Delete a note, Claude stops loading it.

Your notes aren't static documentation. They're live context.

Building the Obsidian Vault Structure

Most people organize Obsidian vaults for human navigation. Folders by topic, tags by theme, wiki-style links between notes.

AI integration requires organizing for machine reading.

Basic structure:

/YourVault/
  CLAUDE.md (master instructions, routing table)
  /Clients/
    _context.md (client-specific info)
    CryoBodyWorks.md
    LimitlessChiro.md
    ValleyWelding.md
  /Projects/
    _context.md (project details)
    WebsiteRedesign.md
    ContentCalendar.md
  /Systems/
    _context.md (workflows and processes)
    EmailTemplates.md
    ProposalFramework.md

The underscore prefix on _context.md files signals "this is for AI, not human browsing."

Why group by domain (Clients, Projects, Systems) instead of by date or topic? Because your prompts use domain language.

You say "help me with Cryo" not "help me with client #3."

You say "check the website project" not "check project started 2026-01-15."

Organize by how you speak. The routing table maps natural language to file paths.

Writing the CLAUDE.md Master File

This is the core of Obsidian AI integration. It tells Claude:

• Who you are
• What you do
• How to communicate
• Where to find more context

Start with identity:

## WHO
Victor Romo. Two jobs:
1. JAG — Inside Sales Database Manager at Jim Allen Group (real estate, Raleigh NC)
2. SWS — Scale With Search founder (SEO education, four retainer clients)

Schedule: 5am leave, 6:30-8am gym, 8am-5pm office, 7pm home (Winston-Salem)

Be specific. Time zones matter. Job titles matter. Commute times matter because they affect availability.

Add domain mapping:

## WHAT (Domains)

| Domain | Context File | Load when prompt mentions... |
|--------|--------------|------------------------------|
| JAG | /JAG/_context.md | lead, database, CRM, Follow Up Boss, agent |
| SWS | /SWS/_context.md | client, SEO, content, Cryo, Limitless, Valley |
| Projects | /Projects/_context.md | website, design, build, code |

This is the routing table. When you type "help me clean up the database," Claude sees "database," matches it to JAG, loads /JAG/_context.md.

When you type "write a blog post for Cryo," Claude sees "Cryo," matches it to SWS, loads /SWS/_context.md and /Clients/CryoBodyWorks.md.

Multiple files can load per prompt. The routing table is cumulative, not exclusive.

Domain Context Files: What Goes In Them

Each domain folder should have a _context.md file. This file contains information specific to that domain.

For a client folder:

## Client: Cryo Body Works
Business: Cryotherapy and recovery services
Location: Raleigh, NC
Owner: [Name]
Services: Whole-body cryotherapy, infrared sauna, NormaTec compression

Voice: Professional but approachable. Health-focused without medical claims. Emphasize recovery and wellness.

Keywords: recovery, inflammation, athletic performance, pain management, wellness

Competitors: [Local cryo centers]

Content deliverables: 2 articles/month, 1 topical map/quarter

Pain points: Misconceptions about cryotherapy safety, price sensitivity, need for education-first content

For a project folder:

## Project: Valley Welding Website Redesign
Client: Valley Welding Supply
Deadline: 2026-02-15
Status: In progress (design approved, awaiting content)

Tech stack: Static HTML, CSS, vanilla JavaScript
Hosting: Netlify
Domain: valleywelding.com

Brand colors: #1a1a1a (dark gray), #ff6b00 (orange accent)
Fonts: Inter (body), Space Grotesk (headings)

Pages: Home, Services, About, Contact, Safety Resources

Key requirement: Mobile-first, fast load times, no frameworks

Don't write these files like documentation. Write them like briefing a team member.

"We need mobile-first design" not "The client has expressed a preference for responsive layouts that prioritize mobile user experience."

AI doesn't need business-speak. It needs facts.

Testing Your Obsidian AI Integration

Open Claude Code. Start a new conversation. Type: "What clients do I work with?"

If Claude lists your clients by name with details, the integration works.

If Claude says "I don't have that information," check three things:

1. Is CLAUDE.md in the vault root? (Not in a subfolder)
2. Does the routing table use correct file paths? (Case-sensitive, relative to vault root)
3. Are context files using proper markdown formatting? (Headers with ##, lists with -, tables with |)

Test routing with a keyword prompt: "Help me with Cryo."

Claude should respond with Cryo-specific information. If it asks "Who's Cryo?" the routing table isn't working. Check keyword matches and file paths.

Advanced: Using Obsidian Features for AI Context

Obsidian has wiki-style linking. You can reference one note from another using [[Note Name]] syntax.

This doesn't automatically help AI. Claude Code reads files independently. It doesn't follow internal links unless you tell it to.

But you can use links as context hints.

In your Cryo context file:

Related notes: [[EmailTemplates]], [[ContentBriefFramework]]

When Claude sees this, it knows those notes exist. If you later say "use my standard email template," Claude knows to look for EmailTemplates.md.

Obsidian's tag system works similarly. Add tags to context files:

Tags: #client #active #chiropractic

Claude can search for tags if you ask: "Show me all active clients." It'll grep the vault for #active and return matching files.

Obsidian's dataview plugin doesn't help AI directly (it's a UI tool), but the metadata you add for dataview (frontmatter fields) does.

---
client: Cryo Body Works
status: active
retainer: monthly
rate: $2000
---

Claude reads frontmatter. You can ask "What's my monthly retainer with Cryo?" and it'll parse the rate field.

What This Makes Possible

Client-aware content generation. Ask for a blog post and Claude writes in the client's voice, uses their keywords, matches their brand tone. No briefing required.

Project-specific code. Request a feature and Claude generates code using your actual tech stack. Not generic React examples. Your HTML/CSS/JavaScript setup.

Context-aware communication. Draft an email and Claude includes real project names, accurate deadlines, correct pricing. Because it reads your project files.

Cross-domain synthesis. Ask "What's my workload this week?" and Claude combines JAG tasks, SWS deliverables, and personal projects. Because all domains load from the same vault.

Memory across sessions. Start a project Monday. Resume Thursday. Claude remembers context because the file didn't change. No "remind me what we were working on."

Maintenance: Real vs. Imagined Work

You're probably thinking: "This sounds like a lot of upkeep."

It's not.

Most people spend 5-10 minutes per week updating context files. That's less time than re-explaining yourself in ChatGPT daily.

When do you update files?

• New client → Add a client note, update routing table (2 minutes)
• Completed project → Archive the project note (30 seconds)
• Changed pricing → Update service context file (1 minute)
• New workflow → Document in systems folder (5 minutes)

Updates happen when reality changes. Not daily. Not even weekly for most people.

The system maintains itself because it's file-based. Change the file, Claude sees it next conversation. No syncing, no deployment, no cache clearing.

Why This Beats ChatGPT Plugins

ChatGPT has an Obsidian plugin. It can read your vault via API.

Here's the problem: API access requires authentication, query limits, network latency, and rate limiting. Your notes live in one app, ChatGPT queries them from another app, results get passed back, then fed into conversation context.

That's not integration. That's a bridge.

Claude Code reads local files directly. No API. No network. No rate limits. Your notes and your AI exist in the same filesystem.

It's the difference between video calling someone vs. being in the same room.