Integración de IA en Node-RED

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué cubre este artículo sobre integración de IA en Node-RED

• Cómo integrar Ollama y otros modelos de IA en Node-RED.
• Cómo trabajar con Function Nodes y Nodes dedicados de IA.
• Cómo lucen los flows basados en eventos (Sensor → IA → Acción).
• Ejemplos prácticos para procesamiento de texto, clasificación y análisis.
• Mejores prácticas para rendimiento, manejo de errores y seguridad.

Introducción: Integración de IA en Node-RED explicada

Node-RED es un editor visual de flows. Integración de IA significa: un Node recibe datos (sensor, correo electrónico, HTTP), un Function Node u Ollama Node los procesa con IA, y otro Node ejecuta una acción. El resultado: automatización impulsada por eventos sin necesidad de frameworks de código.

Este artículo está dirigido a usuarios que quieren añadir funciones de IA a sus flows de Node-RED. Encontrarás los conceptos básicos en Instalar Node-RED y Ollama.

¿Por qué necesito IA en Node-RED?

Imagina que un sensor reporta valores de temperatura inusuales. Un flow clásico envía una alerta. Con IA, el flow analiza los datos, entiende el contexto (“aumento de temperatura después del mantenimiento, probablemente normal”) y decide de forma inteligente si es necesaria una alerta.

IA en Node-RED brevemente

Conectas un Input Node (disparador) con un Function Node que invoca Ollama y un Output Node (acción). O utilizas Nodes dedicados de Ollama desde la paleta. El flow reacciona a eventos y los procesa con IA.

La idea central es: Evento → Procesamiento de IA → Acción.

¿Para quién es este artículo?

• Usuarios de Node-RED que quieren añadir funciones de IA.
• Desarrolladores IoT que analizan datos de sensores con IA.
• Aficionados de Smart Home que desean automatización inteligente.
• Self-hosters que ejecutan flows de IA localmente.

Experiencia previa en Node-RED y Ollama es útil.

Términos importantes

• Node-RED - Editor visual de flows. Cuándo es útil: la plataforma.
• Ollama - Servidor de modelos local. Cuándo es útil: el backend de IA.
• Function Node - Node de JavaScript. Cuándo es útil: para llamadas de IA.
• HTTP Request Node - Node HTTP. Cuándo es útil: para la API de Ollama.
• node-red-contrib-ollama - Nodes de Ollama. Cuándo es útil: para integración sencilla.
• Function Calling - Uso de herramientas. Cuándo es útil: para salidas de IA estructuradas.
• MQTT - Protocolo IoT. Cuándo es útil: para disparadores de sensores.

Método 1: Function Node con fetch()

// Function Node: Llamar a Ollama
const response = await fetch("http://ollama:11434/api/chat", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
        model: "llama3.1",
        messages: [
            { role: "system", content: "Du bist ein Analyse-Assistent." },
            { role: "user", content: msg.payload }
        ],
        stream: false
    })
});

const data = await response.json();
msg.payload = data.message.content;
msg.ki_response = data;
return msg;

Método 2: HTTP Request Node

[Inject/Trigger] → [HTTP Request: Ollama] → [Debug/Action]

HTTP Request Node:
  Method: POST
  URL: http://ollama:11434/api/chat
  Headers: Content-Type: application/json
  Body:
  {
    "model": "llama3.1",
    "messages": [{"role": "user", "content": "{{msg.payload}}"}],
    "stream": false
  }

Método 3: Node Ollama dedicado

# Instalar
cd /data
npm install node-red-contrib-ollama

# O a través del Palette Manager:
# Menu → Manage palette → Install → "ollama"

El Node ofrece configuraciones listas para chat, embeddings y completado.

Ejemplo práctico 1: Analizar datos de sensores

Flow: MQTT Sensor → Análisis de IA → Alerta si hay anomalía

[MQTT In: sensor/temperature]
    │
    ▼
[Function: Construir contexto]
  msg.payload = `Temperatura: ${msg.payload}°C, Hora: ${new Date()},
                 Sensor: Sala, Límite: 30°C`
    │
    ▼
[HTTP Request: Ollama]
  "¿Es esta temperatura crítica? Responde: sí/no + razón"
    │
    ▼
[Switch: ¿Crítica?]
    │
    ├─ sí → [Alert: Telegram/Correo electrónico]
    └─ no → [Debug: OK]

Ejemplo práctico 2: Analizar correo electrónico

Flow: Llega correo → IA clasifica → Ordenar en carpetas

[Email In]
    │
    ▼
[Function: Extraer contenido de correo]
    │
    ▼
[HTTP Request: Ollama]
  "Clasificar: factura, soporte, boletín, spam, otro"
    │
    ▼
[Switch: Categoría]
    │
    ├─ factura → [Move to: Facturas]
    ├─ soporte → [Move to: Soporte]
    ├─ spam → [Delete]
    └─ otro → [Move to: General]

Ejemplo práctico 3: Monitoreo de logs con IA

Flow: Archivo de log → IA analiza → Reporte

[Watch: /var/log/app.log]
    │
    ▼
[Function: Recopilar líneas nuevas]
    │
    ▼
[HTTP Request: Ollama]
  "Analizar estas entradas de log en busca de errores y patrones"
    │
    ▼
[Function: Si hay errores críticos]
    │
    ▼
[Alert: Slack/Correo electrónico]

Ejemplo práctico 4: Comando de voz → IA → Acción

Flow: Procesar comando de voz

[HTTP In: /api/command]  ← de Rhasspy/Home Assistant
    │
    ▼
[HTTP Request: Ollama]
  "Interpretar: '{{msg.payload.command}}'
   Acciones disponibles: licht_an, licht_aus, temperatur_abfragen,
   musik_starten, musik_stoppen
   Responder como JSON: {action: '...', params: {...}}"
    │
    ▼
[Switch: action]
    │
    ├─ licht_an → [call service: light.turn_on]
    ├─ temperatur_abfragen → [MQTT: leer sensor] → [TTS: Respuesta]
    └─ musik_starten → [call service: media_player.play]

Embeddings en Node-RED

// Function Node: Crear embedding
const response = await fetch("http://ollama:11434/api/embeddings", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
        model: "nomic-embed-text",
        prompt: msg.payload
    })
});

const data = await response.json();
msg.embedding = data.embedding;
return msg;

Manejo de errores

// Function Node con manejo de errores
try {
    const response = await fetch("http://ollama:11434/api/chat", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
            model: "llama3.1",
            messages: [{ role: "user", content: msg.payload }],
            stream: false
        }),
        signal: AbortSignal.timeout(30000)  // 30s Timeout
    });

    if (!response.ok) throw new Error(`HTTP ${response.status}`);

    const data = await response.json();
    msg.payload = data.message.content;
    msg.success = true;
} catch (error) {
    msg.payload = "IA no disponible: " + error.message;
    msg.success = false;
    node.error("Error en Ollama: " + error.message, msg);
}
return msg;

Optimización de rendimiento

// Debounce: No llamar a Ollama en cada evento
// Usa context para caché

let cache = context.get("cache") || {};
const key = msg.payload;

if (cache[key] && (Date.now() - cache[key].time) < 60000) {
    // Caché: < 1 minuto de antigüedad
    msg.payload = cache[key].result;
    return msg;
}

// ... Llamada a Ollama ...

cache[key] = { result: msg.payload, time: Date.now() };
context.set("cache", cache);
return msg;

Avisos de seguridad

• Validar entradas: Los datos de sensores y correos electrónicos pueden contener inyección de prompts. Ver Inyección de prompts.
• Aislamiento de red: No expongas Ollama. Ver Aislamiento de red.
• Validar salidas: Verifica las salidas de la IA antes de ejecutar acciones.
• Acciones críticas: Para acciones críticas (alarmas, eliminación), requiere aprobación humana. Ver Aprobación humana.

Errores comunes

• Docker-Netzwerk: localhost en el flujo es el contenedor de Node-RED. Usa http://ollama:11434.
• Timeout muy corto: Los modelos grandes necesitan tiempo. Configura el timeout en 60-120 segundos.
• Sin manejo de errores: Si Ollama falla, el flujo no debería bloquearse.
• Demasiadas llamadas a IA: Con alta frecuencia de eventos, la IA se convierte en un cuello de botella. Cachea o filtra.
• Contexto no persistente: El contexto del flujo se pierde al reiniciar. Usa persistentContext.

Enlaces relacionados

• Guía Node-RED - Node-RED en detalle.
• Instalar Node-RED - Instalación.
• Node-RED Home Assistant - Home Assistant.
• API REST de Ollama - Referencia de API.
• Function Calling - Tool-Calling.
• Automatización de flujos de trabajo - Conceptos básicos.
• Inyección de prompts - Seguridad.

Puntos clave:

• IA en Node-RED: Function Node con fetch(), HTTP Request Node o Nodes dedicados de Ollama.
• IA impulsada por eventos: Sensor → Análisis → Acción.
• Ollama local: sin costes de API, los datos permanecen en tu servidor.
• Manejo de errores y timeout son obligatorios.
• Cacheo con alta frecuencia de eventos.

FAQ

Fuentes y literatura adicional

• Node-RED - Sitio web oficial.
• node-red-contrib-ollama - Node de Ollama.
• API de Ollama - Referencia de API.
• Node-RED Cookbook - Recetas de flujos.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert