n8n y MCP Servers en Automatización Industrial: Conecta IA con tu Planta de Verdad

MCP (Model Context Protocol) es el estándar que faltaba para que la inteligencia artificial dejara de ser un juguete de oficina y empezara a tocar hierro. Combínalo con n8n y tienes un sistema donde un agente IA puede leer datos de tu SCADA, consultar el historial de una máquina y tomar decisiones — todo sin que programes una integración a medida para cada cosa.

Si trabajas en automatización industrial y llevas meses oyendo hablar de agentes IA sin entender cómo encajan en una planta real, esta guía es para ti. Vamos a montar un sistema donde n8n orquesta agentes que se comunican con tus equipos industriales a través de MCP servers. Sin humo, con código.

Qué es MCP y por qué le importa a la industria

MCP (Model Context Protocol) es un protocolo abierto creado por Anthropic que estandariza cómo las aplicaciones de IA se conectan a sistemas externos. Piensa en él como el OPC-UA de la inteligencia artificial: un conector universal que permite que cualquier modelo de lenguaje acceda a herramientas, bases de datos y APIs sin necesidad de integraciones personalizadas para cada una.

La analogía industrial es directa:

• OPC-UA conecta PLCs, SCADA y sistemas de control entre sí con un protocolo estándar.
• MCP conecta modelos de IA con herramientas externas con un protocolo estándar.

¿Por qué importa esto en una fábrica? Porque hasta ahora, si querías que un agente IA consultara datos de producción, tenías que escribir código específico para cada fuente de datos: una API para el SCADA, otra para el ERP, otra para la base de datos de mantenimiento. MCP elimina esa fragmentación.

Arquitectura de MCP en 30 segundos

MCP funciona con un modelo cliente-servidor:

• MCP Client: la aplicación de IA que necesita acceder a datos o herramientas. En nuestro caso, n8n actúa como cliente MCP.
• MCP Server: un servicio que expone capacidades específicas (leer datos, ejecutar acciones, consultar bases de datos). Tú puedes crear MCP servers que expongan tus sistemas industriales.
• Protocolo: comunicación estandarizada basada en JSON-RPC sobre stdio o HTTP con Server-Sent Events (SSE).

Un MCP server expone tres tipos de capacidades:

1. Tools (herramientas): acciones que la IA puede ejecutar. Ejemplo: “leer la temperatura del horno 3”.
2. Resources (recursos): datos que la IA puede consultar. Ejemplo: “historial de alarmas de las últimas 24 horas”.
3. Prompts: plantillas predefinidas para tareas comunes. Ejemplo: “genera un informe de turno con estos datos”.

Por qué n8n es el orquestador perfecto para MCP industrial

n8n ya soporta MCP de forma nativa. Puedes usarlo como cliente MCP (conectándose a MCP servers externos) y como servidor MCP (exponiendo tus workflows de n8n como herramientas MCP que otros agentes pueden llamar). Esta doble capacidad es exactamente lo que necesitas en entornos industriales.

n8n como cliente MCP

El nodo MCP Client Tool de n8n permite que un agente IA dentro de un workflow se conecte a cualquier MCP server. Configuras la conexión (stdio o SSE), y el agente descubre automáticamente las herramientas disponibles y las usa cuando las necesita.

Esto significa que puedes tener un MCP server que lee datos de tu PLC vía OPC-UA, y un agente IA en n8n que lo consulta cuando un operario le pregunta: “¿Cuántas piezas llevamos hoy en la línea 2?“

n8n como servidor MCP

El nodo MCP Server Trigger convierte cualquier workflow de n8n en una herramienta accesible vía MCP. Otros agentes — Claude Desktop, Cursor, aplicaciones propias — pueden llamar a ese workflow como si fuera una función más de su kit de herramientas.

Para industria, esto abre una puerta muy interesante: puedes crear workflows de n8n que encapsulen lógica compleja (consultar producción, cruzar datos de calidad, generar órdenes de mantenimiento) y exponerlos como herramientas que cualquier IA puede usar.

Ventajas frente al enfoque tradicional

Enfoque tradicional	Con n8n + MCP
Una API custom por cada sistema	Un protocolo estándar para todos
Código específico por modelo de IA	Cualquier cliente MCP compatible
Integración rígida, difícil de cambiar	Añadir herramientas es crear un workflow
Sin descubrimiento automático	El agente ve las herramientas disponibles

Caso práctico: monitorización inteligente de producción

Vamos a construir algo real. El objetivo: un sistema donde un agente IA en n8n consulta datos de producción en tiempo real a través de MCP servers y genera alertas inteligentes cuando detecta anomalías.

Arquitectura del sistema

┌─────────────────┐     MCP      ┌──────────────────────┐
│  Agente IA n8n  │◄────────────►│  MCP Server OPC-UA   │
│  (Cliente MCP)  │              │  (datos de PLC/SCADA) │
└────────┬────────┘              └──────────────────────┘
         │
         │  MCP          ┌──────────────────────┐
         ├──────────────►│  MCP Server PostgreSQL│
         │               │  (historial, alarmas) │
         │               └──────────────────────┘
         │
         │  MCP          ┌──────────────────────┐
         └──────────────►│  MCP Server ERP      │
                         │  (órdenes, planning)  │
                         └──────────────────────┘

El agente IA recibe una pregunta (“¿cómo va el turno?”) y decide qué MCP servers consultar. No tiene hardcodeado qué datos pedir: el protocolo le permite descubrir las herramientas disponibles y usarlas según el contexto.

Paso 1: Crear un MCP server para datos industriales

Lo primero es exponer tus datos de planta como un MCP server. Vamos a crear uno en Python que lee datos de un servidor OPC-UA (el protocolo estándar para comunicación industrial).

# mcp_opcua_server.py
from mcp.server import Server, stdio_server
from mcp.types import Tool, TextContent
from opcua import Client as OPCUAClient
import json
import asyncio

app = Server("industrial-opcua")

# Configuración OPC-UA
OPCUA_ENDPOINT = "opc.tcp://192.168.1.10:4840"
NODES = {
    "temperatura_horno": "ns=2;s=Horno.Temperatura",
    "velocidad_linea": "ns=2;s=Linea1.Velocidad",
    "piezas_producidas": "ns=2;s=Linea1.Contador",
    "estado_maquina": "ns=2;s=Linea1.Estado",
}

@app.list_tools()
async def list_tools():
    return [
        Tool(
            name="leer_variable_proceso",
            description="Lee una variable de proceso del PLC/SCADA. "
                        "Variables disponibles: temperatura_horno, "
                        "velocidad_linea, piezas_producidas, estado_maquina",
            inputSchema={
                "type": "object",
                "properties": {
                    "variable": {
                        "type": "string",
                        "description": "Nombre de la variable a leer"
                    }
                },
                "required": ["variable"]
            }
        ),
        Tool(
            name="leer_todas_variables",
            description="Lee todas las variables de proceso de la línea 1",
            inputSchema={"type": "object", "properties": {}}
        ),
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict):
    client = OPCUAClient(OPCUA_ENDPOINT)
    try:
        client.connect()
        if name == "leer_variable_proceso":
            var_name = arguments["variable"]
            if var_name not in NODES:
                return [TextContent(
                    type="text",
                    text=f"Variable '{var_name}' no encontrada. "
                         f"Disponibles: {list(NODES.keys())}"
                )]
            node = client.get_node(NODES[var_name])
            value = node.get_value()
            return [TextContent(
                type="text",
                text=json.dumps({
                    "variable": var_name,
                    "valor": value,
                    "unidad": obtener_unidad(var_name),
                    "timestamp": str(node.get_data_value().SourceTimestamp)
                })
            )]
        elif name == "leer_todas_variables":
            datos = {}
            for var_name, node_id in NODES.items():
                node = client.get_node(node_id)
                datos[var_name] = {
                    "valor": node.get_value(),
                    "unidad": obtener_unidad(var_name)
                }
            return [TextContent(type="text", text=json.dumps(datos))]
    finally:
        client.disconnect()

def obtener_unidad(variable):
    unidades = {
        "temperatura_horno": "°C",
        "velocidad_linea": "m/min",
        "piezas_producidas": "uds",
        "estado_maquina": ""
    }
    return unidades.get(variable, "")

async def main():
    async with stdio_server() as (read, write):
        await app.run(read, write, app.create_initialization_options())

if __name__ == "__main__":
    asyncio.run(main())

Este servidor expone dos herramientas: leer una variable específica o leer todas. Cualquier cliente MCP (incluido n8n) puede descubrirlas y usarlas.

Paso 2: Conectar n8n como cliente MCP

En n8n, la configuración es directa:

1. Crea un nuevo workflow con un nodo AI Agent.
2. Añade un nodo MCP Client Tool como herramienta del agente.
3. En la configuración del MCP Client, selecciona transporte stdio y apunta al script Python:
   • Command: python
   • Arguments: /ruta/a/mcp_opcua_server.py
4. Conecta un modelo de lenguaje (OpenAI, Anthropic, Ollama — el que prefieras).

Ahora el agente IA puede responder preguntas como:

• “¿Cuál es la temperatura actual del horno?”
• “¿Cuántas piezas llevamos producidas?”
• “Dame un resumen del estado de la línea 1”

El agente decide qué herramienta MCP llamar según la pregunta. No hay lógica condicional hardcodeada: el modelo interpreta la pregunta y elige la herramienta apropiada.

Paso 3: Añadir más MCP servers

La gracia de MCP es que escala horizontalmente. Puedes añadir más servidores sin tocar el agente:

MCP Server de históricos (PostgreSQL):

@app.list_tools()
async def list_tools():
    return [
        Tool(
            name="consultar_historico",
            description="Consulta datos históricos de producción. "
                        "Permite filtrar por fecha, línea y variable.",
            inputSchema={
                "type": "object",
                "properties": {
                    "variable": {"type": "string"},
                    "desde": {"type": "string", "description": "Fecha ISO"},
                    "hasta": {"type": "string", "description": "Fecha ISO"},
                    "linea": {"type": "string"}
                },
                "required": ["variable"]
            }
        ),
        Tool(
            name="ultimas_alarmas",
            description="Devuelve las últimas N alarmas de una línea",
            inputSchema={
                "type": "object",
                "properties": {
                    "linea": {"type": "string"},
                    "limite": {"type": "integer", "default": 10}
                }
            }
        )
    ]

MCP Server de mantenimiento (CMMS/ERP):

@app.list_tools()
async def list_tools():
    return [
        Tool(
            name="crear_orden_mantenimiento",
            description="Crea una orden de trabajo de mantenimiento correctivo",
            inputSchema={
                "type": "object",
                "properties": {
                    "equipo": {"type": "string"},
                    "descripcion": {"type": "string"},
                    "prioridad": {
                        "type": "string",
                        "enum": ["baja", "media", "alta", "critica"]
                    }
                },
                "required": ["equipo", "descripcion"]
            }
        )
    ]

En n8n, simplemente añades más nodos MCP Client Tool al mismo agente. Cada uno apunta a un MCP server diferente. El agente tiene acceso a todas las herramientas y decide cuáles usar según la pregunta.

Caso práctico: n8n como MCP Server industrial

El flujo inverso también tiene valor. Imagina que tienes workflows de n8n que encapsulan lógica de negocio compleja: calcular OEE, generar informes de turno, cruzar datos de calidad con producción. Con el nodo MCP Server Trigger, puedes exponerlos como herramientas MCP.

Ejemplo: un workflow de n8n que calcula el OEE (Overall Equipment Effectiveness) de una línea:

1. Crea un workflow con el trigger MCP Server Trigger.
2. Define el nombre de la herramienta: calcular_oee.
3. El workflow recibe los parámetros (línea, turno), consulta la base de datos, calcula disponibilidad × rendimiento × calidad, y devuelve el resultado.

Ahora cualquier agente IA — Claude Desktop, una aplicación interna, otro workflow de n8n — puede llamar a calcular_oee como si fuera una función nativa. No necesita saber que detrás hay 15 nodos de n8n haciendo consultas SQL y cálculos.

Seguridad: MCP en entornos industriales no es plug and play

Antes de entusiasmarte conectando tu SCADA a un agente IA, hablemos de seguridad. Los entornos industriales (OT) tienen reglas estrictas por buenas razones: un comando mal enviado puede parar una línea de producción o, peor, causar daños físicos.

Principios de seguridad para MCP industrial

1. Solo lectura por defecto

Tus MCP servers industriales deberían ser de solo lectura. El agente IA puede consultar temperaturas, contadores y alarmas. Pero no debería poder cambiar setpoints, arrancar motores o modificar recetas. Si necesitas acciones de escritura, implementa un sistema de aprobación humana obligatoria.

2. Segmentación de red

El MCP server que accede al OPC-UA debe vivir en la red industrial o en una DMZ. Nunca expongas el servidor OPC-UA directamente a la red IT. La arquitectura correcta:

Red IT (n8n) → DMZ (MCP Server) → Red OT (OPC-UA / PLCs)

3. Autenticación y autorización

MCP soporta autenticación. Usa tokens o certificados para controlar qué clientes pueden conectarse a cada servidor. Define roles: el agente de producción puede leer datos de línea, pero no alarmas de seguridad.

4. Registro de auditoría

Cada llamada MCP debe quedar registrada: qué agente pidió qué dato y cuándo. En entornos regulados (farmacéutico, alimentación), esto no es opcional — es requisito normativo.

5. Validación de inputs

Si implementas herramientas MCP que aceptan parámetros (por ejemplo, un rango de fechas para consultar históricos), valida estrictamente los inputs. Un agente IA puede generar parámetros inesperados. Sanitiza todo.

Comparativa: MCP vs integraciones directas en n8n

¿Cuándo tiene sentido usar MCP en lugar de los nodos nativos de n8n (HTTP Request, PostgreSQL, etc.)? La respuesta depende de tu escenario:

Usa MCP cuando:

• Quieres que un agente IA decida dinámicamente qué datos consultar.
• Tienes múltiples sistemas que quieres exponer como herramientas reutilizables.
• Quieres que otros agentes (fuera de n8n) accedan a tus workflows.
• Necesitas un catálogo de capacidades que la IA pueda descubrir automáticamente.

Usa nodos nativos cuando:

• El flujo es determinista: siempre se leen los mismos datos en el mismo orden.
• No hay un agente IA tomando decisiones; es un workflow clásico de automatización.
• Necesitas rendimiento máximo sin la sobrecarga del protocolo MCP.

En la práctica, muchos sistemas industriales combinan ambos enfoques. Los workflows deterministas (alertas de umbral, sincronización de datos) usan nodos nativos. Los flujos donde un humano hace preguntas y el sistema responde de forma flexible usan MCP.

Escenarios industriales donde MCP con n8n marca la diferencia

Asistente inteligente de planta

Un operario abre un chat (Telegram, Teams, interfaz web) y pregunta: “¿Por qué la línea 2 lleva 20 minutos parada?” El agente IA en n8n consulta tres MCP servers: el de datos de SCADA (estado de la línea), el de alarmas (qué falló) y el de mantenimiento (si hay una OT abierta). Responde con contexto completo en lenguaje natural.

Informes de turno automáticos

Un workflow programado que al final de cada turno activa un agente IA. El agente usa MCP para recopilar producción, calidad, incidencias y paradas. Genera un informe en texto natural con análisis de causas y sugerencias. Mucho más útil que un PDF con tablas crudas.

Detección proactiva de anomalías

Un agente que cada 15 minutos consulta variables críticas vía MCP, las compara con históricos y decide si algo se sale de lo normal. No es un simple umbral (eso ya lo hace el SCADA): es análisis contextual. “La temperatura subió 5°C, pero hay un cambio de formato programado, así que es normal” vs “La temperatura subió 5°C sin razón aparente — posible fallo en la refrigeración”.

Mantenimiento predictivo asistido

El agente accede vía MCP a datos de vibración, temperatura y horas de funcionamiento de un motor. Cruza esos datos con el historial de mantenimiento. Si detecta un patrón que en el pasado precedió a una avería, crea automáticamente una orden de mantenimiento preventivo.

Cómo empezar: tu primer MCP server industrial en 4 pasos

Si quieres montar un piloto, sigue este orden:

1. Instala las dependencias

pip install mcp opcua
# Para n8n, necesitas la versión 1.44+ que incluye soporte MCP

2. Identifica una fuente de datos simple

No empieces con todo el SCADA. Elige una máquina o línea y expón 3-5 variables. Temperatura, velocidad, contador de piezas. Lo justo para validar el concepto.

3. Crea el MCP server

Usa el ejemplo de código de esta guía como base. Adapta los Node IDs de OPC-UA a los de tu instalación. Prueba que funciona con un cliente MCP simple antes de conectar n8n.

4. Conecta n8n y prueba

Configura el nodo MCP Client Tool en n8n apuntando a tu servidor. Haz preguntas al agente y verifica que las respuestas son correctas. Cuando estés satisfecho, añade más variables y más MCP servers.

Consejo práctico: empieza siempre con datos de solo lectura y en un entorno de prueba. Cuando el sistema lleve semanas funcionando sin problemas, considera moverlo a producción.

El futuro: MCP como capa estándar entre IA e industria

MCP tiene meses de vida y ya lo soportan Claude, ChatGPT, VS Code, Cursor y decenas de herramientas más. Para la industria, supone algo que llevamos años esperando: un estándar abierto para que la IA hable con nuestros sistemas sin integraciones ad hoc.

La combinación de n8n como orquestador visual y MCP como protocolo de conexión baja la barrera de entrada de forma brutal. No necesitas un equipo de desarrollo para conectar un modelo de lenguaje a tu SCADA. Necesitas un ingeniero de automatización que entienda ambos mundos — y ganas de experimentar.

Los fabricantes de SCADA y DCS que muevan rápido y publiquen MCP servers para sus plataformas van a tener una ventaja competitiva seria. Y las plantas que adopten este patrón antes van a poder hacer cosas que hoy suenan a ciencia ficción: operarios que interrogan a sus máquinas en lenguaje natural, sistemas que explican sus propias averías y mantenimiento que se anticipa a los problemas en vez de correr detrás de ellos.

Conclusión

MCP no es otra sigla más para la pila de buzzwords industriales. Es la pieza que conecta la inteligencia artificial — hasta ahora confinada en chatbots y generadores de texto — con el mundo físico de sensores, PLCs y líneas de producción.

Con n8n como orquestador y MCP como protocolo, puedes montar un sistema donde un agente IA tiene acceso real a tus datos de planta y puede actuar sobre ellos (con las protecciones adecuadas). No es teoría: el código de esta guía funciona con un servidor OPC-UA real y n8n 1.44+.

La pregunta ya no es si la IA entrará en la planta. Es cuándo y cómo. MCP con n8n te da un camino concreto para empezar hoy.

---

¿Quieres montar un piloto de IA industrial con n8n y MCP en tu planta? En automatizatodo.com diseñamos e implementamos soluciones de automatización que conectan tus sistemas industriales con inteligencia artificial. Contacta con nosotros y te ayudamos a dar el primer paso.

---

Recursos adicionales:

• Documentación oficial de MCP — Especificación completa del protocolo
• n8n MCP Server Trigger — Documentación del nodo MCP en n8n
• Artículo relacionado: Cómo automatizar procesos industriales — Nuestra guía de automatización industrial paso a paso