Crear agentes de IA en n8n

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué cubre este artículo sobre agentes de IA en n8n

• Cómo construir agentes con el nodo AI-Agent en n8n.
• Cómo conectar herramientas al agente (búsqueda, base de datos, APIs).
• Cómo usar Ollama como backend del agente.
• Cómo funcionan los agentes multi-paso y la memoria.
• Ejemplos prácticos para diferentes tipos de agentes.

Introducción: Agentes de IA en n8n explicados

n8n incluye desde la versión 1.x un nodo AI-Agent dedicado. Este nodo no es simplemente un generador de texto, sino un verdadero agente: puede llamar herramientas, tomar decisiones y ejecutar múltiples pasos para resolver una tarea. Combinado con Ollama, todo funciona localmente.

Este artículo va dirigido a usuarios que quieren construir agentes reales en n8n, no solo enviar prompts simples. Encontrarás los fundamentos en Agentes de IA e Integración n8n-Ollama.

Por qué necesito agentes de IA en n8n

Un flujo de trabajo simple llama al modelo una sola vez: “Resume este texto”. Un flujo de trabajo con agente funciona diferente: el agente recibe un objetivo (“Investiga este tema y crea un reporte”), decide por sí mismo qué herramientas necesita (búsqueda web, lector de documentos, calculadora) y ejecuta varios pasos hasta alcanzar el objetivo.

Agentes de IA en n8n explicados brevemente

El nodo AI-Agent en n8n conecta un modelo de lenguaje (Ollama, OpenAI, Claude) con herramientas (HTTP Request, código, base de datos, búsqueda). El agente planifica por sí mismo, invoca herramientas e itera hasta resolver la tarea.

La idea central es: Modelo + Herramientas + Bucle = Agente.

Para quién es este artículo

• Usuarios de n8n que quieren ir más allá de prompts simples.
• Automatizadores que construyen flujos de trabajo con agentes.
• Self-hosters que ejecutan agentes localmente con Ollama.
• Desarrolladores que utilizan n8n como plataforma de agentes.

Tener conocimientos previos en n8n y agentes de IA es útil.

Términos importantes

• AI Agent Node - Nodo de n8n para agentes. Cuándo es útil: el corazón del sistema.
• Tool - Herramienta para el agente. Cuándo es útil: lo que el agente puede invocar.
• Ollama - Servidor de modelos local. Cuándo es útil: como backend del agente.
• Function Calling - Mecanismo de uso de herramientas. Cuándo es útil: cómo el agente invoca herramientas.
• Memory - Memoria de conversación. Cuándo es útil: para agentes multi-turno.
• Window Buffer Memory - Memoria simple. Cuándo es útil: para conversaciones.
• ReAct - Razonamiento + Acción. Cuándo es útil: el patrón del agente.

El nodo AI-Agent en detalle

Estructura básica

El nodo AI-Agent tiene varios conectores:

                    ┌──────────────────┐
Trigger ──────────► │   AI Agent Node  │ ──► Salida
                    │                  │
   Model ─────────► │  ○ Chat Model    │
   Memory ────────► │  ○ Memory        │
   Tool 1 ────────► │  ○ Tool          │
   Tool 2 ────────► │  ○ Tool          │
                    └──────────────────┘

• Chat Model: El modelo de lenguaje (Ollama, OpenAI, etc.)
• Memory: Opcional, para contexto de conversación
• Tool: Múltiples herramientas que el agente puede invocar

Tipos de agentes

n8n ofrece varios tipos de agentes:

Configuración: Ollama como modelo de agente

1. Configurar Chat Model

Añade un nodo Ollama Chat Model y conéctalo a la entrada Chat-Model del nodo AI-Agent:

Ollama Chat Model:
  Model: llama3.1
  Base URL: http://ollama:11434
  Temperature: 0.3

Importante: Para invocar herramientas necesitas un modelo que lo soporte. Consulta Function Calling.

2. Modelos adecuados para Function Calling

Conectar herramientas

Herramienta 1: HTTP-Request (Búsqueda web)

// Custom Tool Node: Búsqueda web via SearXNG
{
  "name": "web_search",
  "description": "Busca información actual en la web. Input: consulta de búsqueda como string.",
  "schema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" }
    }
  }
}

// En el Tool-Node: HTTP Request a SearXNG
// POST http://searxng:8080/search?q={{query}}&format=json

Herramienta 2: Código (Cálculos)

// Herramienta de código para cálculos
// El agente puede ejecutar código JavaScript

const input = $json.input;
// Ejemplo: cálculo de porcentajes
const result = eval(input);
return { result };

Herramienta 3: Base de datos (Postgres)

// Herramienta Postgres: El agente puede consultar la base de datos
{
  "name": "query_database",
  "description": "Ejecuta una consulta SQL en la base de datos de clientes.",
  "schema": {
    "type": "object",
    "properties": {
      "sql": { "type": "string" }
    }
  }
}

Herramienta 4: Flujo de trabajo como herramienta

Un patrón poderoso: otro flujo de trabajo de n8n se integra como herramienta:

AI Agent
  └─ Herramienta: "Procesar documento"
       └─ Sub-flujo:
            ├─ Descargar PDF
            ├─ Extraer texto
            └─ Resumir

Ejemplo práctico 1: Agente de investigación

Flujo de trabajo: Agente de investigación

1. Webhook Trigger: El tema llega
2. Nodo AI Agent:
   - Modelo: Ollama llama3.1
   - Herramientas:
     * web_search (SearXNG)
     * fetch_page (HTTP Request)
     * save_note (Código)
3. Prompt del agente:
   "Investiga el tema [TEMA].
    Usa web_search para encontrar fuentes,
    fetch_page para obtener detalles,
    save_note para resultados intermedios.
    Al final, crea un reporte con fuentes."
4. Nodo Email: Enviar reporte

Ejemplo práctico 2: Agente de tickets

Flujo de trabajo: Agente de tickets de soporte

1. Webhook: Nuevo ticket
2. Nodo AI Agent:
   - Modelo: Ollama qwen2.5
   - Memory: Window Buffer (para seguimientos)
   - Herramientas:
     * knowledge_base (RAG via Qdrant)
     * ticket_status (Base de datos)
     * create_response (Código)
3. Prompt del agente:
   "Responde el ticket de soporte.
    Primero busca en la base de conocimiento.
    Verifica el estado del ticket.
    Si no encuentras respuesta: escalala."
4. Nodo IF: ¿Escalado? → A humanos / Enviar respuesta

Ejemplo práctico 3: Agente de base de datos

Flujo de trabajo: Agente SQL

1. Schedule Trigger: Diariamente a las 8:00
2. Nodo AI Agent (SQL Agent):
   - Modelo: Ollama llama3.1
   - Herramientas: Postgres (automáticamente como herramienta SQL)
3. Prompt:
   "Analiza las cifras de ventas de la última semana.
    Crea un reporte con los productos principales y tendencias."
4. Slack/Email: Enviar reporte

Configurar memoria

Window Buffer Memory

// Memoria simple: Últimos N mensajes
{
  "type": "windowBuffer",
  "windowSize": 10  // Últimos 10 mensajes
}

Memoria Persistente (Redis/Postgres)

Para conversaciones de larga duración:

// Redis Memory
{
  "type": "redis",
  "host": "redis",
  "port": 6379,
  "sessionKey": "{{$json.session_id}}"
}

Manejo de Errores en Agentes

// Lógica de reintentos en el nodo del agente
{
  "maxIterations": 10,      // Máx. 10 llamadas a herramientas
  "returnIntermediateSteps": true  // Debugging
}

// Después del agente: verificar éxito
const output = $json.output;
if (!output || output.includes("I don't know")) {
  // Fallback o escalado
  return { status: "failed", needs_human: true };
}

Guardrails para Agentes

// Nodo de guardrail antes del agente
function validateInput(input) {
  // Filtrar inyección de prompts
  const dangerous = ["ignore previous", "system:", "forget all"];
  for (const pattern of dangerous) {
    if (input.toLowerCase().includes(pattern)) {
      throw new Error("Potential prompt injection");
    }
  }
  return input;
}

Consulta Configurar guardrails e Inyección de prompts.

Recomendaciones de Seguridad

• Limitar permisos de herramientas: el agente solo debe leer lo que necesita. Consulta Permisos de herramientas.
• Max Iterations: limita el número de llamadas a herramientas, de lo contrario el agente puede ejecutarse indefinidamente.
• Validar output: las acciones críticas (enviar correo, eliminar datos) deben aprobarse manualmente. Consulta Aprobación manual.
• Logging: registra todas las decisiones del agente. Consulta Registro.
• Sandboxing: ejecuta código generado de forma aislada. Consulta Sandboxing.

Trampa Típicas

• Modelo sin Function Calling: no todos los modelos pueden llamar herramientas. Usa llama3.1 o qwen2.5.
• Demasiadas herramientas: más de 5-7 herramientas sobrecargan el modelo. Menos es más.
• Descripciones de herramientas pobres: el modelo decide qué herramienta usar basándose en la descripción. Sé preciso.
• Sin límite de iteraciones: los agentes pueden quedar atrapados en bucles. Siempre establece maxIterations.
• Contexto sobrecargado: los outputs largos de herramientas saturan el contexto. Trunca.
• Sin fallback: si el agente falla, debe haber un fallback.

Enlaces Relacionados

• Guía n8n - n8n en detalle.
• Integración n8n-Ollama - Ollama en n8n.
• Instalación n8n - configurar n8n.
• Conceptos Básicos de Agentes IA - qué son los agentes.
• Function Calling - entender Function Calling.
• Permisos de herramientas - asegurar agentes.
• Registro - registrar agentes.

Puntos Clave:

• El nodo AI Agent conecta modelo, herramientas y memoria en un verdadero agente.
• Ollama con llama3.1 o qwen2.5 como backend local.
• Herramientas: HTTP Request, Code, Bases de datos, incluso sub-workflows.
• Establece Max Iterations, formula descripciones de herramientas precisas.
• Seguridad: permisos de herramientas, validación de output, logging.

FAQ

Fuentes y lecturas complementarias

• n8n AI Agent Node - Documentación.
• Ollama Function Calling - Soporte de herramientas en Ollama.
• ReAct Pattern - Razonamiento + Acción.
• LangChain Agents - Conceptos sobre agentes.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert