BunkerWeb MCP

Servidor MCP oficial para gerenciar implantações do BunkerWeb a partir de assistentes de IA, incluindo instâncias, serviços, configuração, bans, plugins, jobs e cache.

GitHub

Experimente este MCPPatrocinado

Documentação

Servidor MCP BunkerWeb (Python)

Um servidor MCP pronto para produção que expõe a API interna do BunkerWeb para modelos de linguagem de grande porte por meio de uma interface de ferramentas restrita. O servidor fornece endpoints JSON-RPC HTTP (para testes) e WebSocket (para clientes MCP), validação rigorosa de entrada e um cliente assíncrono resiliente com novas tentativas.

Site do BunkerWeb · Documentação

Início rápido com Claude Code

# Install the package
git clone https://github.com/bunkerity/bunkerweb-mcp.git
cd bunkerweb-mcp

# For demo/testing you do not need to change anything
# Configure environment
cp .env.example .env
# Edit .env to set BUNKERWEB_BASE_URL

# Launch BunkerWeb Stack
docker compose up -d

# If you launch Claude in this repo, it will automatically read the .mcp.json file with mcp server url.
# You can then just launch Claude
claude
> List all BunkerWeb instances
> List my BunkerWeb services
> Review @config://global for security improvements

# To connect to a remote BunkerWeb MCP server,
# use BunkerWeb itself to protect the service with TLS:
claude mcp add --transport http bunkerweb http://remote-ip:8080/mcp/

claude mcp add --transport http bunkerweb https://your-domain.com/mcp/

Recursos

43 ferramentas de API integradas, além de busca semântica opcional
🔍 Busca semântica com IA na documentação do BunkerWeb via serviço de busca remoto (opcional, configurável)
Recursos MCP para acesso somente leitura a dados (configuração global, logs de jobs, banimentos ativos, status da instância)
Múltiplos transportes: Stdio (para Claude Code), HTTP, WebSocket
Integração oficial com o SDK MCP usando FastMCP para clientes compatíveis (Claude Code, VS Code, Claude Desktop)
Cliente assíncrono robusto com novas tentativas/backoff e modelos Pydantic tipados
Catálogo de prompts fornecendo orientação contextual para cada ferramenta
Aplicativo FastAPI expondo endpoints JSON-RPC /rpc HTTP e /ws WebSocket (legado)
Ponto de entrada CLI (bunkerweb-mcp) para integração fácil
Documentação abrangente incluindo CLAUDE.md com conhecimento especializado do BunkerWeb
Autenticação opcional via token de segredo compartilhado ou token bearer da API
Logs JSON estruturados com métricas para observabilidade
Testes unitários com transporte HTTP simulado
Manifestos de implantação Docker e Kubernetes
⚡ Otimizações de desempenho (Sprint 2):
- Camada de cache com TTLs configuráveis para operações somente leitura
- Limitação de taxa opcional para proteger contra inundações de solicitações
- Suporte a múltiplos workers para implantações de alto tráfego
- Suíte de testes de carga com Locust para validação de desempenho

Requisitos

Acesso a uma API do BunkerWeb (testado com BunkerWeb 1.6.13 e código de desenvolvimento atual 1.6.14~rc1; padrão http://localhost:8888)

Instalação

A partir do código-fonte

# Clone the repository
git clone https://github.com/bunkerity/bunkerweb-mcp.git
cd bunkerweb-mcp

# Create virtual environment
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install in development mode
pip install -e ".[dev]"

# Or install from requirements
pip install -r requirements.txt

# Configure environment
cp .env.example .env

A partir do PyPI (quando publicado)

pip install bunkerweb-mcp

Atualize .env com a URL base da sua API e um token ou credenciais básicas, se necessário.

Contexto de desenvolvimento

O repositório inclui um arquivo CLAUDE.md que fornece ao Claude Code conhecimento especializado abrangente do BunkerWeb e melhores práticas. Este arquivo é carregado automaticamente ao trabalhar neste repositório com Claude Code, dando ao assistente contexto sobre:

Arquitetura e componentes do BunkerWeb
Configuração de módulos de segurança (ModSecurity, Antibot, etc.)
Fluxos de trabalho operacionais comuns
Diretrizes de solução de problemas
Melhores práticas para implantações de produção

Configuração

Todas as configurações são ajustáveis por meio de variáveis de ambiente (veja .env.example):

Variável	Descrição	Padrão
`BUNKERWEB_BASE_URL`	URL base da API do BunkerWeb	`http://localhost:8888`
`BUNKERWEB_API_TOKEN`	Token bearer estático opcional	vazio
`BUNKERWEB_BASIC_USERNAME`	Nome de usuário opcional para autenticação básica HTTP	vazio
`BUNKERWEB_BASIC_PASSWORD`	Senha opcional para autenticação básica HTTP	vazio
`BUNKERWEB_REQUEST_TIMEOUT_SECONDS`	Tempo limite HTTP em segundos	`30`
`BUNKERWEB_MAX_RETRIES`	Tentativas de nova tentativa para falhas transitórias	`3`
`BUNKERWEB_RETRY_BACKOFF_INITIAL`	Atraso inicial de backoff (segundos)	`0.5`
`BUNKERWEB_RETRY_BACKOFF_MAX`	Atraso máximo de backoff (segundos)	`5.0`
`BUNKERWEB_WEBSOCKET_TOKEN`	Segredo compartilhado exigido por `/ws` e `/rpc`	vazio
`BUNKERWEB_LOG_LEVEL`	Nível de registro de log	`INFO`
`BUNKERWEB_PROMPT_CATALOG`	Arquivo JSON opcional com prompts por ferramenta	catálogo integrado
`RATE_LIMIT_ENABLED`	Ativar limitação de taxa (Sprint 2)	`false`
`RATE_LIMIT_TOOLS`	Limite de taxa para o endpoint /tools	`30/minute`
`RATE_LIMIT_RPC`	Limite de taxa para o endpoint /rpc	`100/minute`
`RATE_LIMIT_WS`	Limite de taxa para mensagens WebSocket	`500/minute`
`CACHE_ENABLED`	Ativar camada de cache (Sprint 2)	`true`
`WORKERS`	Número de workers Uvicorn (somente Docker)	`1`

Executando o servidor

Modo HTTP (recomendado)

docker-compose

docker compose up --build

O arquivo compose inicia uma pilha de demonstração BunkerWeb 1.6.13 e conecta o servidor MCP à sua API.

Local (uvicorn)

uvicorn bunkerweb_mcp.main:app --host 0.0.0.0 --port 8080

Docker

docker build -t bunkerweb-mcp .
docker run --rm -p 8080:8080 --env-file .env bunkerweb-mcp

Kubernetes

Implante no Kubernetes com integração ao controlador de entrada do BunkerWeb:

# Quick deployment
kubectl apply -f deploy/kubernetes/namespace.yaml
kubectl apply -f deploy/kubernetes/secret.yaml      # Edit credentials first
kubectl apply -f deploy/kubernetes/configmap.yaml
kubectl apply -f deploy/kubernetes/deployment.yaml
kubectl apply -f deploy/kubernetes/service.yaml

# Optional: External access via BunkerWeb ingress
kubectl apply -f deploy/kubernetes/ingress.yaml

# Optional: Autoscaling and monitoring
kubectl apply -f deploy/kubernetes/hpa.yaml
kubectl apply -f deploy/kubernetes/servicemonitor.yaml

# Verify deployment
kubectl get pods -n bunkerweb
kubectl logs -n bunkerweb -l app=mcp-bunkerweb --tail=100 -f

Recursos principais:

Controlador de entrada do BunkerWeb com WAF ModSecurity e proteção Antibot
Autoscaler de pods horizontal (2-10 réplicas com base em CPU/memória)
Métricas Prometheus e rastreamento OpenTelemetry
Verificações de saúde com endpoints /health e /ready
Configurável via ConfigMap e Secrets

Para instruções detalhadas de implantação, solução de problemas e opções de configuração, veja deploy/kubernetes/README.md.

Modo Stdio (recomendado para uso local)

Se você instalou o pacote localmente (pip install -e .), Claude Code e VS Code podem iniciar o servidor como um subprocesso via stdio, sem Docker.

Exemplos de configuração para Claude Code, VS Code e Claude Desktop estão na seção dedicada: Integração MCP > Transporte Stdio.

Importante: use o caminho absoluto para o binário do virtualenv em command (obtenha com which bunkerweb-mcp). Comandos relativos podem falhar porque os clientes MCP não herdam o PATH do seu shell.

Integração MCP

O servidor suporta múltiplos protocolos de transporte para clientes MCP:

Transporte Stdio (Recomendado para Claude Code e VS Code)

Claude Code — `.mcp.json`

{
  "mcpServers": {
    "bunkerweb": {
      "type": "stdio",
      "command": "/path/to/your/.venv/bin/bunkerweb-mcp",
      "env": {
        "BUNKERWEB_BASE_URL": "http://<bunkerweb-api-host>:8888",
        "BUNKERWEB_API_TOKEN": "your-api-token-here"
      }
    }
  }
}

VS Code — `.mcp.json`

VS Code usa servers (não mcpServers):

{
  "servers": {
    "bunkerweb": {
      "type": "stdio",
      "command": "/path/to/your/.venv/bin/bunkerweb-mcp",
      "env": {
        "BUNKERWEB_BASE_URL": "http://<bunkerweb-api-host>:8888",
        "BUNKERWEB_API_TOKEN": "your-api-token-here"
      }
    }
  }
}

Adapte command ao seu caminho real do virtualenv (which bunkerweb-mcp após ativá-lo) e defina BUNKERWEB_BASE_URL para o endereço da sua API do BunkerWeb.

Para Claude Desktop, adicione o mesmo bloco ao seu claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json, Linux: ~/.config/Claude/claude_desktop_config.json) — o campo type pode ser omitido, pois o Desktop usa stdio por padrão:

{
  "mcpServers": {
    "bunkerweb": {
      "command": "/path/to/your/.venv/bin/bunkerweb-mcp",
      "env": {
        "BUNKERWEB_BASE_URL": "http://<bunkerweb-api-host>:8888",
        "BUNKERWEB_API_TOKEN": "your-api-token-here"
      }
    }
  }
}

Verifique se o servidor é detectado pelo Claude Code:

claude mcp list
# bunkerweb: /path/to/your/.venv/bin/bunkerweb-mcp (stdio)

Nota: O transporte stdio executa o servidor como um subprocesso comunicando-se via stdin/stdout — sem porta, sem Docker necessário.

Transporte HTTP (Para servidores remotos)

Aponte clientes compatíveis com MCP para o endpoint HTTP transmitível:

Transporte: HTTP transmitível
URL: http://localhost:8080/mcp

Configure em .mcp.json:

{
  "mcpServers": {
    "bunkerweb": {
      "url": "http://localhost:8080/mcp",
      "transport": "http"
    }
  }
}

Transportes legados

Transportes JSON-RPC legados permanecem disponíveis para fluxos de trabalho existentes:

HTTP: endpoint /rpc
WebSocket: endpoint /ws

Use o valor BUNKERWEB_WEBSOCKET_TOKEN quando um cliente exigir autenticação; o mesmo segredo protege todos os transportes.

Recursos MCP

O servidor expõe recursos somente leitura que podem ser referenciados em conversas do Claude Code usando a sintaxe @:

URI	Descrição
`@config://global`	Configuração global atual do BunkerWeb
`@logs://jobs`	Histórico de execução de jobs do agendador
`@bans://active`	Banimentos de IP atualmente ativos
`@instances://status`	Status de saúde de todas as instâncias

Exemplo de uso no Claude Code:

> Review @config://global and suggest security hardening improvements
> Check @bans://active for any suspicious patterns

Busca semântica

O servidor MCP usa uma ferramenta de busca semântica com IA para a documentação do BunkerWeb via um serviço de busca remoto.

⚠️ IMPORTANTE: A funcionalidade de busca foi externalizada para um serviço separado para melhor escalabilidade e tamanho de imagem reduzido. Ainda não está disponível ao público

Configuração

Adicione ao seu arquivo .env:

# Enable or disable search
SEARCH_MODE=disabled          # 'remote' or 'disabled'

# Search service URL
SEARCH_API_URL=https://search.example.com

# Request timeout
SEARCH_TIMEOUT=10.0

Uso com Docker Compose

O docker-compose.yml incluído desativa a busca porque nenhum contêiner de busca está incluído. Para usar um serviço de busca implantado, defina SEARCH_MODE=remote e forneça seu SEARCH_API_URL.

Desativar busca

Para executar o servidor MCP sem busca:

# In .env
SEARCH_MODE=disabled

Catálogo de ferramentas

Consulte o endpoint /tools para descritores JSON. As ferramentas disponíveis incluem:

Documentação e busca:

search_bunkerweb_docs: Busca semântica na documentação do BunkerWeb (query, limit, category)

Gerenciamento de instâncias:

ping: Verifica a acessibilidade da API
health: Lê a sonda de saúde da API
list_instances: Lista instâncias registradas do BunkerWeb
reload_instances: Recarrega a configuração em todas as instâncias (flag test suportada)
reload_instance: Recarrega uma instância específica (hostname, test opcional)

Segurança e banimentos:

list_bans: Recupera banimentos ativos
ban_ip: Bane um ou múltiplos IPs (array bans com ip, exp, reason, service)
unban_ip: Remove banimentos (array bans com ip, service opcional)

Serviços:

list_services: Lista serviços (flag with_drafts)
get_service: Busca detalhes de um serviço específico (service, full, methods, with_drafts)
delete_service: Exclui um serviço (service)

E mais 32 ferramentas integradas cobrindo autenticação, configurações, plugins, jobs e gerenciamento de cache.

Cada descritor agora carrega um campo prompt originado do catálogo de prompts. Clientes MCP podem exibir essas instruções curtas para manter respostas do assistente consistentes entre ferramentas.

Catálogo de prompts

O pacote inclui bunkerweb_mcp/data/tool_prompts.json, um conjunto selecionado de strings de orientação indexadas por nome de ferramenta. Na inicialização, o catálogo é carregado uma vez e injetado nos descritores de ferramentas, bem como em cada resposta RPC/WebSocket. Substitua a localização com BUNKERWEB_PROMPT_CATALOG se precisar de texto personalizado.

Uso JSON-RPC

Exemplo HTTP

curl -X POST http://localhost:8080/rpc \
  -H "Content-Type: application/json" \
  -H "X-MCP-Token: $BUNKERWEB_WEBSOCKET_TOKEN" \
  -d '{"id":"1","tool":"list_instances","params":{}}

Exemplo WebSocket (websocat)

echo '{"id":"ping-1","tool":"ping","params":{}}' \
  | websocat -H "Sec-WebSocket-Protocol: json" ws://localhost:8080/ws?token=$BUNKERWEB_WEBSOCKET_TOKEN

Testes

pip install -r requirements-dev.txt
pytest

Estrutura do projeto

src/bunkerweb_mcp/
├─ main.py                # FastAPI app + JSON-RPC endpoints
├─ cli.py                 # CLI entry point for stdio mode
├─ mcp_adapter.py         # MCP server integration
├─ client.py              # Resilient async client for BunkerWeb
├─ tools/                 # MCP tools with strict validation
├─ config.py              # Environment-driven settings
├─ prompt_catalog.py      # Prompt loading helpers
├─ exceptions.py          # Domain-specific exceptions
├─ search_client.py       # Lightweight HTTP client for search service
├─ schemas/               # Pydantic models for requests/responses
└─ utils/logging.py       # Structured logging helpers

src/bunkerweb_mcp/data/
└─ tool_prompts.json      # Default tool prompts exposed to MCP clients

Observabilidade

O servidor MCP inclui recursos abrangentes de observabilidade:

Métricas Prometheus

As métricas são expostas em GET /metrics no formato Prometheus:

curl http://localhost:8080/metrics

Métricas disponíveis:

mcp_tool_calls_total{tool_name, status} - Total de chamadas de ferramentas por status
mcp_tool_duration_seconds - Histograma de duração de execução de ferramentas
mcp_active_websockets - Conexões WebSocket ativas
bunkerweb_api_requests_total{endpoint, method, status} - Solicitações à API do BunkerWeb
bunkerweb_api_errors_total{endpoint, error_type} - Erros de API
mcp_cache_hits_total{cache_type} - Acertos de cache
mcp_cache_misses_total{cache_type} - Erros de cache
mcp_search_queries_total{mode, status} - Consultas de busca

Rastreamento OpenTelemetry

Rastreamento distribuído com instrumentação automática:

# Configure tracing via environment variables
OTEL_TRACING_ENABLED=true
OTEL_EXPORTER_OTLP_ENDPOINT=http://jaeger:4317

Os rastreamentos são gerados automaticamente para:

Solicitações HTTP (FastAPI)
Chamadas de API de saída (httpx)
Execuções de ferramentas

Veja os rastreamentos na interface Jaeger em http://localhost:16686

Verificações de saúde

Sonda de vivacidade - Verifica se o servidor está em execução:

curl http://localhost:8080/health
# Response: {"status": "healthy", "timestamp": "..."}

Sonda de prontidão - Verifica se o servidor pode lidar com solicitações:

curl http://localhost:8080/ready
# Response: {"status": "ready", "checks": {"bunkerweb_api": true, "search_service": true}, "timestamp": "..."}

Configuração Kubernetes:

livenessProbe:
  httpGet:
    path: /health
    port: 8080
  initialDelaySeconds: 10
  periodSeconds: 30

readinessProbe:
  httpGet:
    path: /ready
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 10

Pilha de monitoramento

Inicie a pilha completa de observabilidade (Prometheus, Grafana, Jaeger):

docker-compose -f docker-compose.monitoring.yml up -d

Acesso:

Prometheus: http://localhost:9090
Grafana: http://localhost:3000 (admin/admin)
Interface Jaeger: http://localhost:16686

Painel Grafana

Painel pré-configurado com 8 painéis:

Taxa de chamadas de ferramentas
Taxa de sucesso de ferramentas
WebSockets ativos
Latência de ferramentas (P50/P95/P99)
Erros da API do BunkerWeb
Taxa de acertos de cache
Latência da API do BunkerWeb
Contagem de resultados de busca

Importe de deploy/grafana/dashboards/mcp-bunkerweb.json

Alertas

Alertas Prometheus pré-configurados em deploy/prometheus/alerts.yml:

Alta taxa de erro de ferramentas (>10%)
Alta latência (P95 > 5s)
Erros da API do BunkerWeb
Baixa taxa de acertos de cache (<30%)
Problemas de saúde do serviço

Registro de log estruturado

Os logs são emitidos como JSON de linha única para ingestão por processadores de log. Cada log tool_call carrega um objeto metrics com o nome da ferramenta e duration_seconds para rastreamento de latência. Ajuste BUNKERWEB_LOG_LEVEL conforme necessário.

Veja docs/OBSERVABILITY.md para o guia completo de observabilidade.

Ajuste de Desempenho

O servidor MCP inclui várias otimizações de desempenho introduzidas no Sprint 2:

Camada de Cache

Habilitada por padrão - Armazena em cache operações de API somente leitura para reduzir latência e carga na API do BunkerWeb.

# Configure in .env
CACHE_ENABLED=true  # Default: true

TTLs de Cache (configurados em src/bunkerweb_mcp/cache.py):

list_services: 300s (5 minutos)
global_config: 600s (10 minutos)
list_instances: 60s (1 minuto)
list_bans: 30s (30 segundos)

O cache é invalidado automaticamente em operações de escrita (criar, atualizar, excluir).

Limitação de Taxa

Desabilitada por padrão - Proteção opcional contra inundações de requisições.

# Enable in .env for production
RATE_LIMIT_ENABLED=true  # Default: false
RATE_LIMIT_TOOLS=30/minute
RATE_LIMIT_RPC=100/minute
RATE_LIMIT_WS=500/minute

Quando habilitada, exceder os limites de taxa retorna HTTP 429 ou erro WebSocket.

Implantação Multi-Worker

Para implantações de alto tráfego, aumente os workers do Uvicorn:

# Docker environment variable
WORKERS=4  # Default: 1

# Local development
uvicorn bunkerweb_mcp.main:app --workers 4

Alocação de recursos Kubernetes:

resources:
  requests:
    cpu: "100m"      # Baseline for single worker
    memory: "256Mi"
  limits:
    cpu: "500m"      # Increase for multiple workers
    memory: "512Mi"

Recomendação: Defina WORKERS como contagem de CPUs × 2 para implantações em produção.

Teste de Carga

Verifique o desempenho com o conjunto de testes Locust incluído:

# Install locust
pip install -r requirements-dev.txt

# Run load test
./scripts/load-test.sh

# Or customize parameters
HOST=http://localhost:8080 USERS=200 RUN_TIME=10m ./scripts/load-test.sh

Metas de desempenho (Sprint 2):

Taxa de transferência: > 1000 req/s sustentados
Latência P95: < 100ms
Taxa de erro: 0% com 100 usuários simultâneos

Os relatórios são gerados em ./load-test-reports/.

Dicas de Desempenho

Habilite o cache (CACHE_ENABLED=true) para cargas de trabalho com muitas leituras
Desabilite a limitação de taxa por padrão (defina RATE_LIMIT_ENABLED=false) a menos que esteja sob ataque
Use múltiplos workers (WORKERS=4) apenas para alto tráfego (>100 req/s)
Monitore a taxa de acerto do cache por meio de logs para ajustar os TTLs
Aumente os recursos no Kubernetes com base nos resultados dos testes de carga

Notas de Segurança

Proteção contra Rebinding de DNS (Importante!)

O servidor MCP inclui proteção integrada contra rebinding de DNS. Você deve configurar os hosts permitidos:

# In your .env file - REQUIRED for production
MCP_ENABLE_DNS_REBINDING_PROTECTION=true
MCP_ALLOWED_HOSTS=yourdomain.com,yourdomain.com:443,internal-host,internal-host:8085

Crítico: Inclua ambos o nome do host sozinho e com a porta (ex.: apps,apps:8085).

Consulte docs/security.md para um guia de configuração detalhado.

Outras Boas Práticas de Segurança

Preencha BUNKERWEB_API_TOKEN quando a API de destino exigir autenticação.
Ao usar autenticação HTTP Basic, defina BUNKERWEB_BASIC_USERNAME e BUNKERWEB_BASIC_PASSWORD por meio do gerenciamento de segredos.
Defina BUNKERWEB_WEBSOCKET_TOKEN para exigir um segredo compartilhado para ambos /rpc e /ws.
Garanta que o servidor MCP execute em uma rede confiável; a API pode modificar o estado do BunkerWeb.
Use HTTPS por meio de proxy reverso (nginx, Traefik ou BunkerWeb) em produção.

Documentação

Documentação do Projeto

Registros de Decisões de Arquitetura (ADR) - Principais decisões arquiteturais com contexto e justificativa
Guia de Observabilidade - Guia completo para métricas, rastreamento e monitoramento (Sprint 4)
Guia de Segurança - Proteção contra rebinding de DNS e boas práticas de segurança
Guia de Desenvolvimento com Claude - Experiência em BunkerWeb para Claude Code

Documentação da API

Todos os manipuladores de ferramentas incluem docstrings abrangentes no estilo Google, com:

Descrição detalhada da funcionalidade
Especificações de parâmetros com tipos e padrões
Documentação do formato do valor de retorno
Orientação sobre tratamento de exceções
Exemplos de uso

Exemplo: src/bunkerweb_mcp/tools/registry.py registra todos os manipuladores integrados.

Decisões de Arquitetura

As principais escolhas arquiteturais estão documentadas nos ADRs:

ADR-0001: SDK FastMCP - Implementação do protocolo MCP
ADR-0002: Externalizar Busca - Arquitetura do serviço de busca
ADR-0003: Pydantic V2 - Estrutura de validação de dados
ADR-0004: HTTPX Assíncrono - Escolha do cliente HTTP

Contribuindo

Consulte os ADRs individuais para orientação arquitetural ao propor alterações. Todos os novos manipuladores de ferramentas devem incluir:

Docstrings completos no estilo Google
Testes unitários com cobertura >80%
Atualizações nos ADRs relevantes se houver mudanças arquiteturais envolvidas

Licença

MIT

BunkerWeb MCP

Documentação

Servidor MCP BunkerWeb (Python)

Início rápido com Claude Code

Recursos

Requisitos

Instalação

A partir do código-fonte

A partir do PyPI (quando publicado)

Contexto de desenvolvimento

Configuração

Executando o servidor

Modo HTTP (recomendado)

docker-compose

Local (uvicorn)

Docker

Kubernetes

Modo Stdio (recomendado para uso local)

Integração MCP

Transporte Stdio (Recomendado para Claude Code e VS Code)

Claude Code — .mcp.json

VS Code — .mcp.json

Transporte HTTP (Para servidores remotos)

Transportes legados

Recursos MCP

Busca semântica

Configuração

Uso com Docker Compose

Desativar busca

Catálogo de ferramentas

Catálogo de prompts

Uso JSON-RPC

Exemplo HTTP

Exemplo WebSocket (websocat)

Testes

Estrutura do projeto

Observabilidade

Métricas Prometheus

Rastreamento OpenTelemetry

Verificações de saúde

Pilha de monitoramento

Painel Grafana

Alertas

Registro de log estruturado

Ajuste de Desempenho

Camada de Cache

Limitação de Taxa

Implantação Multi-Worker

Teste de Carga

Dicas de Desempenho

Notas de Segurança

Proteção contra Rebinding de DNS (Importante!)

Outras Boas Práticas de Segurança

Documentação

Documentação do Projeto

Documentação da API

Decisões de Arquitetura

Contribuindo

Licença

Claude Code — `.mcp.json`

VS Code — `.mcp.json`