Los dos scripts de bash levantan un contenedor local de Postgres, aplican el esquema y generan `backend/.env` / `frontend/.env.local` por ti — luego imprimen los dos comandos para iniciar realmente la aplicación (`pip install` + ejecutar backend, `npm install` + ejecutar el servidor de desarrollo del frontend). `setup-azure.ps1` es un envoltorio fino alrededor de `infra/provision.ps1`, el runbook real de despliegue de Azure Container Apps.

---

## Características

- **Agregación de feeds** — sondea más de 60 feeds RSS de seguridad de Nivel 1/2/3 según una programación; deduplica y filtra contenido promocional automáticamente
- **Triaje con IA** — clasifica cada entrada con severidad (Crítica/Alta/Media/Baja/Informativa), TTPs de MITRE ATT&CK y un resumen en lenguaje sencillo. Modular por proveedor: API directa de Anthropic o Azure AI Foundry, conmutables mediante una variable de entorno sin perder funcionalidad en ningún caso
- **Extracción de IOC** — extrae automáticamente IPs, dominios, URLs, hashes de archivos y CVEs de cada entrada
- **Integración con RunZero** — sincroniza tu inventario de activos y correlaciona inteligencia de amenazas contra activos en vivo; coincide en CVEs, nombres de software, versiones de SO y direcciones IP. Tres subpestañas bajo `RUNZERO`: **Matches** (entradas correlacionadas contra tu inventario, filtrables por severidad/fecha/confianza/KEV), **Exposure** (postura confirmada/posible a nivel de organización con seguimiento de remediación) y **Metrics** (tendencias de ingesta vs. remediación a lo largo del tiempo)
- **Your Stack** — define el software/SO de tu entorno; vuelve a puntuar todas las entradas por relevancia
- **Libro mayor de IOC** — libro mayor buscable de todos los indicadores extraídos con referencias cruzadas de entradas y exportación STIX/CSV
- **Matriz MITRE ATT&CK** — mapa de calor de la cobertura de TTPs a través de la inteligencia de amenazas ingerida
- **Panel de estado de feeds** — estado de sondeo por feed, seguimiento de fallos consecutivos y volumen de artículos de 7 días
- **Detections** — una superficie de revisión de 9 pestañas (ver abajo) que cubre todo lo registrado como detección, ya sea generado por IA, importado desde tus propios archivos o sincronizado desde un espacio de trabajo de Sentinel en vivo
- **Autenticación modular** — SSO de Microsoft Entra ID con acceso basado en roles, o una única clave de API local compartida con cero dependencia de Azure. Detectada automáticamente por el frontend; ver [Modos de autenticación](#auth-modes)

### Dos características relacionadas con detecciones

Este repositorio en realidad incluye dos cosas relacionadas pero utilizables de forma independiente bajo el paraguas de "detections":

1. **La pestaña `DETECTIONS`** — una superficie de revisión autocontenida, dividida en nueve subpestañas:
   - **All Detections** — el catálogo completo de analíticas registradas, filtrable por técnica/disposición/estado de revisión, cada una expandible a su descripción y KQL completo.
   - **Defender Custom Detections** — el mismo catálogo, limitado a detecciones destinadas a las reglas de detección personalizadas de Microsoft Defender for Endpoint en lugar de a las reglas analíticas de Sentinel.
   - **Alignment Reviews** — cada vez que una analítica de detección se registra contra una técnica de MITRE, una comprobación de IA compara su cobertura real con la propia descripción de MITRE de esa técnica. Cuando diverge o solo cubre parcialmente la técnica, aterriza aquí como un elemento de revisión humana con el razonamiento de la IA, una corrección de KQL sugerida y el propio resultado de validación de esa corrección (puerta estática + backtest) — nunca una sugerencia ciega.
   - **Disposition Alerts** — una cola de detección de podredumbre: una analítica aprobada cuya telemetría se degrada o cuya regla subyacente empieza a dar errores se marca aquí para re-revisión, nombrada por su propia detección en lugar de solo por la técnica MITRE compartida.
   - **Generated Hunts** — las detecciones se agrupan en hunts (uno por archivo importado hoy; uno por artículo de TI/proyecto de detections.ai de origen una vez que se lance esa integración), coincidiendo con la propia característica Hunts de Microsoft Sentinel. Un hunt puede sincronizarse en un espacio de trabajo real de Sentinel como un objeto `Microsoft.SecurityInsights/hunts` más sus consultas de búsqueda guardadas constituyentes (restringido por `SENTINEL_HUNTING_SYNC_ENABLED` y un `mode` — off/manual/auto — configurable por equipo en Settings > API Settings; nunca un auto-push silencioso a menos que lo habilites).
   - **Sentinel Hunts** — el inventario en vivo de lo que realmente está desplegado en la característica Hunting de tu espacio de trabajo de Sentinel, extraído directamente de ARM en lugar del propio historial de sincronización de esta aplicación; incluye sugerencias de prueba/ajuste por consulta que puedes aplicar o descartar en el lugar.
   - **Sentinel Analytics Rules** — la misma idea para las Analytics Rules de Microsoft Sentinel (`Microsoft.SecurityInsights/alertRules`) — un tipo de recurso de Sentinel distinto de Hunting, ya que estas son las que realmente disparan incidentes/alertas según una programación — con el mismo flujo de trabajo de aplicar/descartar sugerencias de ajuste.
   - **Local Detections** — ver [Ejecución sin Sentinel ni un proveedor de IA](#running-without-sentinel-or-an-ai-provider-local-detections-import) abajo.
   - **Audit Log** (solo administradores) — un registro entre pipelines de cada comprobación que esta aplicación ha ejecutado realmente: resultados de puerta estática/sonda de control de detecciones generadas por IA, intentos de sincronización de hunts de Sentinel y ejecuciones de prueba de consultas de hunt/reglas analíticas de Sentinel, combinados en una única lista paginada y filtrable — cubriendo deliberadamente lo que ninguna pestaña de revisión individual hace por sí sola.

   Se ejecuta completamente dentro del backend principal, sin necesidad de despliegue adicional para la propia superficie de revisión. Su propio diseño de API sigue deliberadamente las convenciones de detections.ai a continuación, aunque es totalmente autocontenido.
2. **Orquestador de pipeline de detections.ai — próximamente.** detections.ai tiene una API pública en desarrollo para la generación de detecciones asistida por IA, y este repositorio tiene una integración real construida para ella (`backend/detection_pipeline/orchestrator.py`) que toma inteligencia de amenazas triada, la compara con la cobertura de detección existente y genera KQL en borrador para tu espacio de trabajo de Sentinel como un trabajo programado. Esta integración dará soporte a esa API una vez que esté disponible, y aún no forma parte de esta versión pública. Mientras tanto, **no la necesitas en absoluto para usar la pestaña Detections** — [Local Detections Import](#running-without-sentinel-or-an-ai-provider-local-detections-import) abajo cubre el mismo objetivo de "obtener detecciones reales en esta aplicación" para configuraciones sin generación por IA y sin Sentinel hoy.

### Ejecución sin Sentinel ni un proveedor de IA: Local Detections Import

Dado el nombre y el discurso principal de la aplicación, la pregunta más común de un auto-hospedador en el nivel **Basic** probablemente será *"No tengo Sentinel ni un proveedor de IA configurado — ¿aún puedo obtener algo de las pestañas Detections/Hunts?"* La respuesta es sí: apunta la aplicación a una carpeta de tus propios archivos de reglas de detección (escritos a mano, exportados de un tenant real de Sentinel/Defender, o extraídos de un repositorio público de reglas Sigma/Sentinel) y los catalogará, etiquetará con MITRE y validará estáticamente — sin conexión a Sentinel y sin necesidad de `DETECTIONS_AI_API_KEY`/clave de Anthropic para nada de ello.

- **Formatos soportados, desde el primer día:** archivos sin procesar `.kql`/`.txt`/`.yar`/`.spl` o de cualquier extensión, cada uno opcionalmente emparejado con un sidecar `.json`/`.yaml` (`{"file": "myrule.kql", "title": "...", "description": "...", "technique_id": "T1059.001"}`) para metadatos que la propia exportación de Microsoft no necesita declarar por separado; YARA; Suricata; Sigma YAML (de uno o varios documentos); Splunk SPL; y el propio JSON nativo exportado de Analytics Rule/Hunting Query de Microsoft (solo las reglas de tipo `Scheduled` llevan una consulta KQL sin procesar que esta aplicación puede evaluar — cualquier otro tipo se reconoce y se reporta, no se omite silenciosamente).
- **Qué se ejecuta realmente sobre un archivo importado:** validación estática (el mismo motor de durabilidad/hallazgos que usa la ruta de generación por IA) para contenido KQL; también una comprobación de alineación con MITRE, si *sí* tienes un proveedor de IA configurado (un eje independiente de Sentinel — puedes tener uno, ambos o ninguno); todo lo dependiente de Sentinel (backtesting, sondas de telemetría, seguimiento de disposición) queda fuera de alcance y se muestra como "no Sentinel connection configured" en lugar de una celda en blanco engañosa.
- **Dónde aparece:** el contenido importado se convierte en una fila normal de hunt/detección — mismas tablas, mismo flujo de trabajo de revisión, misma visualización de técnica MITRE que cualquier cosa que genere el pipeline de IA — por lo que también aparece en las vistas regulares `ALL DETECTIONS`/`GENERATED HUNTS`, no solo en su propia pestaña. La subpestaña dedicada **Local Detections** (bajo `DETECTIONS`, solo administradores para activar una importación) es donde la apuntas a una carpeta y observas el progreso/resultados por archivo.
- **Configuración:** establece `LOCAL_IMPORT_DIR` a una ruta absoluta en el sistema de archivos del backend (un volumen montado, en un despliegue en contenedor) — todo lo importado debe residir bajo esa raíz; la interfaz de usuario te permite elegir una subruta debajo de ella, nunca una ubicación arbitraria del sistema de archivos. Ver [Variables de entorno](#environment-variables).
- **Pruébalo de inmediato:** `examples/local-detections-samples/` incluye una pequeña carpeta lista para importar — dos reglas KQL válidas (una emparejada con un sidecar `.json` para mostrar ese mecanismo), una regla deliberadamente inválida (para ver el banner de marcado como inválido) y un archivo no reconocido (para ver el banner de importación fallida). Apunta `LOCAL_IMPORT_DIR` a ella para ver los tres estados de resultado en tu primera importación, sin necesidad de escribir reglas.

**Local Detections** — una ejecución de importación completada: el banner de resumen señala los archivos que fueron catalogados pero marcados como inválidos por el análisis estático (aquí, una regla que alerta sobre un único hash codificado) junto a los que se importaron limpiamente, y cada archivo se convierte en una fila normal de hunt/detección a continuación

![Local Detections](https://assets.kitploit.com/production/public/readmes/55296/caf1d88594b2bef58bc52b99a779da6d51aeb2b032ae1808fb114c1b8d6aca07/8985c51d3404ac6592121c1d2217d5faa6551c97d65600b3a9b050d5cd4767ce-display-v1.webp)

---

## Capturas de pantalla

Todas las capturas de pantalla a continuación usan datos sintéticos (nombres de organizaciones falsos, IPs de ejemplo RFC 5737, dominios `.example`) generados para documentación — sin inteligencia de amenazas real ni datos de clientes.

**Feed** — explora y filtra entradas de inteligencia de amenazas triadas con severidad, etiquetas, IOCs y TTPs

![Feed](https://assets.kitploit.com/production/public/readmes/55296/e75cea290ced1c3b96346bf04578c6964569b5c70ac4982b91a9f2fea761c4e9/75ad877a8fafd97692b94e9f033f28191973ff10ec6d94626633f13cad189cc1-display-v1.webp)

<br>

**Dashboard** — desglose de severidad de un vistazo y principales técnicas MITRE ATT&CK

![Dashboard](https://assets.kitploit.com/production/public/readmes/55296/eb48a8bbda9454d3f9e134228080ca250d581375f16e4828da282592278c7118/58f1568d9f9896867c01334e00cc8ef3dfb55f2e31a637a349ff2c5f0718b4c2-display-v1.webp)

<br>

**MITRE ATT&CK** — mapa de calor de matriz completa de cobertura de técnicas a través de la inteligencia ingerida

![MITRE ATT&CK](https://assets.kitploit.com/production/public/readmes/55296/9df0d60a5197e785dd85356a6beba126ef16bd91518f2d84108b987afaaf9b06/cac6e7cbe4f1b993265c84719288aa8789814fe1aff97821b5f0f27baaf65e3d-display-v1.webp)

<br>

**Your Stack** — define tu entorno; las entradas del feed se vuelven a puntuar por relevancia

![Your Stack](https://assets.kitploit.com/production/public/readmes/55296/40839d08db86d678c276bb6d52ec403f807a6593f58b341db27e3e7d8701f652/b7ebedd6e968a264cdf73259aa8d8fef404795023efd998f5a9b0255556f77c2-display-v1.webp)

<br>

**IOCs** — libro mayor buscable de todos los indicadores extraídos con exportación STIX/CSV

![IOCs](https://assets.kitploit.com/production/public/readmes/55296/87ac0ff28d571697f6f3ab0ca6905ab5e137bb190cc0bca1fc064db88904614b/e7f960a68d10c87a9467eb42e438cdd81026c5eb5daa9667f9185dc7b395ebe6-display-v1.webp)

<br>

**Integrations** — resumen de conectores para Sentinel, Defender y RunZero: estado configurado/habilitado y atajos a la propia pestaña de cada uno

![Integrations](https://assets.kitploit.com/production/public/readmes/55296/b261064e5162d7dd615fab4d8eb332735cc412ae6ada1e095c2bca0f0afcf989/d92aa2477825a8eeb126bb5fa3396f3292fe8af23a7806538d9f74eb561efac2-display-v1.webp)

<br>

**RunZero** — correlación de activos, seguimiento de exposición a nivel de organización y métricas de remediación, todo proveniente de tu inventario de RunZero

![RunZero](https://assets.kitploit.com/production/public/readmes/55296/1c14c9bf6fa927012db3fef13c5fbe9187aaf3a9e914358b7408a872f61dc6d0/be053e10181d5b79a14a9aff7b249c3450cf787f0379d84651bb060bf9c2b8b6-display-v1.webp)

<br>

**Exposure** — organizaciones clasificadas por número de coincidencias de amenazas; haz clic en cualquier tarjeta para ver las entradas coincidentes

![Exposure](https://assets.kitploit.com/production/public/readmes/55296/f80096a602e70e3b462c5d98ac4f04b0ebdc6c47c1efb055bd56f552d55823e4/0bfec2320b8e1f189bfd645a816444587f7fd056377e85ff2c1d34df12b1ab44-display-v1.webp)

<br>

**Detections** — el catálogo completo de analíticas registradas (tanto generadas por IA como importadas localmente), cada una con su estado de puerta estática/backtest/revisión y técnica MITRE

![Detections](https://assets.kitploit.com/production/public/readmes/55296/bbf5ddc849c368101e54def614a377ba8bcca705cecf65949dc7b93f1a9dea1f/75df6746fea32f7dac1a0f52b099142c3d48fcdd1dbfcea87b9d20306d178ccd-display-v1.webp)

<br>

**Settings** — controles de triaje con IA, monitoreo de estado de feeds, puntuaciones de confianza de fuentes y gestión de usuarios

![Settings](https://assets.kitploit.com/production/public/readmes/55296/af5be9150416723dd8d0bd311029cc530869c52d514c67f4974a9bbf3d699f99/5964908fc2ae52d0f88149bb6d040898addf7fe99ef154eb7598e1adc3fefda5-display-v1.webp)

---

## Arquitectura```
┌─────────────────────────────────────────┐
│  Next.js 16 frontend (port 3000)        │
│  Tailwind CSS · dark theme              │
└──────────────┬──────────────────────────┘
               │ REST API (Bearer token)
┌──────────────▼──────────────────────────┐
│  FastAPI backend (port 8000)            │
│  APScheduler · slowapi rate limiting    │
└──┬──────────┬──────────┬────────────┬───┘
   │          │          │            │
Postgres   AI provider  RunZero API  detections.ai
           (modular:    (asset sync)  (coming soon --
           Anthropic or                see Features below)
           Azure AI Foundry)

### Configuración manual```bash
cd backend
python -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
pip install -r requirements.txt
cp env.example .env              # fill in required values — see Environment Variables below
uvicorn main:app --reload --port 8000

# Obtener todas las conexiones TCP en escucha
result = mcp.get_network_connections(
    protocol="tcp",
    state="LISTEN"
)

# Obtener conexiones de un proceso específico
result = mcp.get_network_connections(
    process_name="nginx",
    limit=50
)

# Obtener conexiones a un puerto remoto específico
result = mcp.get_network_connections(
    remote_port=443,
    protocol="tcp"
)

{
  "connections": [
    {
      "protocol": "tcp",
      "local_address": "0.0.0.0:22",
      "remote_address": "0.0.0.0:0",
      "status": "LISTEN",
      "pid": 1234,
      "process_name": "sshd",
      "family": "AF_INET"
    }
  ],
  "total_count": 1,
  "filters_applied": {
    "protocol": "tcp",
    "state": "LISTEN"
  }
}

# Obtener todas las interfaces de red
result = mcp.get_network_interfaces()

# Obtener una interfaz específica sin estadísticas
result = mcp.get_network_interfaces(
    interface_name="eth0",
    include_stats=False
)

{
  "interfaces": [
    {
      "name": "eth0",
      "status": "up",
      "mtu": 1500,
      "speed": 1000,
      "addresses": [
        {
          "family": "AF_INET",
          "address": "192.168.1.100",
          "netmask": "255.255.255.0",
          "broadcast": "192.168.1.255"
        }
      ],
      "stats": {
        "bytes_sent": 1234567,
        "bytes_recv": 7654321,
        "packets_sent": 12345,
        "packets_recv": 54321,
        "errors_in": 0,
        "errors_out": 0,
        "drops_in": 0,
        "drops_out": 0
      }
    }
  ],
  "total_count": 1
}

# Obtener estadísticas de red agregadas
result = mcp.get_network_stats()

# Obtener estadísticas por interfaz
result = mcp.get_network_stats(per_interface=True)

{
  "total": {
    "bytes_sent": 123456789,
    "bytes_recv": 987654321,
    "packets_sent": 1234567,
    "packets_recv": 7654321,
    "errors_in": 0,
    "errors_out": 0,
    "drops_in": 0,
    "drops_out": 0
  },
  "per_interface": {
    "eth0": {
      "bytes_sent": 123456789,
      "bytes_recv": 987654321,
      "packets_sent": 1234567,
      "packets_recv": 7654321
    }
  }
}

# Obtener contadores de E/S de red agregados
result = mcp.get_network_io_counters()

# Obtener contadores de una NIC específica
result = mcp.get_network_io_counters(
    per_nic=True,
    nic_name="eth0"
)

{
  "total": {
    "bytes_sent": 123456789,
    "bytes_recv": 987654321,
    "packets_sent": 1234567,
    "packets_recv": 7654321,
    "errin": 0,
    "errout": 0,
    "dropin": 0,
    "dropout": 0
  },
  "per_nic": {
    "eth0": {
      "bytes_sent": 123456789,
      "bytes_recv": 987654321,
      "packets_sent": 1234567,
      "packets_recv": 7654321,
      "errin": 0,
      "errout": 0,
      "dropin": 0,
      "dropout": 0
    }
  }
}

# Obtener resumen agrupado por protocolo
result = mcp.get_network_connections_summary()

# Obtener resumen agrupado por proceso
result = mcp.get_network_connections_summary(
    group_by="process"
)

{
  "summary": {
    "tcp": {
      "total": 25,
      "listening": 5,
      "established": 20
    },
    "udp": {
      "total": 10,
      "listening": 8,
      "established": 2
    }
  },
  "total_connections": 35,
  "group_by": "protocol"
}

# Obtener todas las conexiones agrupadas por proceso
result = mcp.get_network_connections_by_process()

# Obtener conexiones de un proceso específico
result = mcp.get_network_connections_by_process(
    process_name="nginx"
)

{
  "processes": [
    {
      "pid": 1234,
      "process_name": "nginx",
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "0.0.0.0:80",
          "remote_address": "0.0.0.0:0",
          "status": "LISTEN"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_processes": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por puerto
result = mcp.get_network_connections_by_port()

# Obtener conexiones en un puerto específico
result = mcp.get_network_connections_by_port(
    port=443,
    protocol="tcp"
)

{
  "ports": [
    {
      "port": 443,
      "protocol": "tcp",
      "connections": [
        {
          "local_address": "0.0.0.0:443",
          "remote_address": "0.0.0.0:0",
          "status": "LISTEN",
          "pid": 1234,
          "process_name": "nginx"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_ports": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por estado
result = mcp.get_network_connections_by_state()

# Obtener conexiones en estado ESTABLISHED
result = mcp.get_network_connections_by_state(
    state="ESTABLISHED"
)

{
  "states": [
    {
      "state": "ESTABLISHED",
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "192.168.1.100:54321",
          "remote_address": "93.184.216.34:443",
          "pid": 5678,
          "process_name": "firefox"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_states": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por dirección local
result = mcp.get_network_connections_by_address()

# Obtener conexiones a una dirección remota específica
result = mcp.get_network_connections_by_address(
    address="93.184.216.34",
    address_type="remote"
)

{
  "addresses": [
    {
      "address": "93.184.216.34",
      "address_type": "remote",
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "192.168.1.100:54321",
          "remote_address": "93.184.216.34:443",
          "status": "ESTABLISHED",
          "pid": 5678,
          "process_name": "firefox"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_addresses": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por familia
result = mcp.get_network_connections_by_family()

# Obtener conexiones IPv6
result = mcp.get_network_connections_by_family(
    family="AF_INET6"
)

{
  "families": [
    {
      "family": "AF_INET",
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "192.168.1.100:54321",
          "remote_address": "93.184.216.34:443",
          "status": "ESTABLISHED",
          "pid": 5678,
          "process_name": "firefox"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_families": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por tipo
result = mcp.get_network_connections_by_type()

# Obtener conexiones de tipo stream
result = mcp.get_network_connections_by_type(
    connection_type="stream"
)

{
  "types": [
    {
      "type": "stream",
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "192.168.1.100:54321",
          "remote_address": "93.184.216.34:443",
          "status": "ESTABLISHED",
          "pid": 5678,
          "process_name": "firefox"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_types": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por estado
result = mcp.get_network_connections_by_status()

# Obtener conexiones en estado TIME_WAIT
result = mcp.get_network_connections_by_status(
    status="TIME_WAIT"
)

{
  "statuses": [
    {
      "status": "TIME_WAIT",
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "192.168.1.100:54321",
          "remote_address": "93.184.216.34:443",
          "pid": 5678,
          "process_name": "firefox"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_statuses": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por protocolo
result = mcp.get_network_connections_by_protocol()

# Obtener conexiones TCP
result = mcp.get_network_connections_by_protocol(
    protocol="tcp"
)

{
  "protocols": [
    {
      "protocol": "tcp",
      "connections": [
        {
          "local_address": "192.168.1.100:54321",
          "remote_address": "93.184.216.34:443",
          "status": "ESTABLISHED",
          "pid": 5678,
          "process_name": "firefox"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_protocols": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por dirección local
result = mcp.get_network_connections_by_local_address()

# Obtener conexiones desde una dirección local específica
result = mcp.get_network_connections_by_local_address(
    local_address="192.168.1.100"
)

{
  "local_addresses": [
    {
      "local_address": "192.168.1.100",
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "192.168.1.100:54321",
          "remote_address": "93.184.216.34:443",
          "status": "ESTABLISHED",
          "pid": 5678,
          "process_name": "firefox"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_addresses": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por dirección remota
result = mcp.get_network_connections_by_remote_address()

# Obtener conexiones hacia una dirección remota específica
result = mcp.get_network_connections_by_remote_address(
    remote_address="93.184.216.34"
)

{
  "remote_addresses": [
    {
      "remote_address": "93.184.216.34",
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "192.168.1.100:54321",
          "remote_address": "93.184.216.34:443",
          "status": "ESTABLISHED",
          "pid": 5678,
          "process_name": "firefox"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_addresses": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por puerto local
result = mcp.get_network_connections_by_local_port()

# Obtener conexiones desde un puerto local específico
result = mcp.get_network_connections_by_local_port(
    local_port=54321
)

{
  "local_ports": [
    {
      "local_port": 54321,
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "192.168.1.100:54321",
          "remote_address": "93.184.216.34:443",
          "status": "ESTABLISHED",
          "pid": 5678,
          "process_name": "firefox"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_ports": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por puerto remoto
result = mcp.get_network_connections_by_remote_port()

# Obtener conexiones hacia un puerto remoto específico
result = mcp.get_network_connections_by_remote_port(
    remote_port=443
)

{
  "remote_ports": [
    {
      "remote_port": 443,
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "192.168.1.100:54321",
          "remote_address": "93.184.216.34:443",
          "status": "ESTABLISHED",
          "pid": 5678,
          "process_name": "firefox"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_ports": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por PID
result = mcp.get_network_connections_by_pid()

# Obtener conexiones de un PID específico
result = mcp.get_network_connections_by_pid(
    pid=5678
)

{
  "pids": [
    {
      "pid": 5678,
      "process_name": "firefox",
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "192.168.1.100:54321",
          "remote_address": "93.184.216.34:443",
          "status": "ESTABLISHED"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_pids": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por nombre de proceso
result = mcp.get_network_connections_by_process_name()

# Obtener conexiones de un proceso específico
result = mcp.get_network_connections_by_process_name(
    process_name="nginx"
)

{
  "process_names": [
    {
      "process_name": "nginx",
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "0.0.0.0:80",
          "remote_address": "0.0.0.0:0",
          "status": "LISTEN",
          "pid": 1234
        }
      ],
      "connection_count": 1
    }
  ],
  "total_process_names": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por comando
result = mcp.get_network_connections_by_command()

# Obtener conexiones de un comando específico
result = mcp.get_network_connections_by_command(
    command="nginx: worker process"
)

{
  "commands": [
    {
      "command": "nginx: worker process",
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "0.0.0.0:80",
          "remote_address": "0.0.0.0:0",
          "status": "LISTEN",
          "pid": 1234
        }
      ],
      "connection_count": 1
    }
  ],
  "total_commands": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por usuario
result = mcp.get_network_connections_by_user()

# Obtener conexiones de un usuario específico
result = mcp.get_network_connections_by_user(
    username="www-data"
)

{
  "users": [
    {
      "username": "www-data",
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "0.0.0.0:80",
          "remote_address": "0.0.0.0:0",
          "status": "LISTEN",
          "pid": 1234,
          "process_name": "nginx"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_users": 1,
  "total_connections": 1
}

# Obtener todas las conexiones agrupadas por grupo
result = mcp.get_network_connections_by_group()

# Obtener conexiones de un grupo específico
result = mcp.get_network_connections_by_group(
    groupname="www-data"
)

{
  "groups": [
    {
      "groupname": "www-data",
      "connections": [
        {
          "protocol": "tcp",
          "local_address": "0.0.0.0:80",
          "remote_address": "0.0.0.0:0",
          "status": "LISTEN",
          "pid": 1234,
          "process_name": "nginx"
        }
      ],
      "connection_count": 1
    }
  ],
  "total_groups": 1,
  "total_connections": 1
}

### Docker Compose (ambos servicios)```bash
cp backend/env.example backend/.env   # fill in required values
docker compose up --build

`provision.ps1` es idempotente — es seguro volver a ejecutarlo después de editar el manifiesto. Consulta su propio comentario de encabezado para ver el paso a paso completo (plataforma → pila de aplicaciones → secretos → Easy Auth → importación de imágenes → aplicaciones → comprobaciones posteriores).

El orquestador de detections.ai (un Container Apps Job programado controlado por un bloque `Orchestrator` en `migration.psd1` — consulta `migration.psd1.example` para ver la forma, y almacena tu clave como el secreto `DETECTIONSAIAPIKEY` de Key Vault) aún no forma parte de esta versión pública — consulta [Two detections-related features](#two-detections-related-features) más arriba.

---

## Estructura del proyecto```
├── backend/
│   ├── main.py                  # FastAPI app, all endpoints
│   ├── db.py                    # Postgres queries
│   ├── pgcompat.py              # connection pool + SQLite-style placeholder translation
│   ├── feed_manager.py          # RSS polling, AI triage (provider-modular), scheduler
│   ├── enrichment.py            # IOC extraction, KEV cache, stack rematch
│   ├── runzero_sync.py          # RunZero asset sync and correlation engine
│   ├── dedup.py                 # CVE deduplication logic
│   ├── auth.py                  # Entra ID SSO + local API-key auth, app JWT sign/verify
│   ├── ioc_export.py            # STIX 2.1 and CSV export
│   ├── stack_presets.py         # Pre-built tech stack templates
│   ├── detection_pipeline/      # detections.ai orchestrator, MITRE alignment-check,
│   │                            # Sentinel hunts/analytics-rules sync + tuning,
│   │                            # audit log, local_import.py (Local Detections Import)
│   └── tests/                   # pytest test suite, incl. fixtures/local_import/
├── frontend/
│   ├── pages/
│   │   ├── index.js              # Main app shell + tab routing
│   │   └── login.js              # Entra ID or local API-key login, auto-detected
│   ├── lib/
│   │   ├── authMode.js           # GET /api/auth/mode, cached per page load
│   │   ├── authFetch.js          # Bearer auth + 401-retry wrapper
│   │   └── authSession.js        # token storage, JWT decode/expiry helpers
│   └── components/
│       ├── layout/                # TopBar, Sidebar, TabBar, TopFilterBar, TimeRangeToggle
│       ├── feed/                  # FeedList, FeedCard
│       ├── integrations/          # IntegrationsPanel, ExposurePanel, RunZeroPanel,
│       │                          # RunZeroMatchesPanel, RunZeroMetricsPanel
│       ├── detections/            # DetectionsPanel (tab shell) + one component per
│       │                          # sub-tab: DetectionsCatalogPanel, AlignmentReviewPanel,
│       │                          # DispositionAlertsPanel, HuntsPanel, SentinelHuntsPanel,
│       │                          # SentinelAnalyticsRulesPanel, LocalDetectionsPanel,
│       │                          # AuditPanel, plus shared TuningSuggestionBadge
│       ├── settings/              # SettingsPanel, CadencePicker, SeverityCards
│       └── mitre/                 # MitreMatrix
├── infra/                       # Azure Bicep templates + provision.ps1
├── scripts/                     # Tiered setup scripts (see Deployment tiers)
└── docker-compose.yml