---
type: note
alexandria_core: true
author: alexandria
---

# Claude Desktop — connect it to this vault (MCP + GitHub)

Two layers give Claude access to your vault. Set up **GitHub** first (works everywhere, including web + mobile); the **local MCP servers** are a desktop power-up.
{%- set _enabled_ids = modules_info.enabled | map(attribute='id') | list %}
{%- if "vault-mcp" in _enabled_ids %}

## 0. The vault-mcp server (this vault runs its own brain server)

This vault's always-on host runs **`vault-mcp`** — one server every seat talks to, local or
remote. It serves the full tool surface (read, write, and agentic tools like `ingest_content`
and `digest_now`), and commits every write to the vault's
git history. Each seat authenticates with its own Bearer key; read-only seats get read-only
tools. Ask your maintainer for your seat's key — keys are env values on the host
(`VAULT_MCP_BEARER` for the owner), never stored in the vault.

**Claude Code** (local seat, on the host):

```bash
claude mcp add --transport http vault-mcp http://127.0.0.1:{{ vault_mcp.port if vault_mcp else 8765 }}/mcp \
  --header "Authorization: Bearer $VAULT_MCP_BEARER"
```

**Claude Code** (remote seat, any tailnet device): same command, with the host's Tailscale
HTTPS name — `https://<host>.<tailnet>.ts.net/mcp` (run `tailscale status` on the host to see
its name; Tailscale Serve terminates TLS and only tailnet members can reach it).

**Claude Desktop** (bridges HTTP servers via `mcp-remote`) — merge into `mcpServers` in
`~/Library/Application Support/Claude/claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "vault-mcp": {
      "command": "npx",
      "args": ["mcp-remote", "https://HOST.TAILNET.ts.net/mcp",
               "--header", "Authorization:${VAULT_AUTH}"],
      "env": { "VAULT_AUTH": "Bearer YOUR_SEAT_KEY" }
    }
  }
}
```

Then fully quit and reopen Claude Desktop. Three habits worth teaching it: results arrive as
previews/summaries with cursors (ask for `detail="full"` only when needed), **durable
facts belong in the brain** — tell Claude to call `remember(fact)` so what it learns lands in
`Agent/memory/` inside the vault (Desktop's own memory lives on Anthropic's servers and can't
reach the vault by itself) — and **multi-note synthesis questions go to `think_deep`**
rather than manual note-by-note exploration: parallel subagents spider the wikilink graph
server-side and return a `[[wikilink]]`-cited report (poll `job_result`).
{%- endif %}

## 1. GitHub connector (do this first — covers every device)
{% if repo %}In **Claude → Settings → Connectors → GitHub**, authorize it with access to `{{ repo }}`. That alone lets Claude read and edit your vault from web, desktop, and mobile.{% else %}This step needs the **private GitHub backup** first — the connector reads a GitHub repo, and this vault doesn't have one yet (say **"sync to GitHub"**; the `github-sync` skill creates the private repo and connects it). Once the vault has its repo, authorize the connector with access to it in **Claude → Settings → Connectors → GitHub**; from then on Claude can read and edit your vault from web, desktop, and mobile.{% endif %} **Once you've personalized** (said **"Hello"** to your agent, so it knows its name and yours), paste `Agent/Standing Context.md` into Settings → Profile so every chat starts here — it embeds both names, so it's only correct after setup.

## 2. Local MCP servers (Claude Desktop only — faster, graph-aware)
For richer desktop access — live link/graph traversal and direct file edits — add two local MCP servers. **Prerequisites:** Node.js installed (provides `npx`), and the **Obsidian "Semantic Notes Vault MCP"** community plugin installed + running in this vault (it serves the local endpoint and shows you its **port** and **API key**).

Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) — create it if it doesn't exist — and add an `mcpServers` block. If the file already has one, merge these two entries in:

```json
{
  "mcpServers": {
    "obsidian-vault": {
      "command": "npx",
      "args": ["mcp-remote", "http://localhost:PORT/mcp", "--header", "Authorization:${AUTH}"],
      "env": { "AUTH": "Bearer SEMANTIC_MCP_API_KEY" }
    },
    "vault-filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "ABSOLUTE_PATH_TO_YOUR_VAULT"]
    }
  }
}
```

Replace the three placeholders:
- **`PORT`** and **`SEMANTIC_MCP_API_KEY`** — from the Semantic Notes Vault MCP plugin's settings in Obsidian (it shows the local URL + a Bearer key). Keep the `Bearer ` prefix.
- **`ABSOLUTE_PATH_TO_YOUR_VAULT`** — the full path to this vault folder, e.g. `/Users/<you>/Obsidian/<vault>`. Quote it if it contains spaces.

Then **fully quit Claude Desktop (Cmd-Q) and reopen** — it reads this file only on launch.

Notes:
- The `obsidian-vault` server only works while **Obsidian is open** with the Semantic plugin running. The GitHub connector is the always-available fallback.
- The API key lives only in this local file — never commit it. (`AGENTS.md` → Transports explains when Claude uses which.)
