# Obsidian

> Read and write notes in your local Obsidian vault.

[Canonical HTML page](https://top-mcps.com/mcp/obsidian) · [server.json](https://top-mcps.com/mcp/obsidian.json) · [methodology](https://top-mcps.com/about/methodology)

## Install

### Claude Desktop — `claude_desktop_config.json`

Paste under mcpServers. Fully quit and reopen Claude after editing.

```json
{
  "mcpServers": {
    "obsidian": {
      "command": "uvx",
      "args": [
        "mcp-obsidian"
      ],
      "env": {
        "OBSIDIAN_API_KEY": "${OBSIDIAN_API_KEY}",
        "OBSIDIAN_HOST": "${OBSIDIAN_HOST}"
      }
    }
  }
}
```

### Claude Code — `CLI or .mcp.json`

Run from your repo. Commit .mcp.json to share with your team.

```shell
# export OBSIDIAN_API_KEY=your_local_rest_api_key
# export OBSIDIAN_HOST=127.0.0.1
claude mcp add obsidian -- uvx mcp-obsidian
```

### Cursor — `.cursor/mcp.json`

Global path: ~/.cursor/mcp.json. Reload window after editing.

```json
{
  "mcpServers": {
    "obsidian": {
      "command": "uvx",
      "args": [
        "mcp-obsidian"
      ],
      "env": {
        "OBSIDIAN_API_KEY": "${OBSIDIAN_API_KEY}",
        "OBSIDIAN_HOST": "${OBSIDIAN_HOST}"
      }
    }
  }
}
```

### VS Code — `.vscode/mcp.json`

VS Code uses the "servers" key (not "mcpServers").

```jsonc
{
  "servers": {
    "obsidian": {
      "command": "uvx",
      "args": [
        "mcp-obsidian"
      ],
      "env": {
        "OBSIDIAN_API_KEY": "${OBSIDIAN_API_KEY}",
        "OBSIDIAN_HOST": "${OBSIDIAN_HOST}"
      }
    }
  }
}
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Open via Cascade → hammer icon → Configure.

```json
{
  "mcpServers": {
    "obsidian": {
      "command": "uvx",
      "args": [
        "mcp-obsidian"
      ],
      "env": {
        "OBSIDIAN_API_KEY": "${OBSIDIAN_API_KEY}",
        "OBSIDIAN_HOST": "${OBSIDIAN_HOST}"
      }
    }
  }
}
```

### Cline — `cline_mcp_settings.json`

Open via the Cline sidebar → MCP Servers → Edit.

```json
{
  "mcpServers": {
    "obsidian": {
      "command": "uvx",
      "args": [
        "mcp-obsidian"
      ],
      "env": {
        "OBSIDIAN_API_KEY": "${OBSIDIAN_API_KEY}",
        "OBSIDIAN_HOST": "${OBSIDIAN_HOST}"
      }
    }
  }
}
```

### Continue — `~/.continue/config.json`

Continue uses modelContextProtocolServers with a transport block.

```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "uvx",
          "args": [
            "mcp-obsidian"
          ],
          "env": {
            "OBSIDIAN_API_KEY": "${OBSIDIAN_API_KEY}",
            "OBSIDIAN_HOST": "${OBSIDIAN_HOST}"
          }
        }
      }
    ]
  }
}
```

### Codex CLI — `~/.codex/config.toml`

Codex uses TOML. Each server is a [mcp_servers.<name>] subtable.

```shell
# ~/.codex/config.toml
[mcp_servers.obsidian]
command = "uvx"
args = [
  "mcp-obsidian",
]
env = { OBSIDIAN_API_KEY = "${OBSIDIAN_API_KEY}", OBSIDIAN_HOST = "${OBSIDIAN_HOST}" }
```

### Zed — `~/.config/zed/settings.json`

Zed calls them "context_servers". Settings live-reload on save.

```jsonc
{
  "context_servers": {
    "obsidian": {
      "command": {
        "path": "uvx",
        "args": [
          "mcp-obsidian"
        ]
      },
      "env": {
        "OBSIDIAN_API_KEY": "${OBSIDIAN_API_KEY}",
        "OBSIDIAN_HOST": "${OBSIDIAN_HOST}"
      }
    }
  }
}
```

### ChatGPT — `ChatGPT → Settings → Connectors → Developer mode`

Enable Developer mode (paid plans) and enter these values in the UI.

```json
{
  "name": "Obsidian",
  "transport": "stdio",
  "command": "uvx",
  "args": [
    "mcp-obsidian"
  ],
  "env": {
    "OBSIDIAN_API_KEY": "${OBSIDIAN_API_KEY}",
    "OBSIDIAN_HOST": "${OBSIDIAN_HOST}"
  }
}
```

## At a glance

- **Maintainer:** Community (MarkusPfundstein)
- **Transport:** stdio
- **Auth model:** API key
- **Required secrets:** OBSIDIAN_API_KEY, OBSIDIAN_HOST
- **Supported clients:** Claude, Cursor, Any MCP-compatible client
- **License:** MIT
- **Language:** Python
- **Latest version:** latest
- **Last verified:** 2026-04-19
- **GitHub stars:** 3,425 (fetched 2026-04-19T20:32:57.605Z)
- **Score:** 65/100 (rubric 2026-04 — see https://top-mcps.com/about/methodology)
- **Source:** https://github.com/MarkusPfundstein/mcp-obsidian

## Security & scope

- **Access scope:** read-write
- **Sandbox:** Reads and writes Markdown files inside a local Obsidian vault directory passed at launch. Access is scoped to that single vault.
- **Gotchas:**
  - The MCP does not understand Obsidian plugins — edits that depend on plugin-generated content (Dataview, Templater) may look incomplete.
  - Renaming a note does not update backlinks unless the agent does so explicitly.

## Quick answer

**What it does.** Reads and writes Markdown files in an Obsidian vault: search, create, update, list notes, resolve internal [[wikilinks]], and walk backlinks.

**Best for:**
- Personal knowledge capture
- Daily-note automation
- Research assistance
- Reading-list curation
- Zettelkasten workflows

**Not for:**
- Real-time collaboration
- Binary attachment search

## Recipes

### Collect follow-ups into a daily note

```
In my Obsidian vault at ~/Obsidian/Work, find every note tagged `#followup` that has been modified in the last 7 days. Append a "Followups" section to today's daily note listing each as `- [[title]] — <one-sentence gist>` with a link back.
```

_Tested with: Claude Desktop, Cursor_

## Description

The Obsidian MCP connects AI agents to your local Markdown vault. Search notes, create new ones, append to daily journals, and follow backlinks — turning Obsidian into a knowledge graph the agent can read and extend.

## Why it matters

Obsidian is where a lot of individuals (and small teams) keep personal knowledge. An agent with read/write access becomes a second brain that can actually edit the primary brain.

## Key features

- Vault-scoped read/write
- Backlink resolution
- Tag queries
- Daily-note append
- Local-only, no cloud required

## FAQ

### Does it require the Obsidian desktop app to be running?

Yes, plus the Local REST API community plugin. The MCP talks to that plugin over loopback. If Obsidian is closed, the agent can still read the Markdown files directly (via the Filesystem MCP), but writes and backlink queries need the app.

### Is it safe to let an agent write to my vault?

Reasonably — but version-control the vault first. Obsidian + Git is a popular combo exactly because agents (and humans) occasionally make changes you want to revert quickly.

### Can it follow [[wikilinks]]?

Yes. The MCP understands Obsidian's wikilink syntax and can walk outgoing links and backlinks — so agents can traverse a concept graph rather than just searching full-text.

### Does it work with the Obsidian Sync service?

Indirectly. The MCP reads and writes local files; whatever sync setup you have (Obsidian Sync, iCloud, Git) then propagates changes to other devices. There is no direct integration with the Sync service API.

## Changelog

- **2026-04-19** — Refreshed install snippets and fact sheet; verified for 2026.
- **2025-02-01** — Initial directory listing.