Wazuh MCP Server

Un servidor basado en Rust que integra el sistema SIEM de Wazuh con aplicaciones compatibles con MCP.

Documentación

Wazuh MCP Server - Habla con tu SIEM

Un servidor basado en Rust diseñado para cerrar la brecha entre un sistema Wazuh de Gestión de Información y Eventos de Seguridad (SIEM) y aplicaciones que requieren datos de seguridad contextuales, específicamente adaptado para la Integración con Claude Desktop mediante el Protocolo de Contexto de Modelo (MCP).

Descripción General

Los asistentes de IA modernos como Claude pueden beneficiarse significativamente del contexto en tiempo real sobre el entorno de seguridad del usuario. El Wazuh MCP Server cierra esta brecha proporcionando acceso integral a los datos SIEM de Wazuh a través de interacciones en lenguaje natural.

Este servidor transforma las respuestas complejas de la API de Wazuh a un formato compatible con MCP, permitiendo que los asistentes de IA accedan a:

Alertas y Eventos de Seguridad del Wazuh Indexer para detección de amenazas y respuesta a incidentes
Gestión y Monitoreo de Agentes incluyendo estado de salud, procesos del sistema y puertos de red
Datos de Evaluación de Vulnerabilidades para gestión de riesgos y priorización de parches
Reglas de Seguridad y Configuración para optimización de detección y validación de cumplimiento
Estadísticas del Sistema y Rendimiento para monitoreo operativo y pistas de auditoría
Capacidades de Análisis de Registros y Forense para investigación de incidentes y reportes de cumplimiento
Salud y Gestión del Clúster para requisitos de confiabilidad y disponibilidad de la infraestructura
Monitoreo de Cumplimiento y Análisis de Brechas para marcos regulatorios como PCI-DSS, HIPAA, SOX y GDPR

En lugar de requerir llamadas API manuales o consultas complejas, los equipos de seguridad ahora pueden hacer preguntas en lenguaje natural como "Muéstrame vulnerabilidades críticas en servidores web", "¿Qué procesos se están ejecutando en el agente 001?" o "¿Estamos cumpliendo con los requisitos de registro de PCI-DSS?" y recibir datos estructurados y accionables de su implementación de Wazuh.

Este enfoque es particularmente valioso para equipos de cumplimiento que necesitan evaluar rápidamente la postura de seguridad, identificar brechas en la cobertura de monitoreo, validar la efectividad de las reglas y generar evidencia para requisitos de auditoría en infraestructura distribuida.

Casos de Uso de Ejemplo

El Wazuh MCP Server proporciona acceso directo a los datos de seguridad de Wazuh a través de interacciones en lenguaje natural, habilitando varios casos de uso prácticos:

Análisis de Alertas de Seguridad

Triaje e Investigación de Alertas: Consulta alertas de seguridad recientes con get_wazuh_alert_summary para identificar y priorizar rápidamente amenazas que requieren atención inmediata.
Reconocimiento de Patrones de Alertas: Analiza tendencias y patrones de alertas para identificar problemas de seguridad recurrentes o posibles campañas de ataque.

Gestión de Vulnerabilidades

Evaluación de Vulnerabilidades de Agentes: Usa get_wazuh_vulnerability_summary y get_wazuh_critical_vulnerabilities para evaluar la postura de seguridad de agentes específicos y priorizar esfuerzos de parcheo.
Priorización de Vulnerabilidades Basada en Riesgo: Correlaciona datos de vulnerabilidades con la criticidad y exposición del agente para enfocar los esfuerzos de remediación.

Monitoreo del Sistema y Forense

Análisis de Procesos: Investiga procesos en ejecución en agentes usando get_wazuh_agent_processes para caza de amenazas y análisis del sistema.
Evaluación de Seguridad de Red: Monitorea puertos abiertos y servicios de red con get_wazuh_agent_ports para identificar posibles vectores de ataque.
Monitoreo de Salud de Agentes: Rastrea el estado y la conectividad de los agentes usando get_wazuh_running_agents para asegurar una cobertura de seguridad integral.

Inteligencia de Operaciones de Seguridad

Análisis de Efectividad de Reglas: Revisa y analiza reglas de detección de seguridad con get_wazuh_rules_summary para optimizar las capacidades de detección.
Monitoreo de Rendimiento del Manager: Rastrea el rendimiento y las estadísticas del sistema usando herramientas como get_wazuh_weekly_stats, get_wazuh_remoted_stats y get_wazuh_log_collector_stats.
Gestión de Salud del Clúster: Monitorea el estado del clúster de Wazuh con get_wazuh_cluster_health y get_wazuh_cluster_nodes para confiabilidad operativa.

Respuesta a Incidentes y Forense

Análisis de Registros: Busca y analiza registros del manager usando search_wazuh_manager_logs y get_wazuh_manager_error_logs para investigación de incidentes.
Investigación Específica de Agentes: Combina múltiples herramientas para construir perfiles integrales de agentes específicos durante incidentes de seguridad.
Consultas de Seguridad en Lenguaje Natural: Haz preguntas complejas de seguridad en lenguaje natural y recibe datos estructurados de múltiples componentes de Wazuh.

Eficiencia Operativa

Reportes Automatizados: Genera informes y resúmenes de seguridad a través de interfaces conversacionales sin llamadas API manuales.
Análisis Multi-Componente: Correlaciona datos tanto del Wazuh Indexer (alertas) como del Wazuh Manager (agentes, reglas, vulnerabilidades) para obtener información de seguridad integral.
Operaciones de Seguridad Multilingües: Accede a datos de Wazuh y recibe información en múltiples idiomas para equipos de seguridad globales.

Recopilación de Inteligencia de Amenazas y Respuesta

Para capacidades mejoradas de inteligencia de amenazas y respuesta a incidentes, el Wazuh MCP Server puede combinarse con servidores MCP de seguridad complementarios:

Servidor	Descripción
Cortex MCP Server	Análisis de artefactos y enriquecimiento de IOC mediante más de 140 analizadores
TheHive MCP Server	Gestión de casos y orquestación de respuesta a incidentes
MISP MCP Server	Intercambio de inteligencia de amenazas y consulta de IOC

Capacidades Mejoradas con Integración de Cortex:

Análisis de Artefactos: Analiza automáticamente archivos sospechosos, URLs, dominios y direcciones IP encontrados en alertas de Wazuh usando los más de 140 analizadores de Cortex
Enriquecimiento de IOC: Enriquece indicadores de compromiso (IOC) de alertas de Wazuh con inteligencia de amenazas de múltiples fuentes incluyendo VirusTotal, Shodan, MISP y más
Caza de Amenazas Automatizada: Combina las capacidades de detección de Wazuh con los motores de análisis de Cortex para investigar y clasificar amenazas automáticamente
Inteligencia Multi-Fuente: Aprovecha analizadores para verificaciones de reputación, análisis de malware, análisis de dominios y análisis de comportamiento
Orquestación de Respuesta: Usa resultados de análisis para informar acciones de respuesta automatizadas y priorización de alertas

Capacidades Mejoradas con Integración de TheHive:

Creación de Casos: Crea automáticamente casos en TheHive a partir de alertas de Wazuh para seguimiento estructurado de incidentes
Correlación de Alertas: Vincula alertas relacionadas de Wazuh a casos existentes para líneas de tiempo integrales de incidentes
Gestión de Tareas: Crea y rastrea tareas de investigación basadas en la severidad y tipo de alerta
Gestión de Observables: Extrae y gestiona IOC como observables dentro de investigaciones de casos
Colaboración: Habilita la colaboración del equipo de seguridad en incidentes detectados por Wazuh

Capacidades Mejoradas con Integración de MISP:

Consulta de IOC: Verifica si los indicadores de alertas de Wazuh son conocidos en tu base de datos de inteligencia de amenazas
Contexto de Amenazas: Recupera contexto de eventos, atribución de actores de amenazas y mapeos MITRE ATT&CK para IOC
Reducción de Falsos Positivos: Valida IOC contra listas de advertencia de MISP para reducir falsos positivos
Seguimiento de Avistamientos: Registra y consulta el historial de avistamientos para evaluar la prevalencia de IOC
Exploración de Galaxias: Accede a perfiles de actores de amenazas, familias de malware y patrones de ataque

Flujo de Trabajo de Ejemplo:

Wazuh detecta un hash de archivo sospechoso o conexión de red en una alerta
El asistente de IA consulta el MISP MCP Server para verificar si el IOC es conocido en la inteligencia de amenazas
Si es desconocido, el Cortex MCP Server analiza el artefacto usando múltiples analizadores
Los resultados de VirusTotal, análisis híbrido, reputación de dominio y otras fuentes se correlacionan
Se crea un caso en TheHive mediante el TheHive MCP Server para rastrear la investigación
La inteligencia combinada proporciona contexto para decisiones de respuesta a incidentes
Los hallazgos pueden usarse para actualizar reglas de Wazuh o activar monitoreo adicional

Requisitos

Un cliente LLM compatible con MCP (Protocolo de Contexto de Modelo) (por ejemplo, Claude Desktop)
Un servidor Wazuh en ejecución (v4.12 recomendado) con la API habilitada y accesible.
Conectividad de red entre este servidor y la API de Wazuh (si se usa interacción con la API).

Instalación

Opción 1: Descargar Binario Precompilado (Recomendado)

Descargar el Binario:
- Ve a la página de Releases del repositorio de GitHub de mcp-server-wazuh.
- Descarga el binario apropiado para tu sistema operativo (por ejemplo, mcp-server-wazuh-linux-amd64, mcp-server-wazuh-macos-amd64, mcp-server-wazuh-macos-arm64, mcp-server-wazuh-windows-amd64.exe).
- Haz que el binario descargado sea ejecutable (por ejemplo, chmod +x mcp-server-wazuh-linux-amd64).
- (Opcional) Renómbralo a algo más simple como mcp-server-wazuh y muévelo a un directorio en el PATH de tu sistema para facilitar el acceso.

Opción 2: Docker

Extraer la Imagen de Docker:

docker pull ghcr.io/gbrigandi/mcp-server-wazuh:latest

Opción 3: Compilar desde el Código Fuente

Prerrequisitos:
- Instala Rust: https://www.rust-lang.org/tools/install

Compilar:

git clone https://github.com/gbrigandi/mcp-server-wazuh.git
cd mcp-server-wazuh

# Build with stdio transport only (default)
cargo build --release

# Build with HTTP transport support
cargo build --release --features http

El binario estará disponible en target/release/mcp-server-wazuh.

Configurar Tu Cliente LLM

El método para configurar tu cliente LLM variará según el cliente en sí. Para clientes que soportan MCP (Protocolo de Contexto de Modelo), típicamente necesitarás apuntar el cliente a la ruta del ejecutable de mcp-server-wazuh.

Ejemplo para Claude Desktop:

Configura tu archivo claude_desktop_config.json:

{
  "mcpServers": {
    "wazuh": {
      "command": "/path/to/mcp-server-wazuh",
      "args": [],
      "env": {
        "WAZUH_API_HOST": "your_wazuh_manager_api_host",
        "WAZUH_API_PORT": "55000",
        "WAZUH_API_USERNAME": "your_wazuh_api_user",
        "WAZUH_API_PASSWORD": "your_wazuh_api_password",
        "WAZUH_INDEXER_HOST": "your_wazuh_indexer_host",
        "WAZUH_INDEXER_PORT": "9200",
        "WAZUH_INDEXER_USERNAME": "your_wazuh_indexer_user",
        "WAZUH_INDEXER_PASSWORD": "your_wazuh_indexer_password",
        "WAZUH_VERIFY_SSL": "false",
        "WAZUH_TEST_PROTOCOL": "https",
        "RUST_LOG": "info"
      }
    }
  }
}

Reemplaza /path/to/mcp-server-wazuh con la ruta real a tu binario y configura las variables de entorno como se detalla en la sección de Configuración.

Una vez configurado, tu cliente LLM debería poder lanzar y comunicarse con el mcp-server-wazuh para acceder a los datos de seguridad de Wazuh.

Si usas Docker, crea un archivo .env con tu configuración de Wazuh:

WAZUH_API_HOST=your_wazuh_manager_api_host
WAZUH_API_PORT=55000
WAZUH_API_USERNAME=your_wazuh_api_user
WAZUH_API_PASSWORD=your_wazuh_api_password
WAZUH_INDEXER_HOST=your_wazuh_indexer_host
WAZUH_INDEXER_PORT=9200
WAZUH_INDEXER_USERNAME=your_wazuh_indexer_user
WAZUH_INDEXER_PASSWORD=your_wazuh_indexer_password
WAZUH_VERIFY_SSL=false
WAZUH_TEST_PROTOCOL=https
RUST_LOG=info

Configura tu archivo claude_desktop_config.json:

{
  "mcpServers": {
    "wazuh": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "--env-file", "/path/to/your/.env",
        "ghcr.io/gbrigandi/mcp-server-wazuh:latest"
      ]
    }
  }
}

Configuración

La configuración se gestiona mediante variables de entorno. Se puede colocar un archivo .env en la raíz del proyecto para desarrollo local.

Variable	Descripción	Valor Predeterminado	Requerido
`WAZUH_API_HOST`	Nombre de host o dirección IP del servidor API del Wazuh Manager.	`localhost`	Sí
`WAZUH_API_PORT`	Número de puerto para la API del Wazuh Manager.	`55000`	Sí
`WAZUH_API_USERNAME`	Nombre de usuario para la autenticación de la API del Wazuh Manager.	`wazuh`	Sí
`WAZUH_API_PASSWORD`	Contraseña para la autenticación de la API del Wazuh Manager.	`wazuh`	Sí
`WAZUH_INDEXER_HOST`	Nombre de host o dirección IP del servidor API del Wazuh Indexer.	`localhost`	Sí
`WAZUH_INDEXER_PORT`	Número de puerto para la API del Wazuh Indexer.	`9200`	Sí
`WAZUH_INDEXER_USERNAME`	Nombre de usuario para la autenticación de la API del Wazuh Indexer.	`admin`	Sí
`WAZUH_INDEXER_PASSWORD`	Contraseña para la autenticación de la API del Wazuh Indexer.	`admin`	Sí
`WAZUH_VERIFY_SSL`	Establecer a `true` para verificar certificados SSL para conexiones de API de Wazuh e Indexer.	`false`	No
`WAZUH_TEST_PROTOCOL`	Protocolo para conexiones de Wazuh (por ejemplo, "http", "https"). Anula el valor predeterminado del cliente.	`https`	No
`RUST_LOG`	Nivel de registro (por ejemplo, `info`, `debug`, `trace`).	`info`	No
Nota sobre `WAZUH_VERIFY_SSL`: Para entornos de producción, se recomienda encarecidamente establecer `WAZUH_VERIFY_SSL=true` y asegurar una validación de certificados adecuada tanto para las conexiones con la API del Wazuh Manager como con el Wazuh Indexer. Establecerlo en `false` deshabilita las comprobaciones de certificados, lo cual es inseguro.
El campo "Requerido: Sí" indica que estas variables son esenciales para que el servidor se conecte a los componentes de Wazuh correspondientes. Aunque se proporcionan valores predeterminados, es poco probable que coincidan con una configuración de producción o no local.

Compilación

Requisitos previos

Instalar Rust: https://www.rust-lang.org/tools/install
Instalar Docker y Docker Compose (opcional, para despliegue en contenedores): https://docs.docker.com/get-docker/

Desarrollo local

Clonar el repositorio:

git clone https://github.com/gbrigandi/mcp-server-wazuh.git 
cd mcp-server-wazuh

Configurar (si se usa la API de Wazuh):
- Copiar el archivo de entorno de ejemplo: cp .env.example .env
- Editar el archivo .env con los detalles específicos de tu API de Wazuh (por ejemplo, WAZUH_API_HOST, WAZUH_API_PORT).

Compilar:

# Build with default features (stdio transport only)
cargo build

# Build with HTTP transport support
cargo build --features http

Ejecutar:

# Run with stdio transport (default)
cargo run

# Run with HTTP transport (requires --features http during build)
cargo run --features http -- --transport http

# Or use the run script (which might set up stdio mode):
# ./run.sh

Modos de transporte

El Wazuh MCP Server admite dos modos de transporte para la comunicación con clientes MCP:

Transporte stdio (predeterminado)

El transporte stdio es el modo predeterminado, ideal para integraciones locales donde el cliente MCP inicia el servidor como un proceso hijo. La comunicación ocurre a través de stdin/stdout usando mensajes JSON-RPC 2.0.

# Run with stdio transport (default)
mcp-server-wazuh

# Explicit stdio transport
mcp-server-wazuh --transport stdio

Transporte HTTP transmisible

El transporte HTTP permite el despliegue remoto del servidor, permitiendo que los clientes MCP se conecten a través de la red. Este modo implementa la especificación MCP Streamable HTTP con soporte para Server-Sent Events (SSE).

# Run with HTTP transport on default address (127.0.0.1:8080)
mcp-server-wazuh --transport http

# Run with custom host and port
mcp-server-wazuh --transport http --host 0.0.0.0 --port 3000

Características del transporte HTTP:

Un único endpoint /mcp para toda la comunicación MCP
Solicitudes POST con mensajes JSON-RPC
Server-Sent Events (SSE) para respuestas en streaming
Gestión de sesiones con el encabezado MCP-Session-Id
Versión del protocolo: 2025-06-18 (especificación MCP compatible con rmcp 0.10)

Nota de seguridad: Por defecto, el transporte HTTP se vincula a 127.0.0.1 (solo localhost). Al vincularse a 0.0.0.0 para acceso remoto, asegúrate de implementar medidas de seguridad de red adecuadas (reglas de firewall, proxy inverso con TLS, etc.).

Argumentos de CLI

Argumento	Descripción	Predeterminado
`--transport`	Modo de transporte: `stdio` o `http`	`stdio`
`--host`	Dirección de enlace del servidor HTTP (solo para transporte http)	`127.0.0.1`
`--port`	Puerto del servidor HTTP (solo para transporte http)	`8080`

Arquitectura

El servidor está construido con el framework rmcp (v0.10+) y facilita la comunicación entre clientes MCP (por ejemplo, Claude Desktop, extensiones de IDE) y el Wazuh MCP Server. El servidor admite tanto transporte stdio como HTTP transmisible e interactúa con las APIs del Wazuh Indexer y del Wazuh Manager para obtener alertas de seguridad y otros datos.

sequenceDiagram
    participant ClientApp as Client Application (e.g., IDE Extension / Claude Desktop)
    participant WazuhMCPServer as Wazuh MCP Server (this application)
    participant WazuhAPI as Wazuh API

    ClientApp->>+WazuhMCPServer: (stdio) MCP Initialize
    WazuhMCPServer-->>-ClientApp: (stdout) MCP Initialized
    
    ClientApp->>+WazuhMCPServer: (stdio) MCP Request (tools/list)
    WazuhMCPServer->>WazuhMCPServer: Parse MCP Request
    WazuhMCPServer->>WazuhMCPServer: Process internally
    WazuhMCPServer-->>-ClientApp: (stdout) MCP Response (available tools)
    
    ClientApp->>+WazuhMCPServer: (stdio) MCP Request (tools/call for wazuhAlerts)
    WazuhMCPServer->>WazuhMCPServer: Parse MCP Request
    WazuhMCPServer->>+WazuhAPI: Request Wazuh Alerts (with WAZUH_API_USERNAME, WAZUH_API_PASSWORD)
    WazuhAPI-->>-WazuhMCPServer: Wazuh Alert Data (JSON)
    WazuhMCPServer->>WazuhMCPServer: Transform Wazuh Alerts to MCP Format
    WazuhMCPServer-->>-ClientApp: (stdout) MCP Response (alerts)

Flujo de datos (enfoque stdio):

Una aplicación (por ejemplo, una extensión de IDE, una herramienta CLI) inicia el Wazuh MCP Server como un proceso hijo.
La aplicación envía solicitudes con formato MCP (comandos) al stdin del servidor.
El Wazuh MCP Server lee el comando desde stdin.
Procesamiento:
- El servidor analiza el comando MCP.
- Si el comando requiere obtener datos de Wazuh (por ejemplo, "obtener últimas alertas"):
  - El servidor se conecta a la API de Wazuh (autenticándose si es necesario usando credenciales configuradas como WAZUH_API_USERNAME, WAZUH_API_PASSWORD).
  - Obtiene los datos requeridos (por ejemplo, alertas de seguridad).
  - La lógica de transformación del servidor procesa cada alerta, mapeando los campos de Wazuh al formato MCP.
- Si el comando es interno (por ejemplo, una verificación de estado específica del servidor MCP), lo procesa directamente.
El servidor envía una respuesta JSON con formato MCP (por ejemplo, alertas transformadas, confirmación de comando o mensajes de error) a la aplicación a través de su stdout.
La aplicación lee y procesa la respuesta MCP desde el stdout del servidor.

Esta interacción stdio permite una integración estrecha con herramientas de desarrollo locales u otras aplicaciones que puedan gestionar procesos hijos. Un endpoint HTTP opcional (/mcp) también puede estar disponible para clientes que prefieran sondeo.

El servidor se comunica a través de stdin y stdout usando mensajes JSON-RPC 2.0, cumpliendo con el Model Context Protocol (MCP).

Ejemplo de flujo de interacción:

La aplicación cliente (por ejemplo, extensión de IDE) inicia el proceso mcp-server-wazuh.

El cliente envía una solicitud initialize al stdin del servidor:

{
  "jsonrpc": "2.0",
  "id": 0,
  "method": "initialize",
  "params": {
    "protocolVersion": "2025-06-18",
    "capabilities": {
      "sampling": {},
      "roots": { "listChanged": true }
    },
    "clientInfo": {
      "name": "mcp-inspector",
      "version": "0.11.0"
    }
  }
}

El servidor envía una respuesta initialize al cliente a través de stdout:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "protocolVersion": "2025-06-18",
    "capabilities": {
      "prompts": {},
      "resources": {},
      "tools": {}
    },
    "serverInfo": {
      "name": "mcp-server-wazuh",
      "version": "0.3.0"
    },
    "instructions": "This server provides tools to interact with a Wazuh SIEM instance for security monitoring and analysis.\nAvailable tools:\n- 'get_wazuh_alert_summary': Retrieves a summary of Wazuh security alerts. Optionally takes 'limit' parameter to control the number of alerts returned (defaults to 100)."
  }
}

El cliente envía notifications/initialized al stdin del servidor: (Esto es una notificación, por lo que el cliente omite id.)
```
{
  "jsonrpc": "2.0",
  "method": "notifications/initialized"
}
```
El cliente solicita las herramientas disponibles enviando tools/list al stdin del servidor:
```
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
  "params": {}
}
```

El servidor responde con la lista de herramientas al cliente a través de stdout:

{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "tools": [
      {
        "name": "get_wazuh_alert_summary",
        "description": "Retrieves a summary of Wazuh security alerts. Returns formatted alert information including ID, timestamp, and description.",
        "inputSchema": {
          "$schema": "http://json-schema.org/draft-07/schema#",
          "properties": {
            "limit": {
              "description": "Maximum number of alerts to retrieve (default: 100)",
              "format": "uint32",
              "minimum": 0.0,
              "type": ["integer", "null"]
            }
          },
          "title": "GetAlertSummaryParams",
          "type": "object"
        }
      }
    ]
  }
}

El cliente llama a la herramienta get_wazuh_alert_summary enviando tools/call al stdin del servidor:

{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "tools/call",
  "params": {
    "name": "get_wazuh_alert_summary",
    "arguments": {
      "limit": 5
    }
  }
}

El servidor recibe en stdin, procesa la llamada a get_wazuh_alert_summary (lo que implica consultar la API del Wazuh Indexer y transformar los datos).

El servidor envía una respuesta tools/call con las alertas formateadas al cliente a través de stdout:

{
  "jsonrpc": "2.0",
  "id": 3,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Alert ID: 1747091815.1212763\nTime: 2024-01-15T10:30:45.123Z\nAgent: web-server-01\nLevel: 7\nDescription: Attached USB Storage"
      },
      {
        "type": "text", 
        "text": "Alert ID: 1747066333.1207112\nTime: 2024-01-15T10:25:12.456Z\nAgent: database-server\nLevel: 5\nDescription: New dpkg (Debian Package) installed."
      }
    ],
    "isError": false
  }
}

O, si no se encuentran alertas:

{
  "jsonrpc": "2.0",
  "id": 3,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "No Wazuh alerts found."
      }
    ],
    "isError": false
  }
}

O, si hay un error al conectarse a Wazuh:

{
  "jsonrpc": "2.0",
  "id": 3,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Error retrieving alerts from Wazuh: HTTP request error: connection refused"
      }
    ],
    "isError": true
  }
}

Desarrollo y pruebas

Estilo de código: Utiliza formato estándar de Rust (cargo fmt).
Linting: Utiliza Clippy (cargo clippy).
Pruebas: Contiene pruebas unitarias para la lógica de transformación y pruebas de integración. Para stdio, las pruebas podrían implicar canalizar entrada/salida a un arnés de pruebas. Para HTTP, las pruebas utilizan un servidor simulado de la API de Wazuh (httpmock) y un cliente MCP de prueba.
```
# Run all tests
cargo test

# Run specific integration test (example for HTTP tests)
# cargo test --test integration_test

# Run tests with detailed logging
RUST_LOG=debug cargo test
```
Consulta tests/README.md para más detalles sobre cómo ejecutar pruebas y usar el CLI del cliente de prueba.

Licencia

Este proyecto está licenciado bajo la Licencia MIT.