Obsidian via REST

Acesse e gerencie seu cofre do Obsidian por meio de uma API REST local.

GitHub
13
Experimente este MCPPatrocinado

Documentação

mcp-obsidian

Implantação / Uso

Ask DeepWiki NPM Version GitHub Stars GitHub Forks NPM Downloads Docker Hub obsidian-mcp Docker Hub obsidian-vnc License: MIT

Status de CI/CD

NPM (npmjs.org) NPM (GitHub)

Docker (GitHub) Docker (Docker Hub)

Screenshots Cleanup

Ferramentas e Recursos MCP

Este servidor MCP expõe as seguintes ferramentas e recursos para assistentes de IA:

Ferramentas

FerramentaDescriçãoParâmetros
get_note_contentRecupera conteúdo e metadados de uma nota do ObsidianfilePath (string) - Caminho para a nota
obsidian_searchPesquisa notas usando uma string de consultaquery (string) - Consulta de pesquisa
obsidian_semantic_searchPesquisa semântica de notasquery (string) - Consulta de pesquisa

Recursos

RecursoPadrão de URIDescrição
Nota do Obsidianobsidian://{path}Acessa notas via URI (ex.: obsidian://Daily/2025-01-16.md)

Teste Rápido

# 1. Set your Obsidian API key
export OBSIDIAN_API_KEY="your-obsidian-rest-api-key"

# 2. Add MCP server and test (Claude Code)
claude mcp add obsidian -- bunx -y @oleksandrkucherenko/mcp-obsidian
claude "Search my Obsidian vault for monitoring tools, summarize findings"

# 2. Alternative: Codex CLI
codex mcp add obsidian --command "bunx -y @oleksandrkucherenko/mcp-obsidian"
codex "Find notes about logging frameworks and create a comparison table"

Exemplo de caso de uso: "Encontre todas as ferramentas no meu cofre do Obsidian para rastrear logs e métricas, faça um relatório resumido" — a IA pesquisa seu cofre, encontra notas sobre OpenTelemetry, Datadog, Prometheus, etc., e gera um resumo estruturado.

Para outras ferramentas CLI (Gemini, OpenCode, Kilo Code, Copilot), consulte o Guia de Teste Manual.

Gemini CLI Example

Configurar MCP

Use API_URLS para failover automático e autocorreção. O servidor testa todas as URLs em paralelo, seleciona a mais rápida e reconecta automaticamente em caso de falha.

{
  "mcpServers": {
    "obsidian": {
      "command": "docker",
      "args": [
        "run",
        "--name", "mcp-obsidian",
        "--rm",
        "-i",  // Keep STDIN open for stdio transport
        "-p", "3000:3000",
        "-e", "API_KEY",
        "-e", "API_URLS",
        "-e", "DEBUG", // for logs
        "ghcr.io/oleksandrkucherenko/obsidian-mcp:latest"
      ],
      "env": {
        "API_KEY": "<secret_key>",
        // JSON array - automatically tests and selects fastest URL
        "API_URLS": "[\"https://127.0.0.1:27124\",\"https://172.26.32.1:27124\",\"https://host.docker.internal:27124\"]",
        "DEBUG": "mcp:*"
      }
    }
  }
}

Recursos de Autocorreção:

  • ✅ Teste paralelo de URLs na inicialização
  • ✅ Seleção automática da URL mais rápida
  • ✅ Monitoramento de saúde a cada 30 segundos
  • ✅ Failover automático em caso de perda de conexão
  • ✅ Backoff exponencial para evitar oscilações

Transportes disponíveis:

  • stdio - Entrada/saída padrão (padrão, melhor para clientes MCP locais)
  • http - HTTP JSON-RPC com streaming SSE (melhor para acesso remoto)

Exemplo WSL2:

# Automatically determine WSL gateway IP
export WSL_GATEWAY_IP=$(ip route show | grep -i default | awk '{ print $3}')

# Configure with multiple fallback URLs
API_URLS='["https://127.0.0.1:27124", "https://'$WSL_GATEWAY_IP':27124", "https://host.docker.internal:27124"]'

Configuração de Transporte HTTP

O servidor MCP suporta transporte HTTP para acesso remoto com failover automático de URL:

{
  "mcpServers": {
    "obsidian-http": {
      "command": "docker",
      "args": [
        "run",
        "--name", "mcp-obsidian-http",
        "--rm",
        "-p", "3000:3000",
        "-e", "API_KEY",
        "-e", "API_URLS",
        "-e", "MCP_HTTP_PATH",
        "ghcr.io/oleksandrkucherenko/obsidian-mcp:latest"
      ],
      "env": {
        "API_KEY": "<secret_key>",
        "API_URLS": "[\"https://127.0.0.1:27124\",\"https://172.26.32.1:27124\",\"https://host.docker.internal:27124\"]",
        "MCP_HTTP_PATH": "/mcp" // endpoint path (default is: /mcp)
      }
    }
  }
}

Configuração Desacoplada com Autenticação

# Automatically determine WSL gateway IP
export WSL_GATEWAY_IP=$(ip route show | grep -i default | awk '{ print $3}')

# Configure with multiple fallback URLs
API_URLS='["https://127.0.0.1:27124", "https://'$WSL_GATEWAY_IP':27124", "https://host.docker.internal:27124"]'

# run MCP server on docker separately from IDE
docker run --name mcp-obsidian-http --rm \
  -p 3000:3000 \
  -e API_KEY="<secret_key>" \
  -e API_URLS="${API_URLS}" \
  -e MCP_HTTP_TOKEN=<your-secret-token-here> \
  ghcr.io/oleksandrkucherenko/obsidian-mcp:latest

{
  "mcpServers": {
    "obsidian": {
      "type": "streamable-http",
      "url": "http://localhost:3000/mcp",
      "headers": {
        "Authorization": "Bearer <your-secret-token-here>"
      }      
    }
  }
}

Os clientes devem incluir o cabeçalho de Autorização:

Authorization: Bearer your-secret-token-here

Configuração de Transporte Stdio

Para desenvolvimento local com transporte stdio (padrão):

{
  "mcpServers": {
    "obsidian": {
      "command": "docker",
      "args": [
        "run",
        "--name", "mcp-obsidian-windsurf",
        "--interactive",
        "--rm",
        "-e", "API_KEY",
        "-e", "API_URLS",
        "-e", "DEBUG",
        "ghcr.io/oleksandrkucherenko/obsidian-mcp:latest"
      ],
      "env": {
        "API_KEY": "<secret_key>",
        "API_URLS": "[\"https://127.0.0.1:27124\",\"https://172.26.32.1:27124\"]",
        "DEBUG": "mcp:*" // default: disabled logs
      }
    }
  }
}
  • --rm - Remove automaticamente o contêiner e seus volumes anônimos associados quando ele sai
  • -i, --interactive - Mantém STDIN aberto
  • -e, --env - Define variáveis de ambiente
  • --name string - Atribui um nome ao contêiner
  • -p, --publish - Publica a porta do contêiner no host
  • Lançamentos de Pacotes NPM
  • Lançamentos de Imagens Docker

Configuração Legada de URL Única

Para compatibilidade reversa, você ainda pode usar configuração de URL única com API_HOST e API_PORT:

{
  "mcpServers": {
    "obsidian": {
      "command": "docker",
      "args": [
        "run",
        "--name", "mcp-obsidian",
        "--rm",
        "-i",
        "-e", "API_KEY",
        "-e", "API_HOST",
        "-e", "API_PORT",
        "ghcr.io/oleksandrkucherenko/obsidian-mcp:latest"
      ],
      "env": {
        "API_KEY": "<secret_key>",
        "API_HOST": "https://172.26.32.1",  // single URL without failover
        "API_PORT": "27124"
      }
    }
  }
}

Nota: A configuração de URL única não fornece failover automático ou monitoramento de saúde. Use API_URLS para implantações em produção.

Endpoint de Saúde

Quando o transporte HTTP está habilitado, o servidor expõe um endpoint de verificação de saúde em /health:

curl http://localhost:3000/health

Resposta:

{
  "status": "healthy",
  "timestamp": "2025-01-12T12:00:00.000Z",
  "transport": "http",
  "authEnabled": false
}

Para status de saúde abrangente incluindo a conexão com a API do Obsidian e todos os transportes, você pode usar a função getHealthStatus() que retorna:

{
  "healthy": true,
  "obsidian": {
    "connected": true,
    "url": "https://obsidian:27124",
    "lastCheck": 1705065600000
  },
  "transports": {
    "stdio": { "running": true, "enabled": true },
    "http": { "running": true, "enabled": true }
  },
  "uptime": 3600,
  "timestamp": 1705065600000
}

Configuração de Ferramentas CLI

Esta seção mostra como configurar ferramentas CLI populares de IA para usar o servidor MCP Obsidian.

# MacOs or Linux
curl -fsSL https://bun.sh/install | bash

# Windows
powershell -c "irm bun.sh/install.ps1 | iex"

Claude Code CLI

Docker:

# Create mcp.json configuration
cat > mcp.json << 'EOF'
{
  "mcpServers": {
    "obsidian": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "-e", "API_KEY", "-e", "API_URLS", "ghcr.io/oleksandrkucherenko/obsidian-mcp:latest"],
      "env": {
        "API_KEY": "<your-obsidian-api-key>",
        "API_URLS": "[\"https://host.docker.internal:27124\"]"
      }
    }
  }
}
EOF

# Run Claude with MCP config
claude --mcp-config ./mcp.json

NPX/Bunx:

cat > mcp.json << 'EOF'
{
  "mcpServers": {
    "obsidian": {
      "command": "bunx",
      "args": ["-y", "@oleksandrkucherenko/mcp-obsidian"],
      "env": {
        "API_KEY": "<your-obsidian-api-key>",
        "API_URLS": "[\"https://127.0.0.1:27124\"]"
      }
    }
  }
}
EOF

claude --mcp-config ./mcp.json

Gemini CLI

Docker:

gemini mcp add \
  -e API_KEY=<your-obsidian-api-key> \
  -e API_URLS='["https://host.docker.internal:27124"]' \
  obsidian \
  docker run --rm -i ghcr.io/oleksandrkucherenko/obsidian-mcp:latest

NPX/Bunx:

gemini mcp add \
  -e API_KEY=<your-obsidian-api-key> \
  -e API_URLS='["https://127.0.0.1:27124"]' \
  obsidian \
  bunx -y @oleksandrkucherenko/mcp-obsidian

Transporte HTTP (servidor remoto):

gemini mcp add --transport http obsidian-http http://localhost:3000/mcp

Listar e gerenciar servidores:

gemini mcp list
gemini mcp remove obsidian

OpenCode CLI

Crie opencode.json na raiz do seu projeto:

Docker:

{
  "mcp": {
    "obsidian": {
      "type": "local",
      "command": ["docker", "run", "--rm", "-i",
        "-e", "API_KEY", "-e", "API_URLS",
        "ghcr.io/oleksandrkucherenko/obsidian-mcp:latest"],
      "environment": {
        "API_KEY": "{env:API_KEY}",
        "API_URLS": "[\"https://host.docker.internal:27124\"]"
      },
      "enabled": true
    }
  }
}

NPX/Bunx:

{
  "mcp": {
    "obsidian": {
      "type": "local",
      "command": ["bunx", "-y", "@oleksandrkucherenko/mcp-obsidian"],
      "environment": {
        "API_KEY": "{env:API_KEY}",
        "API_URLS": "[\"https://127.0.0.1:27124\"]"
      },
      "enabled": true
    }
  }
}

Transporte HTTP:

{
  "mcp": {
    "obsidian-http": {
      "type": "remote",
      "url": "http://localhost:3000/mcp",
      "enabled": true
    }
  }
}

Kilo Code CLI

Crie .kilocode/mcp.json no seu projeto ou ~/.kilocode/cli/global/settings/mcp_settings.json globalmente:

Docker:

{
  "mcpServers": {
    "obsidian": {
      "command": "docker",
      "args": ["run", "--rm", "-i", "-e", "API_KEY", "-e", "API_URLS",
        "ghcr.io/oleksandrkucherenko/obsidian-mcp:latest"],
      "env": {
        "API_KEY": "<your-obsidian-api-key>",
        "API_URLS": "[\"https://host.docker.internal:27124\"]"
      }
    }
  }
}

NPX/Bunx:

{
  "mcpServers": {
    "obsidian": {
      "command": "bunx",
      "args": ["-y", "@oleksandrkucherenko/mcp-obsidian"],
      "env": {
        "API_KEY": "<your-obsidian-api-key>",
        "API_URLS": "[\"https://127.0.0.1:27124\"]"
      }
    }
  }
}

Transporte HTTP:

{
  "mcpServers": {
    "obsidian-http": {
      "type": "streamable-http",
      "url": "http://localhost:3000/mcp",
      "headers": {
        "Authorization": "Bearer <your-token>"
      }
    }
  }
}

Codex CLI

Docker:

# Register MCP server
codex mcp add obsidian \
  --command "docker run --rm -i -e API_KEY -e API_URLS ghcr.io/oleksandrkucherenko/obsidian-mcp:latest" \
  --env API_KEY=<your-obsidian-api-key> \
  --env 'API_URLS=["https://host.docker.internal:27124"]'

NPX/Bunx:

codex mcp add obsidian \
  --command "bunx -y @oleksandrkucherenko/mcp-obsidian" \
  --env API_KEY=<your-obsidian-api-key> \
  --env 'API_URLS=["https://127.0.0.1:27124"]'

GitHub Copilot CLI

Crie ~/.copilot/mcp-config.json (ou .copilot/mcp-config.json na raiz do repositório):

Docker:

{
  "mcpServers": {
    "obsidian": {
      "type": "local",
      "command": "docker",
      "args": ["run", "--rm", "-i", "-e", "API_KEY", "-e", "API_URLS",
        "ghcr.io/oleksandrkucherenko/obsidian-mcp:latest"],
      "env": {
        "API_KEY": "${OBSIDIAN_API_KEY}",
        "API_URLS": "[\"https://host.docker.internal:27124\"]"
      },
      "tools": ["*"]
    }
  }
}

NPX/Bunx:

{
  "mcpServers": {
    "obsidian": {
      "type": "local",
      "command": "bunx",
      "args": ["-y", "@oleksandrkucherenko/mcp-obsidian"],
      "env": {
        "API_KEY": "${OBSIDIAN_API_KEY}",
        "API_URLS": "[\"https://127.0.0.1:27124\"]"
      },
      "tools": ["*"]
    }
  }
}

Nota: O Copilot CLI v0.0.340+ requer sintaxe ${VAR} para expansão de variáveis de ambiente. Defina OBSIDIAN_API_KEY no seu shell antes de executar.

Referência Rápida

Ferramenta CLIArquivo de ConfiguraçãoSuporte DockerTransporte HTTP
Claude Codemcp.json✅✅
Geminisettings.json✅✅
OpenCodeopencode.json✅✅
Kilo Code.kilocode/mcp.json✅✅
CodexComandos CLI✅✅
Copilot~/.copilot/mcp-config.json✅✅

Para testes e verificação detalhados, consulte o Guia de Teste Manual.

Configuração e Solução de Problemas

Configuração

Obsidian Local REST API Setup

Esta configuração permitirá que você se conecte à API REST Local de qualquer interface de rede (não apenas localhost, o que é crítico para a configuração WSL2).

  • Copie a Chave de API das Configurações do Obsidian; você precisará dela para a configuração do MCP.
  • Verifique se a API REST Local do Obsidian está em execução e acessível a partir da sua máquina.
  • O próximo passo é sempre verificar a configuração de rede na sua máquina (regras de firewall, etc).

Verificar se a API REST do Obsidian está em execução (Host Windows, MacOS, Linux)

Execute no terminal CMD do Windows:

# windows CMD, verify that port is listening (that rest api is running)
netstat -an | findstr 27124
# Expected output:
#   TCP    0.0.0.0:27124           0.0.0.0:0               LISTENING

# Verify that Obsidian Local REST API is working
curl --insecure https://localhost:27124
wget --no-check-certificate -S https://localhost:27124
http --verify=no https://localhost:27124

Resposta esperada da API REST:

{
  "status": "OK",
  "manifest": {
    "id": "obsidian-local-rest-api",
    "name": "Local REST API",
    "version": "3.2.0",
    "minAppVersion": "0.12.0",
    "description": "Get, change or otherwise interact with your notes in Obsidian via a REST API.",
    "author": "Adam Coddington",
    "authorUrl": "https://coddingtonbear.net/",
    "isDesktopOnly": true,
    "dir": ".obsidian/plugins/obsidian-local-rest-api"
  },
  "versions": {
    "obsidian": "1.8.10",
    "self": "3.2.0"
  },
  "service": "Obsidian Local REST API",
  "authenticated": false
}

WSL2, Docker hospedado no Ubuntu

graph LR
    subgraph "Windows Machine"
      obs("Obsidian Application")
    
      subgraph "WSL2"
        subgraph "Ubuntu"
          subgraph "Docker"
            mcp("mcp-obsidian:latest")
          end
        end
      end

      firewall(["Windows Firewall"]) -->|27124| obs

      mcp -->|https://$WSL_GATEWAY_IP:27124| firewall

      IDE -.->|MCP Server Tools| mcp
    end

Execute dentro do terminal WSL2 Ubuntu:

export WSL_GATEWAY_IP=$(ip route show | grep -i default | awk '{ print $3}')
echo $WSL_GATEWAY_IP # expected something like: 172.26.32.1

# Verify that Obsidian Local REST API is working 
curl --insecure https://$WSL_GATEWAY_IP:27124
wget --no-check-certificate -S https://$WSL_GATEWAY_IP:27124
http --verify=no https://$WSL_GATEWAY_IP:27124

Verificar o Firewall do Windows

Execute a GUI e configure as regras manualmente:

# Windows Defender Firewall / Inbound Rules. Press Win+R and type WF.msc or firewall.cpl
WF.msc
firewall.cpl # and then press 'Advanced settings'

Ou execute no Windows PowerShell como Administrador:

# Add firewall rule to allow port 27124 (Run in Admin PowerShell)
New-NetFirewallRule -DisplayName "WSL2 Obsidian REST API" -Direction Inbound -LocalPort 27123,27124 -Protocol TCP -Action Allow

Ou execute no terminal CMD do Windows:

# check firewall rules (CMD) that manage 27124 port
netsh advfirewall firewall show rule name=all | findstr /C:"Rule Name" /C:"LocalPort" /C:"RemotePort" | findstr /C:"27124"

# display rules that has WSL2 keyword in own name
netsh advfirewall firewall show rule name=all | grep -A 13 WSL2

# display rule definition by port number (4 line after, 9 lines before)
netsh advfirewall firewall show rule name=all | grep -A 4 -B 9 27124

Desabilitar/Habilitar Firewall

Execute no Windows PowerShell como Administrador:

# Temporarily turn off firewall (for testing ONLY, not recommended for regular use)
Set-NetFirewallProfile -Profile Domain,Public,Private -Enabled False

# Restore Firewall state
Set-NetFirewallProfile -Profile Domain,Public,Private -Enabled True

Verificar Conectividade no Contêiner BusyBox

Estas etapas nos permitem confirmar que a configuração de rede está correta e que o contêiner pode se conectar à API REST Local.

Execute dentro do terminal WSL2 Ubuntu:

export WSL_GATEWAY_IP=$(ip route | grep default | awk '{print $3}')
echo "Windows host IP from WSL2: $WSL_GATEWAY_IP"
# Output:
#   Windows host IP from WSL2: 172.26.32.1

# run docker container to verify the connectivity from Docker inside
docker run --rm -it --network=host busybox sh

# inside the container run:
which wget
# /bin/wget

export WINDOWS_HOST_IP="172.26.32.1"
echo $WINDOWS_HOST_IP
# 172.26.32.1

# try to connect to the Local REST API
wget -qO- --no-check-certificate "https://$WINDOWS_HOST_IP:27124"
wget -qO- --no-check-certificate https://172.26.32.1:27124