Obsidian — Knowledge Management for AI

Vault structure, plugins, three-layer memory architecture, LLM integration, Git

Obsidian is a local-first markdown editor that turns a folder of .md files into a linked knowledge graph. Free for all use cases, including commercial.

Obsidian — Knowledge Management for AI Workflows

Obsidian operates entirely on your local filesystem: plain .md files in a folder, no database, no server, no vendor lock-in. This makes it uniquely suited for LLM memory systems — the same files an AI reads and writes are the ones you browse in the editor.

How Obsidian Works

Property	Details
Storage	Plain `.md` files in a folder
Database	None — the filesystem IS the database
Server	None required — works 100% offline
Vendor lock-in	Zero — any text editor reads your notes
Platforms	Windows, macOS, Linux, iOS, Android
License	Free (personal and commercial)

The Vault Concept

An Obsidian vault is simply a directory on disk. Obsidian creates a .obsidian/ subdirectory for settings and indexes all markdown files.

my-vault/
├── .obsidian/           # Settings, plugins, themes
├── Daily/               # Daily notes
├── Projects/            # Active project context
├── Knowledge/           # Distilled reference material
└── Templates/           # Note templates

On vault open, Obsidian: scans all .md files, parses YAML frontmatter, indexes all [[wiki-links]] to build the link graph, caches the index for fast search, and watches the filesystem for external changes.

Core Features

Feature	What It Does
Graph View	Interactive visual map of notes and link connections
Backlinks	Every note that links TO the current note
Search	Full-text with regex, tag, path, property filters
Tags	`#tag` inline or frontmatter; hierarchical: `#project/scraper`
Canvas	Visual board for arranging notes spatially
Bases	Native database views over your notes (2025)
Daily Notes	One note per day, auto-created from template
Properties	Visual editor for YAML frontmatter fields

The Linking System

[[Note Name]]                     # Link to a note
[[Note Name#Heading]]             # Deep link to heading
[[Note Name|Display Text]]        # Custom display text
![[Note Name]]                    # Embed (transclusion)
![[image.png]]                    # Embed image

When note A links to note B, Obsidian automatically creates a backlink in note B. This builds a knowledge graph where you navigate in any direction.

Essential Plugins

Plugin	What It Does
Dataview	SQL-like queries over frontmatter and content
Templater	Advanced templates with JavaScript and dynamic dates
obsidian-git	Auto-commit and push to Git on interval
Calendar	Visual calendar linked to daily notes
Tasks	Track tasks across all notes with due dates

AI-Focused Plugins

Plugin	What It Does
Smart Connections	AI-powered similar note discovery via vector embeddings
Copilot	Chat with LLM inside Obsidian using vault as RAG context
Khoj	Self-hosted AI assistant with full vault indexing
AI LLM	Integrates Ollama and local models for text expansion

Vault Structure for AI Workflows

vault/
├── 00-Inbox/               # Raw captures, unsorted
├── 01-Projects/            # Active project context
│   └── project/_MOC.md     # Map of Content (index)
├── 02-Knowledge/           # Distilled, reusable knowledge
├── 03-Runbooks/            # Step-by-step procedures
├── 04-People/              # Contact/team context
├── 05-Context/             # LLM-specific context files
│   ├── PERSONA.md          # Your preferences and stack
│   ├── CONVENTIONS.md      # Coding conventions
│   └── STACK.md            # Current tech stack
├── Daily/                  # Daily notes
├── Templates/              # Note templates
└── _Index.md               # Master Map of Content

Obsidian as LLM Memory

This is the highest-value use case. Obsidian becomes the persistent memory layer for LLM interactions.

The Three-Layer Memory Architecture

Layer 1: Episodic Memory — What Happened

Daily notes, meeting logs, session handoffs. Temporal, sequential, specific. The LLM reads these when resuming work.

Layer 2: Semantic Memory — What You Know

Distilled understanding — facts, patterns, how things work. Evergreen notes that improve over time. The LLM reads these when solving problems.

Layer 3: Procedural Memory — How to Do Things

Runbooks and step-by-step procedures the LLM can follow directly.

Feeding Your Vault to an LLM

The simplest approach for tools with file access (Claude Code, Cursor, Aider):

## Memory System (add to CLAUDE.md)
- At session start, read 05-Context/PERSONA.md
- Before working on any project, read its _MOC.md first
- After significant work, write a session-handoff note
- When learning something reusable, create a note in 02-Knowledge/

For large vaults (500+ notes), use Retrieval-Augmented Generation:

Vault (.md files)
  → embed with text-embedding-3-small
Vector Database (ChromaDB, Qdrant, Pinecone)
  → similarity search (top-K relevant chunks)
LLM generates answer with vault context

Plugins: Smart Connections (local), Copilot (OpenAI/Anthropic), Khoj (self-hosted).

Connect Claude Desktop or Claude Code to your vault via MCP:

Install Local REST API plugin in Obsidian
Configure MCP server in Claude config
The AI can search, read, create, and update notes autonomously

Available tools: list_files_in_vault, get_file_contents, search_vault, create_file, append_content

Git Version Control

Setup with obsidian-git plugin

Install: Settings > Community Plugins > Browse > "Obsidian Git" > Install > Enable

Setting	Recommended Value
Auto backup interval	15 minutes
Auto pull on open	Enabled
Commit message format	`vault backup: {{date}}`
Push on backup	Enabled

.gitignore (critical):

.obsidian/workspace.json
.obsidian/workspace-mobile.json
.obsidian/cache/
.DS_Store
Thumbs.db

Writing Notes for Machines

Best Practices for LLM-Readable Notes

Structured over narrative:

---
type: learning
domain: scraping
confidence: verified
date: 2026-02-24
---
## JWT Token Expiration
- Expiry: ~2 hours from issuance
- Detection: HTTP 401 during scraping
- Mitigation: Call is_token_valid() before each batch

One idea per note (atomic notes) — the LLM retrieves precisely what it needs.

Consistent frontmatter schema:

title: string          # Human-readable title
type: enum             # learning | decision | runbook | reference | daily
domain: string[]       # Topic areas
status: enum           # seed | growing | evergreen
confidence: enum       # hypothesis | tested | verified

Obsidian vs. Alternatives

Criteria	Obsidian	Notion	Logseq
Local-first	Yes	No	Yes
Plain files	Yes (markdown)	No (proprietary)	Yes
LLM integration	Excellent (file + MCP)	API only	Good
Git-friendly	Excellent	No	Good
Plugin ecosystem	2,700+	Integrations	200+
Free tier	Full features	Limited	Full features

If you need…	Choose
LLM memory system	Obsidian
Team wiki / database	Notion
Daily journaling / outliner	Logseq
Simplest setup	Obsidian
Privacy-first AI	Obsidian

n8n — Workflow Automation Overview Web Scraping for AI & LLMs