Potencialize seu agente
Instalação do publicador. Não é um endpoint do PlugMCP.
Host a copy with our keys and logs.
Ainda não há uma versão empacotada no registro. Siga o README do repositório.
URL remota ou um comando na sua máquina? Como as duas instalações diferem
Rodar no PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirEnhanced Obsidian MCP Server with Claude.ai Remote Integration, Tailscale Support, and Advanced Query Capabilities!
🔥 Enhanced Fork Notice: This is an enhanced version of the excellent cyanheads/obsidian-mcp-server with additional features specifically tailored for remote Claude.ai integration, advanced task querying, and security via Tailscale.
An MCP (Model Context Protocol) server providing comprehensive access to your Obsidian vault. Enables LLMs and AI agents to read, write, search, and manage your notes and files through the Obsidian Local REST API plugin.
Built on the cyanheads/mcp-ts-template, this server follows a modular architecture with robust error handling, logging, and security features.
Simultaneous access to multiple Obsidian vaults through a single MCP server:
vault parameterPerfect integration with Claude.ai's Remote MCP feature:
MCP_HTTP_STATELESS=true)Access your Obsidian vault securely from anywhere:
Advanced querying capabilities beyond the original:
Enterprise-grade monitoring and auto-restart capabilities:
scripts/health-check.sh)scripts/monitor-mcp.sh)scripts/setup-autostart.sh)This server equips your AI with specialized tools to interact with your Obsidian vault:
| Overview | Features | Installation | | Configuration | Project Structure | Vault Cache Service | | Tools | Resources | Development | License |
The Obsidian MCP Server acts as a bridge, allowing applications (MCP Clients) that understand the Model Context Protocol (MCP) – like advanced AI assistants (LLMs), IDE extensions, or custom scripts – to interact directly and safely with your Obsidian vault.
Instead of complex scripting or manual interaction, your tools can leverage this server to:
Built on the robust mcp-ts-template, this server provides a standardized, secure, and efficient way to expose Obsidian functionality via the MCP standard. It achieves this by communicating with the powerful Obsidian Local REST API plugin running inside your vault.
Developer Note: This repository includes a .clinerules file that serves as a developer cheat sheet for your LLM coding agent with quick reference for the codebase patterns, file locations, and code snippets.
Leverages the robust utilities provided by the mcp-ts-template:
McpError), and automatic logging.dotenv) with comprehensive validation.zod for schema validation and custom sanitization logic.ObsidianRestApiService.💡 Quick Setup: For automatic startup on boot, see the Auto-Start Setup Guide after installation.
git clone https://github.com/BoweyLou/obsidian-mcp-server-enhanced.git
cd obsidian-mcp-server-enhanced
npm install
npm run build
This compiles the TypeScript code to JavaScript in the dist/ directory and makes the entry point executable.Configure the server using environment variables.
These variables must be set in the MCP client configuration (e.g., cline_mcp_settings.json) or in your environment before starting the server (if running directly).
If running directly, they can be set in a .env file in the project root or directly in your environment.
The server supports both single-vault (backwards compatible) and multi-vault modes:
# .env file
MCP_AUTH_KEY=your-generated-mcp-auth-key
OBSIDIAN_API_KEY=your-obsidian-plugin-api-key
OBSIDIAN_BASE_URL=http://127.0.0.1:27123
MCP_TRANSPORT_TYPE=http
MCP_HTTP_STATELESS=true
# .env file
MCP_AUTH_KEY=your-generated-mcp-auth-key
OBSIDIAN_VAULTS='[
{
"id": "work",
"name": "Work Vault",
"apiKey": "work-vault-api-key",
"baseUrl": "http://127.0.0.1:27123",
"verifySsl": false
},
{
"id": "personal",
"name": "Personal Vault",
"apiKey": "personal-vault-api-key",
"baseUrl": "http://127.0.0.1:27122",
"verifySsl": false
}
]'
MCP_TRANSPORT_TYPE=http
MCP_HTTP_STATELESS=true
openssl rand -hex 32.env with OBSIDIAN_VAULTS JSON configurationnpm run start:httpTo connect in single-vault mode, configure the base URL (OBSIDIAN_BASE_URL) and API key (OBSIDIAN_API_KEY). The Obsidian Local REST API plugin offers two connection types:
Encrypted (HTTPS):
https:// endpoint (e.g., https://127.0.0.1:27124)OBSIDIAN_VERIFY_SSL=false for self-signed certificatesNon-encrypted (HTTP) - Recommended:
http:// endpoint (e.g., http://127.0.0.1:27123)For multi-vault mode, configure each vault individually in the OBSIDIAN_VAULTS JSON array with its own API key and base URL. Each vault can use either HTTP or HTTPS as needed.
Example configurations:
Single-vault with HTTP:
"env": {
"MCP_AUTH_KEY": "your-generated-mcp-auth-key",
"OBSIDIAN_API_KEY": "your-obsidian-api-key",
"OBSIDIAN_BASE_URL": "http://127.0.0.1:27123"
}
Multi-vault configuration:
"env": {
"MCP_AUTH_KEY": "your-generated-mcp-auth-key",
"OBSIDIAN_VAULTS": "[{\"id\":\"work\",\"name\":\"Work\",\"apiKey\":\"work-key\",\"baseUrl\":\"http://127.0.0.1:27123\"},{\"id\":\"personal\",\"name\":\"Personal\",\"apiKey\":\"personal-key\",\"baseUrl\":\"http://127.0.0.1:27122\"}]"
}
Note: For Claude.ai Remote MCP integration, skip this section and use the Tailscale Remote Access Setup instead.
For local MCP clients (e.g., Cline), add to your settings (e.g., cline_mcp_settings.json):
Single-vault configuration:
{
"mcpServers": {
"obsidian-mcp-server": {
"command": "node",
"args": ["/path/to/your/obsidian-mcp-server-enhanced/dist/index.js"],
"env": {
"MCP_AUTH_KEY": "your-generated-mcp-auth-key",
"OBSIDIAN_API_KEY": "your-obsidian-api-key",
"OBSIDIAN_BASE_URL": "http://127.0.0.1:27123",
"OBSIDIAN_ENABLE_CACHE": "true"
}
}
}
}
Multi-vault configuration:
{
"mcpServers": {
"obsidian-mcp-server": {
"command": "node",
"args": ["/path/to/your/obsidian-mcp-server-enhanced/dist/index.js"],
"env": {
"MCP_AUTH_KEY": "your-generated-mcp-auth-key",
"OBSIDIAN_VAULTS": "[{\"id\":\"work\",\"name\":\"Work Vault\",\"apiKey\":\"work-api-key\",\"baseUrl\":\"http://127.0.0.1:27123\"},{\"id\":\"personal\",\"name\":\"Personal Vault\",\"apiKey\":\"personal-api-key\",\"baseUrl\":\"http://127.0.0.1:27122\"}]",
"OBSIDIAN_ENABLE_CACHE": "true"
}
}
}
}
For remote access to your Obsidian vault from anywhere, you can use Tailscale to securely expose your MCP server over the internet.
Generate MCP Auth Key:
openssl rand -hex 32
Configure Environment: Set up your .env file with the generated key:
MCP_AUTH_KEY=your-generated-auth-key
MCP_TRANSPORT_TYPE=http
MCP_HTTP_PORT=3010
MCP_HTTP_STATELESS=true
Configure Vaults: Set up single or multi-vault configuration (see Multi-Vault Configuration)
Start the MCP Server:
npm run build && npm run start:http
Enable Tailscale Funnel:
tailscale funnel 3010
Get Your Public URL: Check your Tailscale device URL:
tailscale status --self | grep "Funnel on"
Add to your Claude.ai Remote MCP servers using your MCP authentication key:
Single-vault setup:
{
"url": "https://your-device.your-tailnet.ts.net/mcp?api_key=your-mcp-auth-key",
"name": "Obsidian Vault"
}
Multi-vault setup:
{
"url": "https://your-device.your-tailnet.ts.net/mcp?api_key=your-mcp-auth-key",
"name": "Obsidian Multi-Vault"
}
Authentication Note: Claude.ai Remote MCP uses the
MCP_AUTH_KEYfor server authentication. Individual vault operations use the vault-specific API keys configured in your environment.
Once set up, you can use tools remotely from Claude.ai:
Single-vault commands (uses default vault):
Use obsidian_task_query to show me tasks due today with format="table"
Multi-vault commands (specify vault):
Use obsidian_task_query with vault="work" to show me work tasks due today
Use obsidian_read_file with filePath="daily-note.md" and vault="personal"
Use obsidian_dataview_query with vault="work" to run: TABLE file.name FROM #meeting WHERE file.cday = date(today)
🚀 Pro Tip: For production use, set up automatic startup on boot so your server and Tailscale Funnel start automatically without manual intervention.
Claude and local MCP clients can connect directly to /mcp. Hosted ChatGPT
connectors should use the separate obsidian-chatgpt facade instead. The
facade reuses the existing vault, search, and task logic internally, but it has
its own process, port, OAuth/PKCE authorization flow, scoped capabilities, and
write audit log.
Use the facade for public HTTPS or Tailscale Funnel routes. Keep the full MCP server on localhost or private tailnet-only routes unless you are doing an explicit local/dev test.
Configure a public resource URL and admin approval secret, then start the facade:
export CHATGPT_FACADE_PUBLIC_URL="https://your-device.your-tailnet.ts.net"
export CHATGPT_FACADE_ADMIN_SECRET="$(openssl rand -hex 24)"
npm run build
npm run start:chatgpt
If the same Funnel hostname also exposes another ChatGPT connector, give this
facade a path-scoped resource URL such as
https://your-device.your-tailnet.ts.net/obsidian and route the /obsidian
prefix to the facade port. The facade serves both root and path-qualified
well-known metadata paths for that setup. In that shared-host setup, create the
connector with https://your-device.your-tailnet.ts.net/obsidian/mcp.
Check health:
curl "http://127.0.0.1:3020/health"
For facade HTTP-surface tests without a live Obsidian API, set
CHATGPT_FACADE_SKIP_OBSIDIAN_CHECK=true. Leave it unset for normal operation.
Expose only the facade through Funnel:
make tailscale-funnel-chatgpt
The facade publishes OAuth discovery metadata:
/.well-known/oauth-protected-resource/.well-known/oauth-authorization-server/.well-known/openid-configurationIt stores authorization-code, access-token, and refresh-token hashes locally
under CHATGPT_FACADE_STORE_PATH, not raw tokens. It requires PKCE S256 for
initial token exchange, supports refresh-token rotation, and validates bearer
tokens by resource, expiry, and scope before executing actions.
Scopes:
obsidian:read: search, fetch, task_query, latest_noteobsidian:write: create_task, update_task, append_note, create_note, create_daily_noteobsidian:dangerous-write: overwrite_noteRead-only connector setup is the default and is supported by granting only
obsidian:read.
overwrite_note is not available unless obsidian:dangerous-write is
explicitly granted.
All actions use POST /chatgpt/actions with Authorization: Bearer <token>.
They accept an optional vault field. The default public surface is intentionally
smaller than the full local MCP tool set.
Successful action responses use the same envelope for HTTP actions and facade MCP tool calls:
{
"success": true,
"action": "create_daily_note",
"vault": "default",
"resultPath": "Daily/2026-07-03.md",
"data": {
"filePath": "Daily/2026-07-03.md"
}
}
Write actions include resultPath when the affected vault path is known.
Task-creation and task-update actions also include taskLineNumber when the
line number is available.
Writes are appended to the local JSONL audit log at
CHATGPT_FACADE_AUDIT_PATH. The audit entry records action, client id, scopes,
target path, mode, result path, status, and a capped input summary; it does not
store raw ChatGPT transcripts or full note bodies. Operators can inspect recent
entries with:
curl "http://127.0.0.1:3020/audit/recent?admin_secret=$CHATGPT_FACADE_ADMIN_SECRET"
CHATGPT_LAYER_ENABLED=true still enables the older in-process
manifest/actions layer on the main HTTP transport for local/dev compatibility.
That layer uses MCP_AUTH_KEY query-string auth and exposes broader actions
including page overwrite. Do not use it as the recommended hosted ChatGPT
connector path.
The codebase follows a modular structure within the src/ directory:
src/
├── index.ts # Entry point: Initializes and starts the server
├── config/ # Configuration loading (env vars, package info)
│ └── index.ts
├── mcp-server/ # Core MCP server logic and capability registration
│ ├── server.ts # Server setup, transport handling, tool/resource registration
│ ├── resources/ # MCP Resource implementations (currently none)
│ ├── tools/ # MCP Tool implementations (subdirs per tool)
│ └── transports/ # Stdio and HTTP transport logic, auth middleware
├── services/ # Abstractions for external APIs or internal caching
│ ├── obsidianRestAPI/ # Typed client for Obsidian Local REST API
│ └── vaultManager/ # Multi-vault configuration and service management
├── types-global/ # Shared TypeScript type definitions (errors, etc.)
└── utils/ # Common utility functions (logger, error handler, security, etc.)
For a detailed file tree, run npm run tree or see docs/tree.md.
This server includes an intelligent in-memory cache designed to enhance performance and resilience when interacting with your vault.
obsidian_global_search tool. If the live API search fails or times out, the server seamlessly uses the cache to provide results, ensuring that search functionality remains available even if the Obsidian API is temporarily unresponsive.VaultCacheService builds an in-memory map of all .md files in your vault, storing their content and modification times.obsidian_update_file, the service proactively updates the cache for that specific file, ensuring immediate consistency.obsidian_global_search tool first attempts a live API search. If this fails, it automatically falls back to searching the in-memory cache.The cache is enabled by default but can be configured via environment variables:
OBSIDIAN_ENABLE_CACHE: Set to true (default) or false to enable or disable the cache service.OBSIDIAN_CACHE_REFRESH_INTERVAL_MIN: Defines the interval in minutes for the periodic background refresh. Defaults to 10.The Obsidian MCP Server provides a suite of tools for interacting with your vault(s), callable via the Model Context Protocol.
All tools support an optional vault parameter to specify which vault to operate on:
vault parameter, tools use the first configured vaultvault: "vault-id" to target a specific vaultobsidian_read_file(filePath="note.md", vault="work")Note: All tools support comprehensive error handling, multi-vault routing, and return structured JSON responses.
This project is licensed under the Apache License 2.0 - see the LICENSE file for details.
This enhanced version is based on the excellent work by cyanheads in the original obsidian-mcp-server project. All core functionality and architecture credit goes to the original author.
Enhancements in this fork:
This is an enhanced version of the excellent cyanheads/obsidian-mcp-server with additional features specifically tailored for remote Claude.ai integration, advanced task querying, and security via Tai
Visão geral
This is an enhanced version of the excellent cyanheads/obsidian-mcp-server with additional features specifically tailored for remote Claude.ai integration, advanced task querying, and security via Tailscale.
Ferramentas
Ainda não há lista de ferramentas. Servidores remotos recebem uma após a primeira verificação de saúde.
Perguntas frequentes
Copie nesta página a configuração stdio para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.
Este registro não lista nenhuma variável de ambiente obrigatória.
Obsidian MCP Server Enhanced roda localmente via stdio.
Última verificação: 2026-10-27. This is an enhanced version of the excellent cyanheads/obsidian-mcp-server with additional features specifically tailored for remote Claude.ai integration, advanced task querying, and security via Tailscale.