Wazuh MCP Server

Um servidor baseado em Rust que integra o sistema Wazuh SIEM com aplicações compatíveis com MCP.

Documentação

Wazuh MCP Server - Fale com seu SIEM

Um servidor baseado em Rust projetado para preencher a lacuna entre um sistema Wazuh Security Information and Event Management (SIEM) e aplicações que necessitam de dados contextuais de segurança, especificamente adaptado para a Integração com Claude Desktop usando o Model Context Protocol (MCP).

Visão Geral

Assistentes de IA modernos como o Claude podem se beneficiar significativamente de contexto em tempo real sobre o ambiente de segurança do usuário. O Wazuh MCP Server preenche essa lacuna fornecendo acesso abrangente aos dados do Wazuh SIEM por meio de interações em linguagem natural.

Este servidor transforma respostas complexas da API do Wazuh em formato compatível com MCP, permitindo que assistentes de IA acessem:

Alertas e Eventos de Segurança do Wazuh Indexer para detecção de ameaças e resposta a incidentes
Gerenciamento e Monitoramento de Agentes incluindo status de saúde, processos do sistema e portas de rede
Dados de Avaliação de Vulnerabilidades para gerenciamento de riscos e priorização de patches
Regras de Segurança e Configuração para otimização de detecção e validação de conformidade
Estatísticas do Sistema e Métricas de Desempenho para monitoramento operacional e trilhas de auditoria
Capacidades de Análise de Logs e Forense para investigação de incidentes e relatórios de conformidade
Saúde e Gerenciamento de Cluster para requisitos de confiabilidade e disponibilidade da infraestrutura
Monitoramento de Conformidade e Análise de Lacunas para frameworks regulatórios como PCI-DSS, HIPAA, SOX e GDPR

Em vez de exigir chamadas manuais de API ou consultas complexas, as equipes de segurança agora podem fazer perguntas em linguagem natural como "Mostre-me vulnerabilidades críticas em servidores web", "Quais processos estão em execução no agente 001?" ou "Estamos atendendo aos requisitos de registro do PCI-DSS?" e receber dados estruturados e acionáveis de sua implantação Wazuh.

Essa abordagem é particularmente valiosa para equipes de conformidade que precisam avaliar rapidamente a postura de segurança, identificar lacunas na cobertura de monitoramento, validar a eficácia das regras e gerar evidências para requisitos de auditoria em infraestruturas distribuídas.

Exemplos de Casos de Uso

O Wazuh MCP Server fornece acesso direto aos dados de segurança do Wazuh por meio de interações em linguagem natural, permitindo vários casos de uso práticos:

Análise de Alertas de Segurança

Triagem e Investigação de Alertas: Consulte alertas de segurança recentes com get_wazuh_alert_summary para identificar e priorizar rapidamente ameaças que exigem atenção imediata.
Reconhecimento de Padrões de Alertas: Analise tendências e padrões de alertas para identificar problemas de segurança recorrentes ou possíveis campanhas de ataque.

Gerenciamento de Vulnerabilidades

Avaliação de Vulnerabilidades de Agentes: Use get_wazuh_vulnerability_summary e get_wazuh_critical_vulnerabilities para avaliar a postura de segurança de agentes específicos e priorizar esforços de correção.
Priorização de Vulnerabilidades Baseada em Risco: Correlacione dados de vulnerabilidade com a criticidade e exposição do agente para focar os esforços de remediação.

Monitoramento do Sistema e Forense

Análise de Processos: Investigue processos em execução nos agentes usando get_wazuh_agent_processes para caça a ameaças e análise do sistema.
Avaliação de Segurança de Rede: Monitore portas abertas e serviços de rede com get_wazuh_agent_ports para identificar possíveis vetores de ataque.
Monitoramento de Saúde do Agente: Acompanhe o status e a conectividade dos agentes usando get_wazuh_running_agents para garantir cobertura abrangente de segurança.

Inteligência de Operações de Segurança

Análise de Eficácia de Regras: Revise e analise regras de detecção de segurança com get_wazuh_rules_summary para otimizar as capacidades de detecção.
Monitoramento de Desempenho do Gerenciador: Acompanhe o desempenho e as estatísticas do sistema usando ferramentas como get_wazuh_weekly_stats, get_wazuh_remoted_stats e get_wazuh_log_collector_stats.
Gerenciamento de Saúde do Cluster: Monitore o status do cluster Wazuh com get_wazuh_cluster_health e get_wazuh_cluster_nodes para confiabilidade operacional.

Resposta a Incidentes e Forense

Análise de Logs: Pesquise e analise logs do gerenciador usando search_wazuh_manager_logs e get_wazuh_manager_error_logs para investigação de incidentes.
Investigação Específica de Agentes: Combine várias ferramentas para construir perfis abrangentes de agentes específicos durante incidentes de segurança.
Consultas de Segurança em Linguagem Natural: Faça perguntas complexas de segurança em linguagem natural e receba dados estruturados de vários componentes do Wazuh.

Eficiência Operacional

Relatórios Automatizados: Gere relatórios e resumos de segurança por meio de interfaces conversacionais sem chamadas manuais de API.
Análise Entre Componentes: Correlacione dados do Wazuh Indexer (alertas) e do Wazuh Manager (agentes, regras, vulnerabilidades) para insights abrangentes de segurança.
Operações de Segurança Multilíngues: Acesse dados do Wazuh e receba insights em vários idiomas para equipes de segurança globais.

Coleta de Inteligência de Ameaças e Resposta

Para capacidades aprimoradas de inteligência de ameaças e resposta a incidentes, o Wazuh MCP Server pode ser combinado com servidores MCP de segurança complementares:

Servidor	Descrição
Cortex MCP Server	Análise de artefatos e enriquecimento de IOC por meio de mais de 140 analisadores
TheHive MCP Server	Gerenciamento de casos e orquestração de resposta a incidentes
MISP MCP Server	Compartilhamento de inteligência de ameaças e consulta de IOC

Capacidades Aprimoradas com Integração Cortex:

Análise de Artefatos: Analise automaticamente arquivos, URLs, domínios e endereços IP suspeitos encontrados em alertas do Wazuh usando os mais de 140 analisadores do Cortex
Enriquecimento de IOC: Enriqueça indicadores de comprometimento (IOCs) de alertas do Wazuh com inteligência de ameaças de várias fontes, incluindo VirusTotal, Shodan, MISP e outras
Caça a Ameaças Automatizada: Combine as capacidades de detecção do Wazuh com os mecanismos de análise do Cortex para investigar e classificar ameaças automaticamente
Inteligência de Múltiplas Fontes: Utilize analisadores para verificações de reputação, análise de malware, análise de domínios e análise comportamental
Orquestração de Resposta: Use os resultados da análise para informar ações de resposta automatizadas e priorização de alertas

Capacidades Aprimoradas com Integração TheHive:

Criação de Casos: Crie automaticamente casos no TheHive a partir de alertas do Wazuh para rastreamento estruturado de incidentes
Correlação de Alertas: Vincule alertas relacionados do Wazuh a casos existentes para linhas do tempo abrangentes de incidentes
Gerenciamento de Tarefas: Crie e acompanhe tarefas de investigação com base na severidade e no tipo do alerta
Gerenciamento de Observáveis: Extraia e gerencie IOCs como observáveis dentro das investigações de casos
Colaboração: Permita a colaboração da equipe de segurança em incidentes detectados pelo Wazuh

Capacidades Aprimoradas com Integração MISP:

Consulta de IOC: Verifique se indicadores de alertas do Wazuh são conhecidos em seu banco de dados de inteligência de ameaças
Contexto de Ameaças: Recupere contexto de eventos, atribuição de atores de ameaças e mapeamentos MITRE ATT&CK para IOCs
Redução de Falsos Positivos: Valide IOCs contra listas de aviso do MISP para reduzir falsos positivos
Rastreamento de Avistamentos: Registre e consulte o histórico de avistamentos para avaliar a prevalência de IOCs
Exploração Galaxy: Acesse perfis de atores de ameaças, famílias de malware e padrões de ataque

Exemplo de Fluxo de Trabalho:

O Wazuh detecta um hash de arquivo suspeito ou conexão de rede em um alerta
O assistente de IA consulta o MISP MCP Server para verificar se o IOC é conhecido na inteligência de ameaças
Se desconhecido, o Cortex MCP Server analisa o artefato usando vários analisadores
Resultados do VirusTotal, análise híbrida, reputação de domínio e outras fontes são correlacionados
Um caso é criado no TheHive por meio do TheHive MCP Server para rastrear a investigação
A inteligência combinada fornece contexto para decisões de resposta a incidentes
As descobertas podem ser usadas para atualizar regras do Wazuh ou acionar monitoramento adicional

Requisitos

Um cliente LLM compatível com MCP (Model Context Protocol) (por exemplo, Claude Desktop)
Um servidor Wazuh em execução (v4.12 recomendado) com a API habilitada e acessível.
Conectividade de rede entre este servidor e a API do Wazuh (se a interação com a API for usada).

Instalação

Opção 1: Baixar Binário Pré-compilado (Recomendado)

Baixar o Binário:
- Acesse a página de Releases do repositório GitHub do mcp-server-wazuh.
- Baixe o binário apropriado para seu sistema operacional (por exemplo, mcp-server-wazuh-linux-amd64, mcp-server-wazuh-macos-amd64, mcp-server-wazuh-macos-arm64, mcp-server-wazuh-windows-amd64.exe).
- Torne o binário baixado executável (por exemplo, chmod +x mcp-server-wazuh-linux-amd64).
- (Opcional) Renomeie-o para algo mais simples como mcp-server-wazuh e mova-o para um diretório no PATH do seu sistema para facilitar o acesso.

Opção 2: Docker

Baixar a Imagem Docker:

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

Opção 3: Compilar a partir do Código Fonte

Pré-requisitos:
- Instale o 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

O binário estará disponível em target/release/mcp-server-wazuh.

Configurar Seu Cliente LLM

O método para configurar seu cliente LLM variará dependendo do próprio cliente. Para clientes que suportam MCP (Model Context Protocol), você normalmente precisará apontar o cliente para o caminho do executável mcp-server-wazuh.

Exemplo para Claude Desktop:

Configure seu arquivo 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"
      }
    }
  }
}

Substitua /path/to/mcp-server-wazuh pelo caminho real para seu binário e configure as variáveis de ambiente conforme detalhado na seção Configuração.

Uma vez configurado, seu cliente LLM deve ser capaz de iniciar e se comunicar com o mcp-server-wazuh para acessar dados de segurança do Wazuh.

Se estiver usando Docker, crie um arquivo .env com sua configuração do 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

Configure seu arquivo 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"
      ]
    }
  }
}

Configuração

A configuração é gerenciada por meio de variáveis de ambiente. Um arquivo .env pode ser colocado na raiz do projeto para desenvolvimento local.

Variável	Descrição	Padrão	Obrigatório
`WAZUH_API_HOST`	Nome do host ou endereço IP do servidor da API do Wazuh Manager.	`localhost`	Sim
`WAZUH_API_PORT`	Número da porta para a API do Wazuh Manager.	`55000`	Sim
`WAZUH_API_USERNAME`	Nome de usuário para autenticação na API do Wazuh Manager.	`wazuh`	Sim
`WAZUH_API_PASSWORD`	Senha para autenticação na API do Wazuh Manager.	`wazuh`	Sim
`WAZUH_INDEXER_HOST`	Nome do host ou endereço IP do servidor da API do Wazuh Indexer.	`localhost`	Sim
`WAZUH_INDEXER_PORT`	Número da porta para a API do Wazuh Indexer.	`9200`	Sim
`WAZUH_INDEXER_USERNAME`	Nome de usuário para autenticação na API do Wazuh Indexer.	`admin`	Sim
`WAZUH_INDEXER_PASSWORD`	Senha para autenticação na API do Wazuh Indexer.	`admin`	Sim
`WAZUH_VERIFY_SSL`	Defina como `true` para verificar certificados SSL para conexões com a API do Wazuh e Indexer.	`false`	Não
`WAZUH_TEST_PROTOCOL`	Protocolo para conexões Wazuh (por exemplo, "http", "https"). Substitui o padrão do cliente.	`https`	Não
`RUST_LOG`	Nível de log (por exemplo, `info`, `debug`, `trace`).	`info`	Não
Nota sobre `WAZUH_VERIFY_SSL`: Para ambientes de produção, é fortemente recomendado definir `WAZUH_VERIFY_SSL=true` e garantir a validação adequada de certificados tanto para as conexões da API do Wazuh Manager quanto do Wazuh Indexer. Definir como `false` desativa as verificações de certificado, o que é inseguro.
O "Obrigatório: Sim" indica que essas variáveis são essenciais para o servidor se conectar aos respectivos componentes do Wazuh. Embora valores padrão sejam fornecidos, é improvável que correspondam a uma configuração de produção ou não local.

Compilação

Pré-requisitos

Instale o Rust: https://www.rust-lang.org/tools/install
Instale o Docker e o Docker Compose (opcional, para implantação em contêineres): https://docs.docker.com/get-docker/

Desenvolvimento Local

Clone o repositório:

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

Configure (se estiver usando a API do Wazuh):
- Copie o arquivo de ambiente de exemplo: cp .env.example .env
- Edite o arquivo .env com os detalhes específicos da API do Wazuh (por exemplo, WAZUH_API_HOST, WAZUH_API_PORT).

Compile:

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

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

Execute:

# 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

O Wazuh MCP Server suporta dois modos de transporte para comunicação com clientes MCP:

Transporte stdio (Padrão)

O transporte stdio é o modo padrão, ideal para integrações locais onde o cliente MCP inicia o servidor como um processo filho. A comunicação ocorre via stdin/stdout usando mensagens JSON-RPC 2.0.

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

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

Transporte HTTP Streamable

O transporte HTTP permite a implantação remota do servidor, permitindo que clientes MCP se conectem pela rede. Este modo implementa a especificação MCP Streamable HTTP com suporte a 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

Recursos do Transporte HTTP:

Endpoint único /mcp para toda comunicação MCP
Requisições POST com mensagens JSON-RPC
Server-Sent Events (SSE) para respostas em streaming
Gerenciamento de sessão com cabeçalho MCP-Session-Id
Versão do protocolo: 2025-06-18 (especificação MCP suportada pelo rmcp 0.10)

Nota de Segurança: Por padrão, o transporte HTTP vincula-se a 127.0.0.1 (somente localhost). Ao vincular a 0.0.0.0 para acesso remoto, garanta que medidas adequadas de segurança de rede (regras de firewall, proxy reverso com TLS, etc.) estejam em vigor.

Argumentos de CLI

Argumento	Descrição	Padrão
`--transport`	Modo de transporte: `stdio` ou `http`	`stdio`
`--host`	Endereço de vinculação do servidor HTTP (somente para transporte http)	`127.0.0.1`
`--port`	Porta do servidor HTTP (somente para transporte http)	`8080`

Arquitetura

O servidor é construído usando o framework rmcp (v0.10+) e facilita a comunicação entre clientes MCP (por exemplo, Claude Desktop, extensões de IDE) e o Wazuh MCP Server. O servidor suporta tanto os transportes stdio quanto HTTP Streamable e interage com as APIs do Wazuh Indexer e do Wazuh Manager para buscar alertas de segurança e outros dados.

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)

Fluxo de Dados (foco em stdio):

Um aplicativo (por exemplo, uma extensão de IDE, uma ferramenta CLI) inicia o Wazuh MCP Server como um processo filho.
O aplicativo envia requisições (comandos) formatadas em MCP para o stdin do servidor.
O Wazuh MCP Server lê o comando do stdin.
Processamento:
- O servidor analisa o comando MCP.
- Se o comando exigir a obtenção de dados do Wazuh (por exemplo, "obter alertas mais recentes"):
  - O servidor se conecta à API do Wazuh (autenticando se necessário usando credenciais configuradas como WAZUH_API_USERNAME, WAZUH_API_PASSWORD).
  - Ele obtém os dados necessários (por exemplo, alertas de segurança).
  - A lógica de transformação do servidor processa cada alerta, mapeando os campos do Wazuh para o formato MCP.
- Se o comando for interno (por exemplo, uma verificação de status específica do servidor MCP), ele o processa diretamente.
O servidor envia uma resposta JSON formatada em MCP (por exemplo, alertas transformados, confirmação de comando ou mensagens de erro) para o aplicativo via seu stdout.
O aplicativo lê e processa a resposta MCP do stdout do servidor.

Essa interação stdio permite uma integração estreita com ferramentas de desenvolvimento locais ou outros aplicativos que podem gerenciar processos filhos. Um endpoint HTTP opcional (/mcp) também pode estar disponível para clientes que preferem polling.

O servidor se comunica via stdin e stdout usando mensagens JSON-RPC 2.0, aderindo ao Model Context Protocol (MCP).

Exemplo de fluxo de interação:

O aplicativo cliente (por exemplo, extensão de IDE) inicia o processo mcp-server-wazuh.

O cliente envia a requisição initialize para o stdin do 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"
    }
  }
}

O servidor envia a resposta initialize para o cliente via 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)."
  }
}

O cliente envia notifications/initialized para o stdin do servidor: (Isso é uma notificação, então o id é omitido pelo cliente.)
```
{
  "jsonrpc": "2.0",
  "method": "notifications/initialized"
}
```
O cliente solicita as ferramentas disponíveis enviando tools/list para o stdin do servidor:
```
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
  "params": {}
}
```

O servidor responde com a lista de ferramentas para o cliente via 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"
        }
      }
    ]
  }
}

O cliente chama a ferramenta get_wazuh_alert_summary enviando tools/call para o stdin do servidor:

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

O servidor recebe em stdin, processa a chamada get_wazuh_alert_summary (que envolve consultar a API do Wazuh Indexer e transformar os dados).

O servidor envia a resposta tools/call com alertas formatados para o cliente via 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
  }
}

Ou, se nenhum alerta for encontrado:

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

Ou, se houver um erro ao conectar ao Wazuh:

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

Desenvolvimento e Testes

Estilo de Código: Usa formatação padrão do Rust (cargo fmt).
Linting: Usa Clippy (cargo clippy).
Testes: Contém testes unitários para a lógica de transformação e testes de integração. Para stdio, os testes podem envolver o encaminhamento de entrada/saída para um harness de teste. Para HTTP, os testes usam um servidor mock da API do Wazuh (httpmock) e um cliente MCP de teste.
```
# 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
```
Consulte tests/README.md para mais detalhes sobre como executar testes e usar o CLI do cliente de teste.

Licença

Este projeto é licenciado sob a Licença MIT.