← Blog/Integration

Semantic Memory for
Your Obsidian Vault

Name: OMEGA
Author: OMEGA

March 14, 2026|OMEGA team|6 min read

Obsidian vaults are where developers keep architecture decisions, meeting notes, research, and project context. But when you work with an AI coding agent, that knowledge sits in a separate silo. The agent cannot search your vault by meaning, traverse your wikilink graph, or remember what it found last session.

Existing Obsidian MCP servers solve the file-reading part. They let agents open notes and search by filename. But they re-read the entire vault on every startup, they match keywords instead of meaning, and they cannot write back.

omega-obsidian is different. It indexes your vault once into a persistent SQLite database with semantic embeddings, then serves searches instantly on every subsequent startup. It traverses wikilinks and tags as a knowledge graph. And it writes agent-generated memories back into your vault as real Obsidian-compatible markdown files.

What File-Based MCP Servers Miss

Most Obsidian MCP servers work like a file browser with extra steps. They walk the vault directory, read files on demand, and match against filenames or raw text. This works for retrieving a specific note you already know about.

It breaks down when you need to find notes by concept. Searching for "authentication flow" will not find a note titled "Login System Design" unless those exact words appear in the content. There is no semantic understanding.

It also breaks down at scale. A vault with 2,000 notes takes seconds to walk on every startup. omega-obsidian indexes once, persists the index to SQLite, and only re-indexes files that changed. Startup after the first run is instant.

Feature	File-based servers	omega-obsidian
Semantic search	No	Yes
Persistent index	No	Yes
Incremental updates	No	Yes
Write-back to vault	No	Yes
Knowledge graph	No	Yes
Read notes	Yes	Yes

One Line to Install

terminal

$ pip install omega-obsidian

For higher-quality embeddings, install with the OMEGA engine:

terminal

$ pip install omega-obsidian[omega]

The base install uses a built-in TF-IDF embedder that requires no extra dependencies. The [omega] variant uses bge-small-en-v1.5 via ONNX for 384-dimensional embeddings with much better semantic understanding. Both run entirely locally.

MCP Configuration

Add omega-obsidian to your coding agent. Point it at your Obsidian vault path:

Claude Code

$ claude mcp add omega-obsidian -- omega-obsidian --vault-path /path/to/vault

.cursor/mcp.json

{
  "mcpServers": {
    "omega-obsidian": {
      "command": "omega-obsidian",
      "args": ["--vault-path", "/path/to/your/obsidian/vault"]
    }
  }
}

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "omega-obsidian": {
      "command": "omega-obsidian",
      "args": ["--vault-path", "/path/to/your/obsidian/vault"]
    }
  }
}

Six Tools for Vault Memory

vault_search

Semantic search across all indexed notes. Finds notes by meaning, not just keywords. Returns ranked matches with relevance scores and content snippets.

vault_read

Read a specific note by vault-relative path. Returns full content with parsed frontmatter, extracted tags, and wikilinks.

vault_remember

Store a new memory into your vault from agent context. Creates an Obsidian-compatible markdown file with frontmatter and indexes it immediately.

vault_graph

Traverse your knowledge graph. Get notes related to a given note via backlinks, wikilinks, and shared tags.

vault_index

Force a full reindex of the vault. Run this after making bulk changes to the vault outside the agent.

vault_recent

Get recently modified notes sorted by modification time. Useful for picking up where you left off.

How It Works

On first startup, omega-obsidian walks your vault and parses every .md file. It extracts YAML frontmatter, wikilinks ([[note]]), and tags (#tag), generates a semantic embedding for each note, and stores everything in a SQLite database at ~/.omega-obsidian/index.db.

On subsequent startups, it checks modification times and content hashes. Only new or changed files get re-indexed. A vault with 2,000 notes that had 3 edits since last run will re-index just those 3 files.

Search works by embedding the query with the same model and computing cosine similarity against all note embeddings. This is why "authentication flow" finds "Login System Design": the embeddings capture semantic proximity that keyword matching cannot.

The knowledge graph uses wikilinks and tags as edges. When you call vault_graph on a note, it returns all notes linked by wikilinks (bidirectional) and notes sharing tags, giving your agent a way to explore context beyond a single note.

Bonus: Export OMEGA Memories to Obsidian

If you already use OMEGA for agent memory, you can export your entire memory database as Obsidian-compatible markdown files. Each memory becomes a note with YAML frontmatter and [[wikilinks]] for graph edges:

terminal

$ omega export-obsidian --output-dir ./my-vault/omega-memories

# Filter by project:
$ omega export-obsidian --output-dir ./vault --project my-project

Memories are organized by type into subdirectories: decisions/, lessons/, errors/, checkpoints/, and more. An _index.md summary is generated with counts per type. Open the output directory in Obsidian and you get a fully linked knowledge graph of everything your agents have learned.

Your vault should be searchable by meaning.

One package. Six tools. Persistent semantic memory for your Obsidian vault.

pip install omega-obsidian