Home
Servers
AI
Vault Cortex

Vault Cortex

by aliasunder

479 downloads

Not rated

GitHub

About

Standalone MCP server for Obsidian vaults — hybrid search, notes & files, structured memory, tasks, and full vault access for any AI agent

Details

Author: aliasunder
Downloads: 479
Categories: AI, Other, Knowledge Base, Search, Developer Tools, Project Management

- Plugin‑free: Obsidian does not need to be running
- Remote access via OAuth 2.1 from any MCP client
- Hybrid search: FTS5 + vector similarity + cross‑encoder reranking
- Structured memory for persistent AI personalization
- Obsidian‑native: frontmatter, wikilinks, tags, headings, daily notes
- Task queries parsing both Tasks‑plugin and Dataview formats
- Link graph: backlinks, outgoing links, orphan detection

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Vault Cortex

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

From the repository

Run npx vault-cortex@latest init after installing Docker and Node.js >= 20.12 and pointing to an Obsidian vault. Alternatively, follow the local or remote deployment guides in the repository. Authentication can be configured via OAuth 2.1 or a static bearer token.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

McpServers

{
    "vault-cortex": {
        "url": "http://localhost:8000/mcp",
        "headers": {
            "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
        }
    }
}

Vault Cortexis a standalone MCP server that gives any AI agenthybrid search, task management, structured memory, and read/write accessto yourObsidianvault. No plugins, no running Obsidian, no separate bridge. One Docker container, your vault folder, a full tool suite + 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·Memory·Tasks·Files·Tools·Prompts·Properties·Config·Daily Notes·Data Integrity·Auth·Deployment·Community Deployments

All three demos run on Claude mobile. The vault is on a remote server, not the phone.

- 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.mdfiles 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, append-only entries accumulate into a personal knowledge layer, auto-initialized for AI personalization. Topic recall answers "what do I think about X?" with the current take and the dated history behind it — evolution included.
- Tasks— Kanban-aware task queries and updates: triage by status, dates, or priority, then complete, reprioritize, or move tasks between lanes in one call. Parses both Tasks pluginemoji and Dataviewinline-field formats.
- Link graph— backlinks, outgoing links, and orphan detection across the vault
- Files— read the vault's non-markdown files too: images arrive as actual images (shrunk to fit when needed), PDFs as structured text or rendered pages, canvases as readable outlines, data files as text
- Obsidian-native— understands frontmatter, wikilinks, tags, headings, and daily notes
- Guided workflows— 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.

Local (2 minutes — Docker + your vault folder)

Prerequisites:Docker(or a Docker-compatible runtime, e.g. OrbStack, Colima, Podman), Node.js >= 20.12 (only for the CLI — the server itself runs in Docker), and an Obsidian vault (or any folder of.mdfiles).

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 (CLI reference →).

Set up with the CLI?It manages the server from here on —configure,upgrade,start,restart,logs,down(CLI reference →).

Set up with Compose?Stick with Compose for updates too (docker compose pull && docker compose up -d) — the CLI and Compose manage the container independently.

# 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

Full local guide →(includes Windows setup)

Remote (access from anywhere — Docker + Obsidian Sync)

Prerequisites:a VPS with Docker(or a Docker-compatible runtime), an Obsidian Syncsubscription, and Node.js >= 20.12 (only for the CLI — the server itself runs in Docker).

# 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 get-sync-tokenfor you), and auth config, then starts the server (CLI reference →).

Set up with the CLI?It manages the server from here on —configure,upgrade,start,restart,logs,down(CLI reference →).

Set up with Compose?Stick with Compose for updates too (docker compose pull && docker compose up -d) — the CLI and Compose manage the container independently.

# 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

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 anAuthorization: Bearerheader.

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

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

The "Add custom connector" dialog only acceptshttpsURLs. With anhttpsPUBLIC_URL, add it directly in the connector dialog; for a localhost server, register it inclaude_desktop_config.jsonthrough the mcp-remotestdio bridge instead:

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

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[Authenticationfor both methods and token lifetimes.

Everything runs in one Docker container, working directly with the.mdfiles on disk:

- Your vault stays the source of truth— the server reads and writes the same plain Markdown files your Obsidian apps do.
- Search is derived data— a file watcher keeps the index (keywords + vectors) current as notes change, and it can be rebuilt from your notes at any time.
- The remote image adds a sync loop— a bundled Obsidian Sync service keeps the container's vault current with every device: edit a note on your phone and it's searchable moments later; an agent writes a note and it shows up in Obsidian.

…

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

Install

{
    "mcpServers": {
        "vault cortex": {
            "vault-cortex": {
                "url": "http://localhost:8000/mcp",
                "headers": {
                    "Authorization": "Bearer <YOUR_MCP_AUTH_TOKEN>"
                }
            }
        }
    }
}

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

Local (2 minutes — Docker + your vault folder)

Remote (access from anywhere — Docker + Obsidian Sync)

Install

More like this

Sequential Thinking

Aws Kb Retrieval Server

Memory

Filesystem

EverArt

Google Drive