Skip to main content
Glama
Illumio MCP Server

Illumio MCP Server

by alexgoller

Servidor MCP de Illumio

Un servidor de Protocolo de Contexto de Modelo (MCP) que proporciona una interfaz para interactuar con Illumio PCE (Motor de Cómputo de Políticas). Este servidor permite el acceso programático a la gestión de cargas de trabajo de Illumio, las operaciones de etiquetado y el análisis del flujo de tráfico.

¿Qué puede hacer?

Utilice IA conversacional para hablar con su PCE:

  • Crear, actualizar y eliminar cargas de trabajo

  • Crear, actualizar y eliminar etiquetas

  • Obtenga resúmenes de tráfico y realice análisis de seguridad sobre ellos

  • Obtenga salud PCE

Related MCP server: OpenCTI MCP Server

Prerrequisitos

  • Python 3.8+

  • Acceso a una instancia de Illumio PCE

  • Credenciales API válidas para el PCE

Instalación

  1. Clonar el repositorio:

git clone [repository-url]
cd illumio-mcp
  1. Instalar dependencias:

pip install -r requirements.txt

Configuración

Debes ejecutarlo usando el comando uv , que hace que sea más fácil pasar variables de entorno y ejecutarlo en segundo plano.

Uso de uv y Claude Desktop

En MacOS: ~/Library/Application\ Support/Claude/claude_desktop_config.json En Windows: %APPDATA%/Claude/claude_desktop_config.json

Agregue lo siguiente a la sección custom_settings :

"mcpServers": {
    "illumio-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/Users/alex.goller/git/illumio-mcp",
        "run",
        "illumio-mcp"
      ],
      "env": {
        "PCE_HOST": "your-pce-host",
        "PCE_PORT": "your-pce-port",
        "PCE_ORG_ID": "1", # your org id
        "API_KEY": "api_key",
        "API_SECRET": "api_secret"
      }
    }
  }
}

Características

Recursos

Los recursos aún no están terminados y lo revisaré más adelante.

  • illumio://workloads - Obtener cargas de trabajo del PCE

  • illumio://labels - Obtener todas las etiquetas de PCE

Herramientas

Gestión de la carga de trabajo

  • get-workloads - Recupera todas las cargas de trabajo de PCE

  • create-workload : crea una carga de trabajo no administrada con un nombre, direcciones IP y etiquetas especificados

  • update-workload : actualiza las propiedades de una carga de trabajo existente

  • delete-workload - Eliminar una carga de trabajo de PCE por nombre

Operaciones de etiquetas

  • create-label - Crea una nueva etiqueta con un par clave-valor

  • delete-label : elimina una etiqueta existente por par clave-valor

  • get-labels - Recupera todas las etiquetas de PCE

Análisis de tráfico

  • get-traffic-flows : obtenga datos detallados del flujo de tráfico con opciones de filtrado integrales:

    • Filtrado de rango de fechas

    • Filtrado de origen/destino

    • Filtrado de servicios (puertos/protocolos)

    • Filtrado de decisiones políticas

    • Opciones de consulta de lista de IP y carga de trabajo

    • Resultados limitantes

  • get-traffic-flows-summary : obtenga información resumida del flujo de tráfico con las mismas capacidades de filtrado que get-traffic-flows

Gestión de políticas

  • get-rulesets - Obtener conjuntos de reglas del PCE con filtrado opcional:

    • Filtrar por nombre

    • Filtrar por estado habilitado

Gestión de listas de IP

  • get-iplists - Obtener listas de IP del PCE con filtrado opcional:

    • Filtrar por nombre

    • Filtrar por descripción

    • Filtrar por rangos de IP

Prueba de conexión

  • check-pce-connection : verificar la conectividad y las credenciales del PCE

Gestión de eventos

  • get-events - Obtener eventos del PCE con filtrado opcional:

    • Filtrar por tipo de evento (por ejemplo, 'system_task.expire_service_account_api_keys')

    • Filtrar por gravedad (emergencia, alerta, crítica, error, advertencia, aviso, información, depuración)

    • Filtrar por estado (éxito, fracaso)

    • Limitar el número de resultados devueltos

Manejo de errores

El servidor implementa un manejo y registro de errores integral:

  • Problemas de conexión de PCE

  • Errores de autenticación de API

  • Errores de creación/actualización de recursos

  • Validación de entrada no válida

Todos los errores se registran con seguimientos de pila completos y se devuelven como mensajes de error formateados al cliente.

Desarrollo

Ejecución de pruebas

Las pruebas aún no están implementadas.

python -m pytest tests/

Modo de depuración

Establezca el nivel de registro en DEBUG en el código o entorno para obtener registros de operaciones detallados.

Contribuyendo

  1. Bifurcar el repositorio

  2. Crear una rama de características

  3. Confirme sus cambios

  4. Empujar hacia la rama

  5. Crear una solicitud de extracción

Licencia

Este proyecto está licenciado bajo la GPL-3.0. Consulte el archivo de LICENCIA para más detalles.

Apoyo

Para obtener ayuda, cree un problema .

Ejemplos

Ejemplos visuales

Todos los ejemplos a continuación fueron generados por Claude Desktop 3.5 Sonnet y con datos obtenidos a través de este servidor MCP. Descubrí que renderizar los datos a los componentes de React genera visualizaciones y resultados excelentes.

Análisis de aplicaciones

Análisis de aplicaciones Vista detallada de los patrones de comunicación y dependencias de la aplicación

Análisis de niveles de aplicación Análisis de patrones de tráfico entre diferentes niveles de aplicación

Perspectivas de infraestructura

Panel de análisis de infraestructura Panel de descripción general que muestra las métricas y el estado clave de la infraestructura

Servicios de infraestructura Análisis detallado de las comunicaciones del servicio de infraestructura

Evaluación de seguridad

Informe de análisis de seguridad Informe de análisis de seguridad completo

Hallazgos de alto riesgo Resultados de la evaluación de seguridad para vulnerabilidades de alto riesgo

Cumplimiento de PCI Resultados de la evaluación de cumplimiento de PCI

Cumplimiento de SWIFT Resultados de la evaluación de cumplimiento de SWIFT

Planificación de la remediación

Descripción general del plan de remediaciónDescripción general de la planificación de la remediación de seguridad

Pasos detallados de remediación Pasos detallados para la implementación de la remediación de seguridad

Gestión de políticas

Descripción general de las listas de IP Interfaz de gestión para listas de IP

Categorías de conjuntos de reglas Descripción general de las categorías y la organización del conjunto de reglas

Ordenación del conjunto de reglas de la aplicación Configuración del ordenamiento de reglas de la aplicación

Gestión de la carga de trabajo

Análisis de la carga de trabajo Análisis detallado de la carga de trabajo y métricas

Tráfico de carga de trabajo Identificación y análisis de patrones de tráfico de carga de trabajo

Gestión de etiquetas

Etiquetas PCE por tipo Organización de las etiquetas PCE por tipo y categoría

Análisis de servicios

Inferencia de roles de servicio Inferencia automática de roles de servicio según patrones de tráfico

Principales fuentes y destinos Análisis de las 5 principales fuentes y destinos de tráfico

Planificación de proyectos

Plan del proyecto Cronograma y hitos de implementación del proyecto

Indicaciones disponibles

Aplicación Ringfence

El mensaje de ringfence-application ayuda a crear políticas de seguridad para aislar y proteger las aplicaciones controlando el tráfico entrante y saliente.

Argumentos requeridos:

  • application_name : Nombre de la aplicación a proteger

  • application_environment : Entorno de la aplicación a delimitar

Características:

  • Crea reglas para la comunicación entre niveles dentro de la aplicación.

  • Utiliza flujos de tráfico para identificar las conexiones externas necesarias

  • Implementa restricciones de tráfico entrante según las aplicaciones de origen

  • Crea reglas de tráfico saliente para las comunicaciones externas necesarias

  • Maneja conexiones tanto dentro del ámbito (misma aplicación/entorno) como fuera del ámbito (externas)

  • Crea conjuntos de reglas separados para conexiones de aplicaciones remotas

Analizar el tráfico de aplicaciones

El mensaje de solicitud analyze-application-traffic proporciona un análisis detallado de los patrones de tráfico y la conectividad de las aplicaciones.

Argumentos requeridos:

  • application_name : Nombre de la aplicación a analizar

  • application_environment : Entorno de la aplicación a analizar

Características del análisis:

  • Ordena el tráfico por flujos entrantes y salientes

  • Grupos por combinaciones de aplicación/entorno/rol

  • Identifica tipos y patrones de etiquetas relevantes

  • Muestra los resultados en un formato de componente React

  • Muestra información del protocolo y del puerto.

  • Intenta identificar patrones de servicio conocidos (por ejemplo, Nagios en el puerto 5666)

  • Clasifica el tráfico en tipos de infraestructura y aplicaciones.

  • Determina la exposición a Internet

  • Muestra las etiquetas de roles, aplicaciones y entornos de Illumio

Cómo utilizar las indicaciones de MCP

Paso 1: Haga clic en el botón "Adjuntar desde MCP" en la interfaz

Flujo de trabajo de avisos de MCP

Paso 2: Elija entre los servidores MCP instalados

Flujo de trabajo de avisos de MCP

Paso 3: Complete los argumentos solicitados:

Flujo de trabajo de avisos de MCP

Paso 4: Haga clic en Enviar para enviar el mensaje configurado

Cómo funcionan las indicaciones

  • El servidor MCP envía el mensaje configurado a Claude

  • Claude recibe contexto a través del Protocolo de Contexto Modelo

  • Permite el manejo especializado de tareas específicas de Illumio

Este flujo de trabajo permite compartir contexto automatizado entre los sistemas Illumio y Claude para el análisis del tráfico de aplicaciones y tareas de delimitación.

Estibador

La aplicación está disponible como un contenedor Docker desde el Registro de contenedores de GitHub.

Tire del contenedor

docker pull ghcr.io/alexgoller/illumio-mcp-server:latest

También puedes usar una versión específica reemplazando latest con un número de versión:

docker pull ghcr.io/alexgoller/illumio-mcp-server:1.0.0

Ejecutar con Claude Desktop

Para utilizar el contenedor con Claude Desktop, necesitarás:

  1. Cree un archivo de entorno (por ejemplo ~/.illumio-mcp.env ) con sus credenciales de PCE:

PCE_HOST=your-pce-host
PCE_PORT=your-pce-port
PCE_ORG_ID=1
API_KEY=your-api-key
API_SECRET=your-api-secret
  1. Agregue la siguiente configuración a su archivo de configuración de Claude Desktop:

En MacOS ( ~/Library/Application Support/Claude/claude_desktop_config.json ):

{
    "mcpServers": {
        "illumio-mcp-docker": {
            "command": "docker",
            "args": [
                "run",
                "-i",
                "--init",
                "--rm",
                "-v",
                "/Users/YOUR_USERNAME/tmp:/var/log/illumio-mcp",
                "-e",
                "DOCKER_CONTAINER=true",
                "-e",
                "PYTHONWARNINGS=ignore",
                "--env-file",
                "/Users/YOUR_USERNAME/.illumio-mcp.env",
                "illumio-mcp:latest"
            ]
        }
    }
}

Asegúrese de:

  • Reemplace YOUR_USERNAME con su nombre de usuario real

  • Crea el directorio de registro (por ejemplo, ~/tmp )

  • Ajuste las rutas según su sistema

Ejecutar de forma independiente

También puedes ejecutar el contenedor directamente:

docker run -i --init --rm \
  -v /path/to/logs:/var/log/illumio-mcp \
  -e DOCKER_CONTAINER=true \
  -e PYTHONWARNINGS=ignore \
  --env-file ~/.illumio-mcp.env \
  ghcr.io/alexgoller/illumio-mcp-server:latest

Docker Compose

Para desarrollo o pruebas, puedes usar Docker Compose. Crea un archivo docker-compose.yml :

version: '3'
services:
  illumio-mcp:
    image: ghcr.io/alexgoller/illumio-mcp-server:latest
    init: true
    volumes:
      - ./logs:/var/log/illumio-mcp
    environment:
      - DOCKER_CONTAINER=true
      - PYTHONWARNINGS=ignore
    env_file:
      - ~/.illumio-mcp.env

Luego ejecuta:

docker-compose up

Problemas conocidos

Al ejecutar el contenedor, es posible que vea advertencias de sintaxis de las expresiones regulares del SDK de Illumio. Estas advertencias no afectan la funcionalidad y se eliminan automáticamente del contenedor.

Si ve advertencias al ejecutar el contenedor, puede eliminarlas manualmente agregando:

docker run \
  -e PYTHONWARNINGS=ignore \
  ... other environment variables ...
  ghcr.io/alexgoller/illumio-mcp-server:latest

O en docker-compose.yml:

services:
  illumio-mcp:
    environment:
      - PYTHONWARNINGS=ignore
      # ... other environment variables ...

Configuración del escritorio de Claude

Para los usuarios de Claude Desktop, agregue esta configuración a su archivo de configuración de Claude Desktop:

{
    "mcpServers": {
        "illumio-mcp-docker": {
            "command": "docker",
            "args": [
                "run",
                "-i",
                "--init",
                "--rm",
                "-v",
                "/Users/YOUR_USERNAME/tmp:/var/log/illumio-mcp",
                "-e",
                "DOCKER_CONTAINER=true",
                "-e",
                "PYTHONWARNINGS=ignore",
                "--env-file",
                "/Users/YOUR_USERNAME/.illumio-mcp.env",
                "illumio-mcp:latest"
            ]
        }
    }
}

Asegúrese de:

  1. Reemplace YOUR_USERNAME con su nombre de usuario real

  2. Cree un directorio de registro en ~/tmp (o ajuste la ruta según sea necesario)

  3. Cree un archivo de entorno en ~/.illumio-mcp.env con sus credenciales de PCE:

PCE_HOST=your-pce-host
PCE_PORT=your-pce-port
PCE_ORG_ID=1
API_KEY=your-api-key
API_SECRET=your-api-secret

La configuración:

  • Utiliza Docker para ejecutar el contenedor

  • Monta un directorio local para registros

  • Suprime las advertencias de Python

  • Carga las credenciales de PCE desde un archivo de entorno

  • Permite la limpieza adecuada del contenedor con --init y --rm

Available Tools

56 tools
build-identity-graphA

Identity-centric view of traffic: which ACCOUNT the communicating process ran as, which workloads it acted from, what it reached, and over what period. Answers least-privilege questions that workload labels cannot -- what can this account reach, and from how many places. Resolves DOMAIN\user and user@realm to one identity, so a person appearing as both CRYSTAL\jdoe and jdoe is not counted twice. Classifies service accounts (root, SYSTEM, mysql) separately from interactive ones, because wide host spread is normal for a daemon and notable for a person. Findings are ranked by how unexpected they are, and are observations, not verdicts.

Inputs: top, end_date, identity, start_date, +6 more.

check-pce-connectionA

Is the PCE answering, and how fast. Probes GET /health first and returns JSON: status (ok | unreachable), health_http_status, health_round_trip_ms, total_seconds. On failure the error names the host, how long it waited and the HTTP status or timeout -- a 5xx is the PCE or its front end, a timeout is the network. Waits are bounded (MCP_PCE_RETRIES, MCP_PCE_REQUEST_TIMEOUT); run this first when any other tool returns tool_timeout.

Inputs: no named parameters.

check-pce-credentials-statusA

Check which PCE credentials apply to the current user without revealing secrets. Always carries mode: per_user (your own key), shared (the operator's service account -- PCE-side audit shows it, not you), or stdio. In hybrid mode this reflects THIS request: registered users whose key could not be used are told they ran as shared.

Inputs: no named parameters.

collect-compliance-evidenceA

Audit evidence for segmentation controls, per app/env scope pair, from ACTIVE policy (pversion=active by default) and observed traffic. Runs the framework-independent tests the illumio-compliance-evidence skill defines (T1 inventory, T2 enforcement, T3 VEN health, T4 unmanaged in scope, T5 providing rules described, T6 no broad consumer, T7 admitted services vs approved list, T8 inbound boundary flows with potentially-blocked and blocked evidence plus a per-day timeline, T9 outbound crossings, T11 draft-vs-active drift for the scope's rulesets, T14 events and flows present) and returns, per test and per pair, {result: PASS|FAIL|EXCEPTION|NOT_TESTED, measured, rows, evidence}. No score. A capped pull never yields PASS (EXCEPTION). An unknown scope label is an error. T10 (unknown endpoints), T12 and T13 (attestations) are listed in not_run. Framework requirement mapping stays in the illumio://compliance/* resources. Read-only. Query cost: scope-wide one pull each of labels, rulesets, IP lists, services, pending changes and events, plus per pair one workload pull, four traffic queries and one deny-rule read per matched ruleset; queries reports the count.

Inputs: scope (required), tests, end_date, max_rows, +5 more.

compare-draft-activeA

Compare draft vs active policy to see what would change on provisioning. Shows new, modified, and deleted rulesets, rules, IP lists, and services.

Inputs: resource_type.

compliance-checkA

First look at policy posture against a framework (PCI-DSS, DORA, NIS2, NIST, CIS, ISO 27001, SWIFT CSP, HIPAA): keyword-routed heuristics on draft policy and recent traffic, summarised as a score. Not audit evidence: for per-test results from ACTIVE policy for an app/env scope use collect-compliance-evidence. An unknown app_name or env_name label is an error, not an estate-wide run.

Inputs: app_name, env_name, framework, lookback_days.

create-deny-ruleA

Create a deny rule in an existing ruleset. Deny rules block specific traffic (processed after allow rules). Override deny rules (override_deny=true) are the HIGHEST priority — they block traffic even when allow rules exist, meaning 'this must not happen under any circumstances.' Use override deny for emergency isolation, hard compliance blocks, or active attack response — NOT for normal segmentation or ringfencing. Rule processing order: 1) Essential rules, 2) Override Deny (blocks above all), 3) Allow rules, 4) Deny rules, 5) Default action. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: consumers (required), providers (required), ingress_services (required), ruleset_href, +3 more.

create-iplistA

Create an IP List from IP ranges, FQDNs (api.example.com, *.example.com), or both. At least one entry is required. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: name (required), fqdn, fqdns, ip_ranges, +1 more.

create-labelB

Create a label of a specific type and the value in the PCE WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: key (required), value (required).

create-ringfenceA

Create a ringfencing policy for an application. This analyzes traffic flows to discover which other apps communicate with this app, then creates a ruleset with:

  1. An intra-scope rule allowing all workloads within the app to communicate on All Services

  2. Extra-scope rules for each remote app+env discovered in traffic, allowing them in on All Services The result is a coarse-grained segmentation that controls which apps can talk to each other, reducing risk without requiring per-port policies. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: app_name (required), env_name (required), dry_run, selective, +5 more.

create-rulesetA

Create a ruleset in the PCE with support for ring-fencing patterns WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: name (required), scopes (required), rules, description.

create-serviceA

Create a service in the PCE. Supply at least one of service_ports, windows_services or windows_egress_services. windows_egress_services matches a process on the consumer side and needs a Windows VEN there. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: name (required), description, service_ports, windows_services, +1 more.

create-workloadA

Create a Illumio Core unmanaged workload in the PCE WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: name (required), ip_addresses (required), labels.

delete-deny-ruleA

Delete a deny rule from a ruleset by its href WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: href (required).

delete-iplistA

Delete an IP List from the PCE. Provide either 'href' or 'name' (but not both) to identify the IP List. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: href, name.

delete-labelA

Delete a label in the PCE WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: key (required), value (required).

delete-pce-credentialsA

Remove the current user's stored PCE credentials. Idempotent — safe to call even if no credentials are stored. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: no named parameters.

delete-rulesetA

Delete a ruleset from the PCE by its href WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: href (required).

delete-sec-ruleA

Delete a single allow rule from a ruleset, leaving the rest of the ruleset intact. For deny rules use delete-deny-rule. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: href (required).

delete-serviceA

Delete a service from the PCE. Identify by href (preferred) or name. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: href, name.

delete-workloadA

Delete a workload from the PCE. Identify by href (preferred) or name. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: href, name.

detect-lateral-movement-pathsA

Analyze traffic patterns to detect potential lateral movement paths — chains of connections that could allow an attacker to pivot between applications. Identifies apps that serve as bridges between otherwise disconnected app groups.

Inputs: app_name, env_name, max_hops, lookback_days.

discover-process-egressA

Find which processes talk to destinations outside this PCE's managed estate - the shadow-IT / unsanctioned-egress question. Returns ranked findings of process -> external destination with port, protocol, the user, current policy decision and volume, preferring an FQDN over a bare IP where the PCE resolved one. Use this instead of get-traffic-flows when the question is 'what is talking out', not 'show me all traffic'.

Inputs: limit, process, end_date, start_date, +5 more.

enforcement-readinessA

Assess whether an application is ready for enforcement by analyzing its traffic flows, existing policy coverage, and identifying potential gaps. Provides a readiness score and actionable recommendations.

Inputs: app_name (required), env_name (required), lookback_days.

find-unknown-endpointsA

Which IP addresses show up in traffic that the PCE does not know as a workload at all, and what do they do. Unknown = Explorer attached no workload to that side of the flow AND the IP is not an interface address of any inventoried workload (managed or unmanaged). Not the same as find-unmanaged-traffic, whose test is 'no app label'. One Explorer pull, one workload pull, one IP-list pull. Per endpoint: fqdn, address_class (private | public | link_local | multicast | broadcast | loopback), ip_lists (named lists containing it; the 0.0.0.0/0 default list is dropped), likely_provider for public addresses, neighbourhood (the /24 or /64 it shares with N managed workloads), as_source / as_destination blocks (connections, flows, peer workloads, peer apps as 'app (env)', top-10 ports with an admin flag, policy mix, first/last seen), peers_enforced, and profile shapes: scanner, fan_in_server, admin_reach, high_volume, single_peer, with the numbers each test used. Noise classes are counted but listed only with include_noise. With ip set, profiles that one address: full peer x port table and a timeline (1h buckets up to two days, else 1d) with the shared spike rule. Read-only.

Inputs: ip, top_n, end_date, direction, +9 more.

find-unmanaged-trafficA

Find traffic involving unmanaged (unlabeled) workloads or IP addresses. These are sources or destinations without app/env labels, representing potential policy blind spots.

Inputs: top_n, direction, lookback_days, min_connections.

get-container-clustersA

Get container clusters (Kubernetes/OpenShift) registered in the PCE. Shows cluster name, CLAS mode, online status, kubelink version, and node count.

Inputs: name, max_results.

get-container-workload-profilesB

Get Container Workload Profiles for a container cluster. These profiles control how Kubernetes pods are managed by Illumio — mapping K8s namespaces to Illumio labels and enforcement modes.

Inputs: managed, namespace, cluster_href.

get-eventsA

PCE audit events as data. Each event carries created_by as {type: user|agent|system, username, href}, resource_changes as [{resource_type, href, name, change_type, changes}] (which ruleset, rule, workload... changed and how), notifications as [{notification_type, info}] and action as {api_endpoint, api_method, src_ip, http_status_code}. Filter by event_type (one string or a list, ORed) or by kind: policy = sec_policy.create/restore, rule_set., sec_rule., deny_rule., ip_list., service.* (create/update/delete); enforcement = workloads.bulk_update / workload.update whose changes name enforcement_mode; ven = agent.activate/deactivate/tampering/clone_detected/suspend/unsuspend, workloads.unpair; auth = user.login/logout/sign_in/sign_out/authenticate, request.authorization_failed. Verified on a live PCE (26.30): rule_set., sec_rule.create/delete, deny_rule., ip_list., service., workloads.bulk_update, request.authorization_failed. The rest are Illumio's documented names not yet seen on a PCE (expected); event_types_unverified lists them per call. The PCE filters on one event_type per request, so a list or kind is one request per type, merged newest-first and capped at max_results; event_types_queried echoes the list.

Inputs: kind, status, severity, created_by, +4 more.

get-iplistsA

Get IP lists from the PCE with optional filtering. Each list carries ip_ranges as [{from_ip, to_ip, exclusion, description}] and fqdns as [{fqdn, description}], plus is_default: true on the built-in list that covers 0.0.0.0/0 or ::/0. Use contains_ip for an exact 'which lists cover this address' answer, evaluated server-side (CIDRs, from/to spans, exclusions, IPv4 and IPv6); the ip_address filter is the PCE's substring match on the range text and does not look inside CIDRs.

Inputs: fqdn, name, pversion, ip_address, +3 more.

get-kubernetes-workloadsB

Get Kubernetes Workloads (CLAS mode) from a container cluster. Shows Deployments, Services, and other K8s objects managed by Illumio with their labels and policy sync state.

Inputs: namespace, max_results, cluster_href.

get-labelsA

Get labels from the PCE with optional filtering

Inputs: key, usage, value, max_results, +1 more.

get-pairing-profilesA

Get pairing profiles from the PCE. Pairing profiles define the initial enforcement mode and labels for VENs when they pair with the PCE.

Inputs: name, max_results.

get-pce-capacityA

How full is this PCE, against its limits. Reads the documented metrics -- flow storage and retention per source vs limits (traffic_flows/database_metrics), managed-workload count over time (reports/time_series_statistics), and soft_limit_exceeded / hard_limit_exceeded events in the window -- and probes the object-limit API (/api/v2/object_limit_profiles and /api/v2/api_usage_limit_profiles, root-level, undocumented). A 403 there is reported as 'exists but this key is not allowed' (the PCE logs an authorization_failed audit event), a 404 as 'not on this PCE version', a 200 passed through with a best-effort summary. warnings lists anything at or above 80% of a limit or above a soft limit.

Inputs: lookback_days, include_object_limits.

get-policy-coverage-reportB

Generate a policy coverage report for an app, showing what traffic is covered by existing rules vs what would be blocked. Helps understand how much of an app's traffic is already policy'd.

Inputs: app_name (required), env_name (required), lookback_days.

get-rulesetsA

Get rulesets and their rules, from draft or active policy, rendered as data: scopes as [{key, value, href}], consumers/providers as {label: {key, value, href}} | {all_workloads: true} | {ip_list: {name, href}} | {label_group: {name, href}}, ingress_services as {port, proto} or {service: {name, href}}. Allow, deny and override_deny rules share one shape (rule_type). Rulesets and rules carry created_at, updated_at, update_type and created_by/updated_by as {username, href} when the PCE sends them (username needs GET /users; null if this key may not list users). labels matches ruleset SCOPE; actor_labels returns only the rules that NAME those labels as consumer or provider, in any ruleset -- 'the policy that touches app X'. Each ruleset costs one extra request for its deny rules, so filter where you can.

Inputs: name, labels, enabled, pversion, +4 more.

get-server-changelogA

What changed in this MCP server. Call this when tool behaviour does not match what you expect, after the server has been updated mid-session, or before relying on assumptions formed earlier in a long session -- a cached tools/list and remembered response shapes are not refreshed when the server changes. The unlearn field lists behaviour changes that make previously correct assumptions wrong. Needs no PCE connection.

Inputs: since, unlearn_only.

get-servicesB

Get services from the PCE with optional filtering

Inputs: name, port, proto, description, +3 more.

get-traffic-fingerprintA

A snapshot of who talks to whom on which service -- for the whole org, one environment (scope={env}) or one app (scope={app, env}) -- and the drift against an earlier snapshot. One Explorer query over the window; keys are app-pair x service with the decision set seen (A allowed, P potentially blocked, B blocked), never counts, plus per-app shape: peers in/out, external destinations and sources, services, blocked share, attributed providers. Compare by passing baseline (the fingerprint object this tool returned before) or baseline_days (a second query over the N days before the window): new / changed / gone keys, drift per app, the peers and providers that came and went. A compare across another PCE, org, scope or identity axis is refused; unequal windows and truncated sides are warned, since they inflate new or gone. Use it for 'what changed in payments/prod since last month', 'is this environment's shape stable', or to keep a per-app history.

Inputs: scope, baseline, end_date, start_date, +6 more.

get-traffic-flowsC

Get traffic flows from the PCE with comprehensive filtering options

Inputs: end_date (required), start_date (required), group_by, query_name, +9 more.

get-traffic-flows-summaryA

Summarize traffic flows as structured JSON. Sections: by_process (which binary talks to which destination, on which port, under which policy, and as which user), external_destinations (traffic leaving the managed estate), blocked (what policy is stopping), app_to_app (coarse view). Prefer this over get-traffic-flows for analysis - it is far smaller and answers the usual questions directly.

Inputs: end_date (required), start_date (required), query_name, max_results, +10 more.

get-traffic-timelineA

Time-bucketed flow counts from ONE Explorer query: how many flows and connections fell into each 15m/1h/6h/1d bucket of the window, with every bucket present (zeros included). Use it for 'blocked flows per hour for app X' instead of one summary query per bucket. Rows are bucketed by first_detected; Explorer aggregates a persistent connection (and, for older data, several days) into one row, so rows_spanning_buckets and resolution_note say how much the start of the window is smeared. spikes=true applies the shared rule: a bucket >= 3x the median of the non-zero buckets is a spike, and worst names the largest with its multiple.

Inputs: bucket, spikes, end_date, split_by, +12 more.

get-workload-enforcement-statusA

Get enforcement mode status across all workloads, grouped by application and environment. Shows counts per enforcement mode and identifies apps with mixed enforcement states.

Inputs: app_name, env_name.

get-workloadsA

Get workloads from the PCE. Use detail_level to control breadth vs depth: 'compact' (default) for tabular overviews of thousands of workloads, 'full' for complete data on specific workloads, 'labels_only' for maximum breadth with just identity and labels.

Inputs: name, labels, online, managed, +6 more.

identify-infrastructure-servicesA

Analyze traffic flows to identify infrastructure services in your environment. Builds an app-to-app communication graph and computes centrality metrics to rank apps by how 'infrastructure-like' they are. Infrastructure services (DNS, AD, logging, monitoring platforms, shared databases) are consumed by many apps and should be policy'd first during segmentation rollouts. Returns a ranked list with scores, classification tiers, and connectivity details.

Inputs: top_n, lookback_days, min_connections.

provision-policyA

Provision pending draft policy changes in the PCE. This moves draft rulesets, rules, IP lists, services, and label groups from draft to active state. You can provision all pending changes or specific items by href. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting. Additionally requires an explicit confirm token, so it takes two steps: the first call returns a token to be passed back in the second.

Inputs: hrefs, change_description.

register-pce-credentialsA

Register (or overwrite) PCE credentials for the current authenticated user. After registering, all PCE tools become available in this session. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: api_key (required), pce_host (required), pce_port (required), api_secret (required), +3 more.

ringfence-batchA

Create ringfence policies for multiple applications at once. Optionally auto-discovers infrastructure services and ringfences them first, then standard apps. Uses the same logic as create-ringfence for each app. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting. Additionally requires an explicit confirm token, so it takes two steps: the first call returns a token to be passed back in the second.

Inputs: apps (required), dry_run, auto_order, lookback_days.

update-container-workload-profileA

Update a Container Workload Profile to manage Kubernetes pods in Illumio. Set managed=true and assign labels to start managing pods in a namespace. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: profile_href (required), managed, assign_labels, enforcement_mode.

update-deny-ruleA

Update an existing deny rule in a ruleset. Identify the rule by its href. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: href (required), enabled, consumers, providers, +1 more.

update-iplistA

Update an existing IP List in the PCE. Provide either 'href' or 'name' (but not both) to identify the IP List. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: fqdn, href, name, fqdns, +2 more.

update-labelA

Update an existing label in the PCE. Provide either: 1) href + new_value (optionally with key), or 2) key + value + new_value to identify and update the label. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: key, href, value, new_value.

update-rulesetA

Update an existing ruleset in the PCE. Provide either 'href' or 'name' (but not both) to identify the ruleset. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: href, name, scopes, enabled, +1 more.

update-sec-ruleA

Update an allow rule inside a ruleset, identified by its href. Only the fields you supply change. Use this to refine a rule in place — swapping an inline port for a process-qualified service, for example — instead of rebuilding the ruleset. For deny rules use update-deny-rule. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: href (required), enabled, consumers, providers, +4 more.

update-serviceA

Update an existing service in the PCE. Identify by href (preferred) or name. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: href, name, new_name, description, +3 more.

update-workloadA

Update a workload in the PCE. Identify by href (preferred) or name. Provide only fields you want to change. WRITE OPERATION: changes PCE state. In clients that gate tool calls (Claude Desktop, Claude Code), this pauses for the user to approve it -- the call has not failed and must not be retried while waiting.

Inputs: href, name, labels, hostname, +4 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 56 tools

    Disambiguation3/5

    Most CRUD tools are cleanly separated by resource (workload, label, service, iplist, ruleset, sec-rule, deny-rule), but the read/analysis surface is crowded with near-neighbours: get-traffic-flows, get-traffic-flows-summary, get-traffic-fingerprint, get-traffic-timeline, discover-process-egress, build-identity-graph, find-unmanaged-traffic and find-unknown-endpoints all answer 'what is talking to what'. Likewise enforcement-readiness, get-policy-coverage-report, compliance-check and collect-compliance-evidence are four posture-assessment tools whose boundaries require careful reading of long descriptions. The descriptions do explicitly steer ('use this instead of get-traffic-flows', 'not the same as find-unmanaged-traffic'), which rescues the set from being genuinely ambiguous, but an agent must read a lot of prose to pick correctly.

    Naming Consistency4/5

    The dominant pattern is consistent kebab-case verb-noun: get-/create-/update-/delete- prefixes applied uniformly across workloads, labels, services, iplists, rulesets and rules. Minor deviations exist — enforcement-readiness and ringfence-batch drop the verb, and find- vs get- vs discover- vs identify- are used for similar read actions — but on the whole the naming is predictable.

    Tool Count2/5

    56 tools is well past the point where a single agent can hold the surface in context, especially with eight traffic-analysis variants and four compliance/posture tools. The domain (Illumio PCE segmentation) is broad enough to justify many tools, but this set looks like it has accumulated one tool per question rather than staying scoped, and the write-tool approval boilerplate repeated across ~25 descriptions makes the list expensive to read.

    Completeness3/5

    Coverage is strong for workloads, labels, services, IP lists, rulesets, deny rules and container/cluster artifacts, plus provisioning, draft-vs-active diffing and a rich read-only analytics layer. However there is a notable gap around allow rules: update-sec-rule and delete-sec-rule exist but there is no create-sec-rule (allow rules can only be created indirectly via create-ruleset or create-ringfence), and there is no label-group tooling or VEN/agent listing despite VEN health being referenced in compliance tests. These are workable but force detours.

    Maintenance

    ActivityActive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      A Model Context Protocol server that connects AI assistants to MISP threat intelligence platforms. It enables threat intelligence search, IOC lookup, and event analysis through natural conversation.
      -
    • F
      license
      Not graded
      quality
      D
      maintenance
      A Model Context Protocol server that connects AI assistants to OpenCTI threat intelligence platforms. It enables natural language interaction for searching threat intelligence, analyzing reports, managing indicators, and monitoring connectors.
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      A Model Context Protocol (MCP) server that enables AI assistants to perform comprehensive AWS security analysis through natural language queries, bridging AI with AWS security services.
      2
      Apache 2.0