io.github.aliasunder/vault-cortex

Official

by aliasunder · TypeScript

Vault Cortex

Standalone MCP server for Obsidian vaults — hybrid search, memory, tasks, 26 tools, OAuth 2.1.

Obsidian vault integration with hybrid search, task management, and 26 integrated tools.

obsidianvaultknowledge managementsearchnotestaskshybrid search

Topics

dockermcpobsidianobsidian-vaultobsidian-mcp-serverobsidian-syncknowledge-basemodel-context-protocoloauth2self-hostedai-memory-systemmcp-serverai-agentshybrid-searchsemantic-searchsqlite-vecvector-searchcross-encoderrerankingtask-management

README.md28 KBView on GitHub

</div>

Vault Cortex is a standalone MCP server that gives any AI agent hybrid search, structured memory, and read/write access to your Obsidian vault. No plugins, no running Obsidian, no separate bridge. One Docker container, your vault folder, 25 tools + 3 guided prompts. Deploy on a VPS with Obsidian Sync and the same vault is accessible from your phone, claude.ai, or any remote MCP client, secured with OAuth 2.1.

Contents — What you get · Quick Start · How It Works · Hybrid Search · Tools · Prompts · Config · Auth · Deployment

What you get

<table align="center"> <tr> <td align="center"><strong>Search the vault</strong></td> <td align="center"><strong>Reason over notes</strong></td> <td align="center"><strong>Write back to Obsidian</strong></td> </tr> <tr> <td><img src="./assets/demo-remember.gif" width="240" alt="Ask Claude about a past trip — it searches the vault and recalls the route, cities, and highlights"></td> <td><img src="./assets/demo-reason.gif" width="240" alt="Ask what went wrong — Claude synthesizes lessons from session logs and itinerary notes"></td> <td><img src="./assets/demo-writeback.gif" width="240" alt="Save lessons learned to the vault, update travel preferences, then see both in Obsidian"></td> </tr> </table> <p align="center"><em>All three demos run on Claude mobile. The vault is on a remote server, not the phone.</em></p>

Remote access — works from your phone, a remote server, or any MCP client via OAuth 2.1. Deploy on a VPS with Obsidian Sync for access from anywhere.
Plugin-free — Obsidian doesn't need to be running. The server works directly with .md files on disk. Headless sync keeps the vault current.
Hybrid search — FTS5 keyword matching + vector semantic similarity via RRF fusion, refined by cross-encoder reranking for intent-heavy queries. Keywords stay precise on exact terms and jargon; vectors find notes even when your words differ from the vault's.
Structured memory — dated entries, section targeting, auto-initialization for AI personalization
Link graph — backlinks, outgoing links, and orphan detection across the vault
Obsidian-native — understands frontmatter, wikilinks, tags, headings, and daily notes
Guided workflows — three built-in prompts for vault health, memory review, and daily reconciliation — assembled from live vault data each time

Tested across a 15-day trip through Europe. 30+ sessions from a phone, 216 tool calls, zero laptop access needed. Writes in one session were immediately available in the next, across cities and days.

Quick Start

Local (2 minutes — Docker + your vault folder)

Prerequisites: Docker, Node.js >= 20.12 (only for the CLI — the server itself runs in Docker), and an Obsidian vault (or any folder of .md files).

bash

npx vault-cortex@latest init

That's it — the CLI asks for your vault path, generates the auth token and config files, starts the server, and prints the connection details for your MCP client.

<details> <summary><strong>Manual setup</strong> (no Node.js needed)</summary>

bash

# 1. Get the quickstart files
curl -O https://raw.githubusercontent.com/aliasunder/vault-cortex/main/deploy/local/docker-compose.yml
curl -O https://raw.githubusercontent.com/aliasunder/vault-cortex/main/deploy/local/.env.example

# 2. Configure
cp .env.example .env
# Edit .env — set MCP_AUTH_TOKEN (openssl rand -hex 32) and VAULT_PATH

# 3. Start
docker compose up

</details>

Full local guide → (includes Windows setup)

Remote (access from anywhere — Docker + Obsidian Sync)

Prerequisites: a VPS with Docker, an Obsidian Sync subscription, and Node.js >= 20.12 (only for the CLI — the server itself runs in Docker).

bash

# On your VPS:
npx vault-cortex@latest init --mode remote

That's it — the CLI walks through the public URL, Obsidian Sync token (it can run the token generator for you), and auth config, then starts the server.

<details> <summary><strong>Manual setup</strong> (no Node.js needed)</summary>

bash

# On your VPS:
mkdir -p /opt/vault-cortex && cd /opt/vault-cortex
curl -O https://raw.githubusercontent.com/aliasunder/vault-cortex/main/deploy/remote/docker-compose.yml
curl -O https://raw.githubusercontent.com/aliasunder/vault-cortex/main/deploy/remote/.env.example
cp .env.example .env
# Edit .env — set MCP_AUTH_TOKEN, PUBLIC_URL, OBSIDIAN_AUTH_TOKEN, VAULT_NAME
docker compose up -d

</details>

Full remote guide →

Connect your MCP client

Setup	Server URL
Local	`http://localhost:8000/mcp`
Remote	`<PUBLIC_URL>/mcp`

Add the server URL in any MCP client — Claude Code, Claude Desktop, Cursor, OpenCode, or any other. OAuth clients open a consent page in your browser — approve with your token, and the client handles token renewal from then on. Clients without OAuth (MCP Inspector, scripts) send the token directly as an Authorization: Bearer header.

Claude Code:

bash

claude mcp add --scope user --transport http vault-cortex http://localhost:8000/mcp   # local (or <PUBLIC_URL>/mcp)

--scope user registers the server for every project; omit it to scope it to the current directory only.

<details> <summary><strong>Claude Desktop</strong> (localhost requires mcp-remote bridge)</summary>

The "Add custom connector" dialog only accepts https URLs. With an https PUBLIC_URL, add it directly in the connector dialog; for a localhost server, register it in claude_desktop_config.json through the mcp-remote stdio bridge instead:

json

{
  "mcpServers": {
    "vault-cortex": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "http://localhost:8000/mcp",
        "--header",
        "Authorization: Bearer <your MCP_AUTH_TOKEN>"
      ]
    }
  }
}

</details>

claude.ai (web and mobile) connects to the remote setup only — its connectors are fetched server-side and can never reach localhost.

"Remote MCP server" refers to the connection type (HTTP) — in the local setup the server still runs entirely on your machine.

See Authentication for both methods and token lifetimes.

How It Works

mermaid

graph LR
    Client["MCP Client"] -->|OAuth 2.1 / Bearer| Server["vault-mcp"]
    Server -->|read/write| Vault[("/vault<br/>.md files")]
    Server -->|FTS5 + vector| SQLite[("SQLite\nFTS5 + sqlite-vec")]
    Sync["obsidian-sync"] <-->|Obsidian Sync| Vault

The search index is rebuildable derived state — FTS5 keyword tables rebuild on startup, vector embeddings persist across restarts with content-hash gating (only changed notes re-embed). A file watcher keeps both current, and queries fuse both signals via Reciprocal Rank Fusion. obsidian-sync keeps the vault in sync with your Obsidian apps (remote deployments only).

See ARCHITECTURE.md for the full design, auth flow diagrams, and component breakdown.

Hybrid Search

Keyword search alone fails when your vocabulary doesn't match the vault's — "aspirations" won't find a note about "targets", "coworkers" won't surface your "references" file. In testing against a real vault, 30% of natural-language queries returned zero or tangential results with keywords alone. Hybrid search eliminated those misses — vectors bridge the vocabulary gap, and the reranker rescues intent-heavy queries where neither signal is strong on its own.

Hybrid search combines three ranking signals via Reciprocal Rank Fusion:

Keywords (FTS5) stay precise on exact terms, jargon, and property values
Vectors (sqlite-vec) bridge the vocabulary gap by matching on meaning
Reranker (cross-encoder) refines ordering by scoring each query-document pair jointly — rescues intent-heavy queries where keywords and vectors both miss

All models run locally (~45MB total, no external API). Set EMBEDDING_ENABLED=false for keyword-only search, or RERANK_MODE=none to skip reranking for lower latency.

See ARCHITECTURE.md → Hybrid Search for model details, blend weights, and the full pipeline breakdown.

Tools (25)

Category	Tool	Description
Vault CRUD	`vault_read_note`	Read a note — full body, properties, outline, or a section
	`vault_write_note`	Create or overwrite a note with properties
	`vault_patch_note`	Heading-targeted edit (append, prepend, replace, insert)
	`vault_replace_in_note`	Find-and-replace text in a note
	`vault_delete_span`	Delete a block of lines by short anchors, no full re-quote
	`vault_list_notes`	List notes with optional glob/folder filter
	`vault_delete_note`	Delete a note (protected paths enforced)
	`vault_move_note`	Move or rename a note, rewriting links across the vault
Search	`vault_search`	Hybrid search with tag/folder/property filters
	`vault_search_by_tag`	Find notes by tag (exact or prefix match)
	`vault_search_by_folder`	Browse notes in a folder with metadata
	`vault_recent_notes`	Recently modified or created notes
	`vault_list_tags`	All tags with usage counts
Memory	`vault_get_memory`	Read structured memory (file, section, or all)
	`vault_update_memory`	Append a dated entry to a memory section
	`vault_delete_memory`	Remove a specific memory entry by date
	`vault_list_memory_files`	Discover memory files and their sections
Properties	`vault_list_property_keys`	All property keys with sample values
	`vault_list_property_values`	Distinct values for a property key
	`vault_search_by_property`	Find notes by property key-value
	`vault_update_properties`	Add or update properties without touching the body
Links	`vault_get_backlinks`	Notes linking to a given path
	`vault_get_outgoing_links`	Links from a given note
	`vault_find_orphans`	Notes with no incoming links
Daily Notes	`vault_get_daily_note`	Today's (or any date's) daily note

Prompts (3)

Tools are model-driven — the assistant calls them. Prompts are workflows you trigger. Each one queries the search index, link graph, and memory layer at invocation time, then assembles the results with guided instructions — so the session starts grounded in your vault's actual state, not assumptions.

Prompt	Arguments	What it does
`vault-orientation`	—	Surveys vault stats, folder distribution, property adoption rates (flags low adoption), orphans, broken link count, tags, recent notes, and the memory layer — with contextual tool suggestions
`memory-review`	`file?`, `max_chars?`	Structural overview (scope callouts, section entry counts) + dated content as a timeline. Guided reflection: evolution narrative, scope-fit, backfill gaps, and coverage analysis. Hidden when `MEMORY_ENABLED=false`.
`daily-review`	`date?`, `max_chars?`	Reviews a day's daily note with outgoing links (broken-link detection), backlinks, and date-specific activity — guides reconciliation, link following, and pattern recognition

Prompts adapt to your configuration (MEMORY_DIR, daily-notes settings) and work for any vault out of the box. Pass max_chars to cap embedded content if your client has payload limits.

Client support: Prompts work in Claude Desktop (Chat and Cowork — via the + menu under your connector), Claude Code (slash commands), and OpenCode. Support in other clients (Cursor, Windsurf) varies — see the MCP clients matrix for the latest.

Properties

Vault Cortex indexes every property in your notes, but five get promoted treatment — dedicated columns for fast filtering, and top-level fields in every search and discovery result:

Property	What you can do
`title`	Display name in search results; falls back to the filename when missing
`tags`	Search and filter by tag, including parent-child hierarchies (`project` matches `project/vault-cortex`)
`type`	Filter by note type — `meeting`, `person`, `session-log`, or any value your vault uses
`created`	Sort by creation date and see when each note was created alongside every search result
`related`	Filter for notes that cross-reference a specific link — surfaces connections invisible without a graph query

All other properties are still fully queryable — use vault_search with filters.properties for combined text + metadata queries, or vault_search_by_property for metadata-only lookups. vault_list_property_keys and vault_list_property_values discover what properties exist across your vault.

These are conventions, not requirements — Vault Cortex works with any property schema. Promoted properties just give you richer filtering and cleaner results out of the box.

Leading callouts get the same treatment. When a note's first body content is an Obsidian callout (> [!type]) — either right after frontmatter or right after the title heading — it's indexed and surfaced alongside every search and discovery result. This makes notes self-describing: an agent scanning results can see what each note is for before deciding which to read. The memory templates use > [!info] Scope of this file callouts for this, and any note in your vault can use the same pattern.

Configuration

All settings are environment variables with sensible defaults.

Variable	Required?	Default	Description
`MCP_AUTH_TOKEN`	Yes	—	Bearer token for authentication (also the JWT signing key)
`VAULT_PATH`	Local only	—	Host path to your vault (bind mount source; remote uses a named volume)
`PUBLIC_URL`	Remote only	—	Public URL for OAuth discovery metadata
`EMBEDDING_ENABLED`	—	`true`	Set `false` to disable the embedding pipeline — skips model download, vector tables, embedding passes, and hybrid search. Search falls back to FTS5 keyword matching.
`RERANK_MODE`	—	`blended`	Cross-encoder reranking mode: `blended` applies position-aware score blending after RRF fusion (~200ms added latency), `none` skips reranking. Only takes effect when `EMBEDDING_ENABLED` is true.
`MEMORY_ENABLED`	—	`true`	Set `false` to fully disable the memory layer — hides memory tools, skips bootstrap, omits memory from server metadata. `MEMORY_DIR` is ignored when `false`.
`MEMORY_DIR`	—	`About Me`	Vault folder for structured memory files
`PROTECTED_PATHS`	—	`MEMORY_DIR, Daily Notes`	Folders that `vault_delete_note` refuses to touch
`ORPHAN_EXCLUDE_FOLDERS`	—	`Daily Notes, Templates, MEMORY_DIR`	Folders excluded from orphan detection
`TZ`	—	`UTC`	IANA timezone for timestamps and daily note resolution
`SERVICE_DOCUMENTATION_URL`	—	GitHub repo URL	URL returned in OAuth discovery metadata
`LOG_LEVEL`	—	`info`	Logging verbosity: `debug`, `info`, `warn`, `error`
`LOG_DIR`	—	`/data/logs` (Docker)	Directory for persistent log files. Logs survive container restarts.
`LOG_RETENTION_DAYS`	—	`30`	Days to keep log files before automatic cleanup on startup
`WINDOWS_MODE`	—	`false`	On Windows? Set `true`. Switches the file watcher to polling and note moves to rename-based writes so a vault on a `C:` drive works through Docker Desktop. Safe to leave on for any Windows setup; unneeded on macOS/Linux/WSL2.

Smart defaults: Setting MEMORY_DIR automatically updates the defaults for PROTECTED_PATHS and ORPHAN_EXCLUDE_FOLDERS. You only set those explicitly for a fully custom list. When MEMORY_ENABLED is false, the memory layer is fully disabled — memory tools are hidden and the memory folder is not auto-created.

See templates/memory/ for memory file examples and the dated-entry design philosophy.

Authentication

For a server with read/write access to personal notes, authentication is not optional. Vault Cortex implements the full OAuth 2.1 specification, including PKCE and refresh-token rotation. The AWS (SST) deployment adds defense-in-depth: requests are validated at two independent layers (API Gateway Lambda authorizer + Express middleware). Per BlueRock's 2026 MCP security analysis, only 8.5% of MCP servers implement OAuth; 41% have no authentication at all.

Two methods:

Method	Used by	Token format
OAuth 2.1	Claude Desktop, Claude Code, claude.ai, any OAuth client	JWT (HS256, 24h)
Static bearer	Claude Code, MCP Inspector, curl	Raw `MCP_AUTH_TOKEN`

OAuth uses dynamic client registration — no Client ID/Secret needed. A consent page opens in your browser; enter your MCP_AUTH_TOKEN to approve. Refresh tokens have a 60-day sliding expiry (daily users never re-authenticate).

See ARCHITECTURE.md → Auth for the full flow diagram.

Deployment Options

Path	What	Guide
Local	Docker on your machine, vault bind-mounted	`deploy/local/`
Remote	VPS + Obsidian Sync, access from anywhere	`deploy/remote/`
AWS (SST)	Full IaC: Lightsail + API Gateway + Lambda + CI/CD	`DEPLOY.md`

Development

bash

# Run locally with hot reload
PUBLIC_URL=http://localhost:8000 MCP_AUTH_TOKEN=local-dev-token VAULT_PATH=~/Vault npm run dev:mcp

# Tests
npm test

# Full check suite
npm run prettier:check && npm run lint && npm test && npm run build

MCP Inspector — interactive browser UI for testing tools:

bash

# Start server (terminal 1), then:
npx @modelcontextprotocol/inspector
# Enter http://localhost:8000/mcp as URL, local-dev-token as Bearer token

See CONTRIBUTING.md for the full development setup.

Companion: obsidian-vault skill

The MCP server works on its own with any client. For agents that support skills (Claude Code, Cursor, Windsurf, Cline, and 70+ others), the obsidian-vault skill adds deeper knowledge of Obsidian-flavored markdown — frontmatter conventions, callout syntax, and plugin-specific formats like Dataview, Tasks, and Kanban.

bash

npx skills add aliasunder/agent-skills --skill obsidian-vault

Skill source →

Roadmap

Phase	What	Status
1	Vault CRUD, full-text search (FTS5), memory layer, OAuth 2.1	Complete
2a	Hybrid search — FTS5 + vector + RRF fusion, heading-aware chunking	Complete
2b	Reranker — cross-encoder reranking, position-aware score blending	Complete
3	Graph memory — automated relationship extraction for relational queries that hand-maintained wikilinks miss	Exploring

Acknowledgments

Vault Cortex's remote capability exists because of @Belphemur's obsidian-headless-sync-docker — a headless Obsidian Sync client that runs in Docker without a display server. It's the piece that makes "access your vault from anywhere" possible. The remote stack runs a small fork that adds a build-time config chown and --device-name on the initial Sync registration (upstream PR #8 remains open).

The hybrid search pipeline draws on patterns from @tobi's qmd — RRF fusion with rank bonuses, position-aware score blending for cross-encoder reranking, content-hash gating, and heading-aware chunking.

Contributing

See CONTRIBUTING.md for development setup, code conventions, and PR guidelines.

License

MIT

Security

Report vulnerabilities privately — see SECURITY.md.

Install

Configuration

Environment variables

MCP_AUTH_TOKENrequiredsecret

Bearer token for MCP client authentication. Must match the Authorization header sent by clients. Generate with: openssl rand -hex 32

PUBLIC_URLdefault http://localhost:8000

Public URL clients use to reach this server. Used as the OAuth issuer URL in discovery metadata. Override when exposing the server outside localhost or on a non-default port.

EMBEDDING_ENABLEDdefault true

Enable or disable the embedding pipeline. When false, no ONNX model is downloaded, no vector tables are created, and search uses FTS5 only.

RERANK_MODEdefault blended

Cross-encoder reranking mode: blended (position-aware score blending after RRF fusion) or none (skip reranking). Only takes effect when EMBEDDING_ENABLED is true.

MEMORY_ENABLEDdefault true

Enable or disable the structured memory layer. When false, memory tools are hidden, bootstrap is skipped, and server metadata omits memory references.

MEMORY_DIRdefault About Me

Vault folder for structured memory files (About Me-style notes). Memory tools are hidden when MEMORY_ENABLED is false, but this value still feeds the defaults for PROTECTED_PATHS and ORPHAN_EXCLUDE_FOLDERS.

TZdefault UTC

IANA timezone for timestamps and daily note resolution.

LOG_LEVELdefault info

Logging verbosity.

LOG_DIR

Directory for persistent log files. Unset by default — logs go to stdout only. Set to /data/logs to also write date-stamped .log files to the persistent volume.

LOG_RETENTION_DAYSdefault 30

Days to retain persistent log files before cleanup.

PROTECTED_PATHS

Comma-separated vault folder names blocked from vault_delete_note. Default: MEMORY_DIR and "Daily Notes".

ORPHAN_EXCLUDE_FOLDERS

Comma-separated vault folder names excluded from vault_find_orphans. Default: "Daily Notes", "Templates", MEMORY_DIR.

SERVICE_DOCUMENTATION_URLdefault https://github.com/aliasunder/vault-cortex

Override the OAuth service documentation URL exposed via discovery metadata.

Arguments

-pdefault 8000:8000

-vrequireddefault {VAULT_PATH}:/vault:rw

claude_desktop_config.json

{
  "mcpServers": {
    "vault-cortex": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "ghcr.io/aliasunder/vault-mcp:0.26.2"
      ],
      "env": {
        "MCP_AUTH_TOKEN": "<YOUR_MCP_AUTH_TOKEN>",
        "PUBLIC_URL": "http://localhost:8000",
        "EMBEDDING_ENABLED": "true",
        "RERANK_MODE": "blended",
        "MEMORY_ENABLED": "true",
        "MEMORY_DIR": "About Me",
        "TZ": "UTC",
        "LOG_LEVEL": "info",
        "LOG_DIR": "<YOUR_LOG_DIR>",
        "LOG_RETENTION_DAYS": "30",
        "PROTECTED_PATHS": "<YOUR_PROTECTED_PATHS>",
        "ORPHAN_EXCLUDE_FOLDERS": "<YOUR_ORPHAN_EXCLUDE_FOLDERS>",
        "SERVICE_DOCUMENTATION_URL": "https://github.com/aliasunder/vault-cortex"
      }
    }
  }
}