BunkerWeb MCP

Servidor MCP oficial para gestionar despliegues de BunkerWeb desde asistentes de IA, incluyendo instancias, servicios, configuración, bloqueos, plugins, trabajos y caché.

GitHub

Prueba este MCPPatrocinado

Documentación

Servidor MCP de BunkerWeb (Python)

Un servidor MCP listo para producción que expone la API interna de BunkerWeb a modelos de lenguaje grandes mediante una interfaz de herramientas restringida. El servidor proporciona endpoints JSON-RPC tanto HTTP (para pruebas) como WebSocket (para clientes MCP), validación estricta de entrada y un cliente asíncrono resiliente con reintentos.

Sitio web de BunkerWeb · Documentación

Inicio rápido con 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/

Características

43 herramientas API integradas, más búsqueda semántica opcional
🔍 Búsqueda semántica impulsada por IA en la documentación de BunkerWeb mediante servicio de búsqueda remoto (opcional, configurable)
Recursos MCP para acceso de solo lectura a datos (configuración global, registros de trabajos, baneos activos, estado de instancias)
Múltiples transportes: Stdio (para Claude Code), HTTP, WebSocket
Integración oficial del SDK MCP con FastMCP para clientes compatibles (Claude Code, VS Code, Claude Desktop)
Cliente asíncrono robusto con reintentos/retroceso y modelos Pydantic tipados
Catálogo de indicaciones que proporciona orientación contextual para cada herramienta
Aplicación FastAPI que expone endpoints JSON-RPC HTTP /rpc y WebSocket /ws (heredados)
Punto de entrada CLI (bunkerweb-mcp) para integración sencilla
Documentación completa que incluye CLAUDE.md con experiencia en BunkerWeb
Autenticación opcional mediante token de secreto compartido o token portador de API
Registro JSON estructurado con métricas para observabilidad
Pruebas unitarias con transporte HTTP simulado
Manifiestos de implementación para Docker y Kubernetes
⚡ Optimizaciones de rendimiento (Sprint 2):
- Capa de caché con TTL configurables para operaciones de solo lectura
- Limitación de velocidad opcional para proteger contra inundaciones de solicitudes
- Soporte multi-trabajador para implementaciones de alto tráfico
- Suite de pruebas de carga con Locust para validación de rendimiento

Requisitos

Acceso a una API de BunkerWeb (probado con BunkerWeb 1.6.13 y código de desarrollo actual 1.6.14~rc1; http://localhost:8888 por defecto)

Instalación

Desde el código fuente

# 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

Desde PyPI (cuando se publique)

pip install bunkerweb-mcp

Actualice .env con su URL base de API y un token o credenciales básicas si es necesario.

Contexto de desarrollo

El repositorio incluye un archivo CLAUDE.md que proporciona a Claude Code experiencia integral en BunkerWeb y mejores prácticas. Este archivo se carga automáticamente al trabajar en este repositorio con Claude Code, brindando al asistente contexto sobre:

Arquitectura y componentes de BunkerWeb
Configuración de módulos de seguridad (ModSecurity, Antibot, etc.)
Flujos de trabajo operativos comunes
Pautas de solución de problemas
Mejores prácticas para implementaciones de producción

Configuración

Todos los ajustes son configurables mediante variables de entorno (consulte .env.example):

Variable	Descripción	Predeterminado
`BUNKERWEB_BASE_URL`	URL base de la API de BunkerWeb	`http://localhost:8888`
`BUNKERWEB_API_TOKEN`	Token portador estático opcional	vacío
`BUNKERWEB_BASIC_USERNAME`	Nombre de usuario opcional para autenticación básica HTTP	vacío
`BUNKERWEB_BASIC_PASSWORD`	Contraseña opcional para autenticación básica HTTP	vacío
`BUNKERWEB_REQUEST_TIMEOUT_SECONDS`	Tiempo de espera HTTP en segundos	`30`
`BUNKERWEB_MAX_RETRIES`	Intentos de reintento para fallos transitorios	`3`
`BUNKERWEB_RETRY_BACKOFF_INITIAL`	Retraso inicial de retroceso (segundos)	`0.5`
`BUNKERWEB_RETRY_BACKOFF_MAX`	Retraso máximo de retroceso (segundos)	`5.0`
`BUNKERWEB_WEBSOCKET_TOKEN`	Secreto compartido requerido por `/ws` y `/rpc`	vacío
`BUNKERWEB_LOG_LEVEL`	Nivel de registro	`INFO`
`BUNKERWEB_PROMPT_CATALOG`	Archivo JSON opcional con indicaciones por herramienta	catálogo integrado
`RATE_LIMIT_ENABLED`	Habilitar limitación de velocidad (Sprint 2)	`false`
`RATE_LIMIT_TOOLS`	Límite de velocidad para el endpoint /tools	`30/minute`
`RATE_LIMIT_RPC`	Límite de velocidad para el endpoint /rpc	`100/minute`
`RATE_LIMIT_WS`	Límite de velocidad para mensajes WebSocket	`500/minute`
`CACHE_ENABLED`	Habilitar capa de caché (Sprint 2)	`true`
`WORKERS`	Número de trabajadores de Uvicorn (solo Docker)	`1`

Ejecutar el servidor

Modo HTTP (recomendado)

docker-compose

docker compose up --build

El archivo compose inicia una pila de demostración BunkerWeb 1.6.13 y conecta el servidor MCP a su 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

Implemente en Kubernetes con integración del controlador de ingreso de 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

Características clave:

Controlador de ingreso de BunkerWeb con WAF ModSecurity y protección Antibot
Autoscalador de pods horizontal (2-10 réplicas basado en CPU/memoria)
Métricas de Prometheus y rastreo de OpenTelemetry
Verificaciones de salud con endpoints /health y /ready
Configurable mediante ConfigMap y Secrets

Para instrucciones detalladas de implementación, solución de problemas y opciones de configuración, consulte deploy/kubernetes/README.md.

Modo Stdio (recomendado para uso local)

Si instaló el paquete localmente (pip install -e .), Claude Code y VS Code pueden iniciar el servidor como subproceso mediante stdio, sin Docker.

Ejemplos de configuración para Claude Code, VS Code y Claude Desktop están en la sección dedicada: Integración MCP > Transporte Stdio.

Importante: use la ruta absoluta al binario del entorno virtual en command (obténgala con which bunkerweb-mcp). Los comandos relativos pueden fallar porque los clientes MCP no heredan el PATH de su shell.

Integración MCP

El servidor admite múltiples protocolos de transporte para clientes MCP:

Transporte Stdio (Recomendado para Claude Code y 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 (no 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 a su ruta real del entorno virtual (which bunkerweb-mcp después de activarlo) y establezca BUNKERWEB_BASE_URL a la dirección de su API de BunkerWeb.

Para Claude Desktop, agregue el mismo bloque a su claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json, Linux: ~/.config/Claude/claude_desktop_config.json) — el campo type puede omitirse ya que Desktop usa stdio por defecto:

{
  "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 que el servidor sea detectado por Claude Code:

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

Nota: El transporte stdio ejecuta el servidor como subproceso que se comunica mediante stdin/stdout — sin puerto, sin Docker.

Transporte HTTP (Para servidores remotos)

Apunte clientes compatibles con MCP al endpoint HTTP transmisible:

Transporte: HTTP transmisible
URL: http://localhost:8080/mcp

Configure en .mcp.json:

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

Transportes heredados

Los transportes JSON-RPC heredados permanecen disponibles para flujos de trabajo existentes:

HTTP: endpoint /rpc
WebSocket: endpoint /ws

Use el valor BUNKERWEB_WEBSOCKET_TOKEN cuando un cliente requiera autenticación; el mismo secreto protege todos los transportes.

Recursos MCP

El servidor expone recursos de solo lectura que pueden referenciarse en conversaciones de Claude Code usando la sintaxis @:

URI	Descripción
`@config://global`	Configuración global actual de BunkerWeb
`@logs://jobs`	Historial de ejecución de trabajos del programador
`@bans://active`	Baneos de IP actualmente activos
`@instances://status`	Estado de salud de todas las instancias

Ejemplo de uso en Claude Code:

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

Búsqueda semántica

El servidor MCP usa una herramienta de búsqueda semántica impulsada por IA para la documentación de BunkerWeb mediante un servicio de búsqueda remoto.

⚠️ IMPORTANTE: La funcionalidad de búsqueda se ha externalizado a un servicio separado para mejor escalabilidad y tamaño de imagen reducido. Aún no está disponible públicamente

Configuración

Agregue a su archivo .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 con Docker Compose

El docker-compose.yml incluido deshabilita la búsqueda porque no se incluye un contenedor de búsqueda. Para usar un servicio de búsqueda implementado, establezca SEARCH_MODE=remote y proporcione su SEARCH_API_URL.

Deshabilitar búsqueda

Para ejecutar el servidor MCP sin búsqueda:

# In .env
SEARCH_MODE=disabled

Catálogo de herramientas

Consulte el endpoint /tools para descriptores JSON. Las herramientas disponibles incluyen:

Documentación y búsqueda:

search_bunkerweb_docs: Búsqueda semántica en la documentación de BunkerWeb (query, limit, category)

Gestión de instancias:

ping: Verificar accesibilidad de la API
health: Leer la sonda de salud de la API
list_instances: Listar instancias registradas de BunkerWeb
reload_instances: Recargar configuración en todas las instancias (se admite el indicador test)
reload_instance: Recargar una instancia específica (hostname, test opcional)

Seguridad y baneos:

list_bans: Recuperar baneos activos
ban_ip: Banear una o múltiples IPs (matriz bans con ip, exp, reason, service)
unban_ip: Eliminar baneos (matriz bans con ip, service opcional)

Servicios:

list_services: Listar servicios (indicador with_drafts)
get_service: Obtener detalles de un servicio específico (service, full, methods, with_drafts)
delete_service: Eliminar un servicio (service)

Y 32 herramientas integradas más que cubren autenticación, configuraciones, complementos, trabajos y gestión de caché.

Cada descriptor ahora lleva un campo prompt proveniente del catálogo de indicaciones. Los clientes MCP pueden mostrar estas instrucciones breves para mantener respuestas consistentes del asistente en todas las herramientas.

Catálogo de indicaciones

El paquete incluye bunkerweb_mcp/data/tool_prompts.json, un conjunto curado de cadenas de orientación claveadas por nombre de herramienta. Al inicio, el catálogo se carga una vez y se inyecta en los descriptores de herramientas así como en cada respuesta RPC/WebSocket. Sobrescriba la ubicación con BUNKERWEB_PROMPT_CATALOG si necesita redacción personalizada.

Uso de JSON-RPC

Ejemplo 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":{}}

Ejemplo WebSocket (websocat)

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

Pruebas

pip install -r requirements-dev.txt
pytest

Estructura del proyecto

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

Observabilidad

El servidor MCP incluye características integrales de observabilidad:

Métricas de Prometheus

Las métricas se exponen en GET /metrics en formato Prometheus:

curl http://localhost:8080/metrics

Métricas disponibles:

mcp_tool_calls_total{tool_name, status} - Total de llamadas a herramientas por estado
mcp_tool_duration_seconds - Histograma de duración de ejecución de herramientas
mcp_active_websockets - Conexiones WebSocket activas
bunkerweb_api_requests_total{endpoint, method, status} - Solicitudes a la API de BunkerWeb
bunkerweb_api_errors_total{endpoint, error_type} - Errores de API
mcp_cache_hits_total{cache_type} - Aciertos de caché
mcp_cache_misses_total{cache_type} - Fallos de caché
mcp_search_queries_total{mode, status} - Consultas de búsqueda

Rastreo de OpenTelemetry

Rastreo distribuido con instrumentación automática:

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

Los rastreos se generan automáticamente para:

Solicitudes HTTP (FastAPI)
Llamadas API salientes (httpx)
Ejecuciones de herramientas

Vea los rastreos en la interfaz de Jaeger en http://localhost:16686

Verificaciones de salud

Sonda de actividad - Verifica si el servidor está ejecutándose:

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

Sonda de preparación - Verifica si el servidor puede manejar solicitudes:

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

Configuración de Kubernetes:

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

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

Pila de monitoreo

Inicie la pila completa de observabilidad (Prometheus, Grafana, Jaeger):

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

Acceso:

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

Panel de Grafana

Panel preconstruido con 8 paneles:

Tasa de llamadas a herramientas
Tasa de éxito de herramientas
WebSockets activos
Latencia de herramientas (P50/P95/P99)
Errores de API de BunkerWeb
Tasa de aciertos de caché
Latencia de API de BunkerWeb
Conteo de resultados de búsqueda

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

Alertas

Alertas de Prometheus preconfiguradas en deploy/prometheus/alerts.yml:

Alta tasa de errores de herramientas (>10%)
Alta latencia (P95 > 5s)
Errores de API de BunkerWeb
Baja tasa de aciertos de caché (<30%)
Problemas de salud del servicio

Registro estructurado

Los registros se emiten como JSON de una sola línea para ingestión por procesadores de registros. Cada registro tool_call lleva un objeto metrics con el nombre de la herramienta y duration_seconds para seguimiento de latencia. Ajuste BUNKERWEB_LOG_LEVEL según sea necesario.

Consulte docs/OBSERVABILITY.md para la guía completa de observabilidad.

Ajuste de Rendimiento

El servidor MCP incluye varias optimizaciones de rendimiento introducidas en el Sprint 2:

Capa de Caché

Habilitada por defecto - Almacena en caché operaciones de API de solo lectura para reducir la latencia y la carga en la API de BunkerWeb.

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

TTLs de caché (configurados en 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)

La caché se invalida automáticamente en operaciones de escritura (crear, actualizar, eliminar).

Límite de Peticiones

Deshabilitado por defecto - Protección opcional contra inundaciones de peticiones.

# 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

Cuando está habilitado, superar los límites de peticiones devuelve HTTP 429 o un error de WebSocket.

Despliegue Multi-Trabajador

Para despliegues de alto tráfico, aumente los trabajadores de Uvicorn:

# Docker environment variable
WORKERS=4  # Default: 1

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

Asignación de recursos en Kubernetes:

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

Recomendación: Establezca WORKERS a número de CPUs × 2 para despliegues de producción.

Pruebas de Carga

Verifique el rendimiento con el conjunto de pruebas Locust incluido:

# 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

Objetivos de rendimiento (Sprint 2):

Rendimiento: > 1000 req/s sostenidos
Latencia P95: < 100ms
Tasa de error: 0% con 100 usuarios concurrentes

Los informes se generan en ./load-test-reports/.

Consejos de Rendimiento

Habilite la caché (CACHE_ENABLED=true) para cargas de trabajo con muchas lecturas
Deshabilite el límite de peticiones por defecto (establezca RATE_LIMIT_ENABLED=false) a menos que esté bajo ataque
Use múltiples trabajadores (WORKERS=4) solo para alto tráfico (>100 req/s)
Supervise la tasa de aciertos de caché mediante registros para ajustar los TTLs
Aumente los recursos en Kubernetes según los resultados de las pruebas de carga

Notas de Seguridad

Protección contra Rebinding de DNS (¡Importante!)

El servidor MCP incluye protección integrada contra rebinding de DNS. Debe configurar los 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: Incluya tanto el nombre de host solo como con puerto (por ejemplo, apps,apps:8085).

Consulte docs/security.md para una guía de configuración detallada.

Otras Buenas Prácticas de Seguridad

Complete BUNKERWEB_API_TOKEN cuando la API de destino requiera autenticación.
Al usar autenticación básica HTTP, establezca BUNKERWEB_BASIC_USERNAME y BUNKERWEB_BASIC_PASSWORD mediante gestión de secretos.
Establezca BUNKERWEB_WEBSOCKET_TOKEN para requerir un secreto compartido tanto para /rpc como para /ws.
Asegúrese de que el servidor MCP se ejecute en una red de confianza; la API puede modificar el estado de BunkerWeb.
Use HTTPS mediante proxy inverso (nginx, Traefik o BunkerWeb) en producción.

Documentación

Documentación del Proyecto

Registros de Decisiones de Arquitectura (ADR) - Decisiones arquitectónicas principales con contexto y justificación
Guía de Observabilidad - Guía completa de métricas, trazabilidad y monitoreo (Sprint 4)
Guía de Seguridad - Protección contra rebinding de DNS y mejores prácticas de seguridad
Guía de Desarrollo para Claude - Experiencia en BunkerWeb para Claude Code

Documentación de la API

Todos los manejadores de herramientas incluyen docstrings completos estilo Google con:

Descripción detallada de funcionalidad
Especificaciones de parámetros con tipos y valores predeterminados
Documentación del formato del valor de retorno
Guía de manejo de excepciones
Ejemplos de uso

Ejemplo: src/bunkerweb_mcp/tools/registry.py registra todos los manejadores integrados.

Decisiones de Arquitectura

Las elecciones arquitectónicas clave están documentadas en los ADRs:

ADR-0001: SDK FastMCP - Implementación del protocolo MCP
ADR-0002: Externalizar Búsqueda - Arquitectura del servicio de búsqueda
ADR-0003: Pydantic V2 - Marco de validación de datos
ADR-0004: HTTPX Asíncrono - Elección del cliente HTTP

Contribuciones

Consulte los ADRs individuales para obtener orientación arquitectónica al proponer cambios. Todos los nuevos manejadores de herramientas deben incluir:

Docstrings completos estilo Google
Pruebas unitarias con >80% de cobertura
Actualizaciones a los ADRs relevantes si se involucran cambios arquitectónicos

Licencia

MIT

BunkerWeb MCP

Documentación

Servidor MCP de BunkerWeb (Python)

Inicio rápido con Claude Code

Características

Requisitos

Instalación

Desde el código fuente

Desde PyPI (cuando se publique)

Contexto de desarrollo

Configuración

Ejecutar el servidor

Modo HTTP (recomendado)

docker-compose

Local (uvicorn)

Docker

Kubernetes

Modo Stdio (recomendado para uso local)

Integración MCP

Transporte Stdio (Recomendado para Claude Code y VS Code)

Claude Code — .mcp.json

VS Code — .mcp.json

Transporte HTTP (Para servidores remotos)

Transportes heredados

Recursos MCP

Búsqueda semántica

Configuración

Uso con Docker Compose

Deshabilitar búsqueda

Catálogo de herramientas

Catálogo de indicaciones

Uso de JSON-RPC

Ejemplo HTTP

Ejemplo WebSocket (websocat)

Pruebas

Estructura del proyecto

Observabilidad

Métricas de Prometheus

Rastreo de OpenTelemetry

Verificaciones de salud

Pila de monitoreo

Panel de Grafana

Alertas

Registro estructurado

Ajuste de Rendimiento

Capa de Caché

Límite de Peticiones

Despliegue Multi-Trabajador

Pruebas de Carga

Consejos de Rendimiento

Notas de Seguridad

Protección contra Rebinding de DNS (¡Importante!)

Otras Buenas Prácticas de Seguridad

Documentación

Documentación del Proyecto

Documentación de la API

Decisiones de Arquitectura

Contribuciones

Licencia

Claude Code — `.mcp.json`

VS Code — `.mcp.json`