Integrar n8n con Ollama

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué cubre este artículo

• Cómo conectar n8n con Ollama.
• Cómo configurar nodos HTTP-Request para la API de Ollama.
• Casos prácticos: clasificación, resumen, traducción, extracción.
• Cómo construir flujos de trabajo RAG con embeddings de Ollama.
• Mejores prácticas para manejo de errores, caché y rendimiento.

Introducción: n8n con Ollama explicado

n8n es una herramienta de automatización de flujos de trabajo que conecta procesos visualmente. Ollama es un servidor local de modelos de IA. Cuando los combinas, puedes construir flujos de trabajo que usen IA localmente: clasificar correos electrónicos, resumir documentos, traducir textos, todo sin la nube, sin costos de API, con control total de tus datos.

Este artículo está dirigido a usuarios que utilizan n8n para automatización de flujos de trabajo e integran Ollama para IA local. Debes entender cómo funciona n8n y cómo se ejecuta Ollama.

¿Por qué necesito n8n con Ollama?

Imagina que deseas clasificar correos electrónicos automáticamente. Sin IA, necesitarías reglas: “Si el asunto es X, entonces carpeta Y”. Pero las reglas son rígidas. Con Ollama en n8n, la IA entiende el contenido y clasifica según el contexto. Todo local, sin que el contenido de los correos viaje a la nube.

n8n con Ollama en pocas palabras

n8n envía solicitudes HTTP a la API de Ollama. La respuesta se procesa en el flujo de trabajo. Todo se ejecuta localmente: n8n en tu servidor, Ollama en tu servidor, ningún dato sale de tu red.

La idea clave es: n8n controla el flujo de trabajo, Ollama proporciona la IA.

Para quién es este artículo

• Usuarios de n8n que quieren integrar IA en flujos de trabajo.
• Usuarios de Ollama que desean automatizar flujos de trabajo.
• Self-hosters que quieren usar IA local.
• Automatizadores que resuelven tareas recurrentes con IA.

Se requiere experiencia previa con n8n y Ollama.

Conceptos clave

• n8n - Automatización de flujos de trabajo. Útil cuando: necesitas la herramienta de flujos.
• Ollama - Servidor de modelos local. Útil cuando: necesitas el backend de IA.
• HTTP-Request-Node - Nodo de n8n para llamadas API. Útil cuando: necesitas comunicarte con Ollama.
• Ollama REST API - Interfaz de Ollama. Útil cuando: es cómo n8n habla con Ollama.
• Embeddings - Representaciones vectoriales. Útil cuando: construyes flujos RAG.
• RAG - Generación aumentada por recuperación. Útil cuando: necesitas flujos basados en conocimiento.
• Docker - Contenedores. Útil cuando: ejecutas n8n y Ollama.

Configuración: Conectar n8n y Ollama

1. Ollama está en ejecución

# Ollama se ejecuta en localhost:11434
ollama serve
ollama list  # Verifica que los modelos estén cargados

2. n8n está en ejecución

# Inicia n8n con Docker
docker run -d \
  --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  --restart unless-stopped \
  n8nio/n8n:latest

3. Red

Si ambos se ejecutan en Docker, deben estar en la misma red:

docker network create n8n-ollama

docker run -d --name ollama --network n8n-ollama -p 11434:11434 ollama/ollama
docker run -d --name n8n --network n8n-ollama -p 5678:5678 n8nio/n8n:latest

# En n8n: la URL es http://ollama:11434 en lugar de http://localhost:11434

Consulta Docker Network para más detalles.

Llamar a la API de Ollama en n8n

Solicitud HTTP básica

// Configuración del nodo HTTP-Request en n8n:
{
  "method": "POST",
  "url": "http://ollama:11434/api/chat",  // o http://localhost:11434
  "headers": {
    "Content-Type": "application/json"
  },
  "body": {
    "model": "llama3.1",
    "messages": [
      {"role": "user", "content": "{{$json.prompt}}"}
    ],
    "stream": false
  }
}

Function-Node para Ollama

// En el nodo Function de n8n:
const response = await this.helpers.httpRequest({
  method: 'POST',
  url: 'http://ollama:11434/api/chat',
  body: {
    model: 'llama3.1',
    messages: [
      { role: 'system', content: 'Eres un asistente útil.' },
      { role: 'user', content: $input.item.json.prompt }
    ],
    stream: false
  },
  json: true
});

return { response: response.message.content };

Caso práctico 1: Clasificación de correos electrónicos

// Flujo de trabajo:
// 1. IMAP-Trigger: Nuevo correo electrónico
// 2. Function: Construir prompt
// 3. HTTP-Request: Ollama clasifica
// 4. Switch: Basado en categoría
// 5. Acciones diversas

// Function-Node (Construir prompt):
const email = $input.item.json;
return {
  prompt: `Clasifica este correo electrónico en una de estas categorías: support, sales, billing, spam, other.

Asunto: ${email.subject}
De: ${email.from}
Contenido: ${email.body}

Responde solo con la categoría, nada más.`
};

// HTTP-Request-Node:
{
  "method": "POST",
  "url": "http://ollama:11434/api/chat",
  "body": {
    "model": "llama3.1",
    "messages": [{"role": "user", "content": "{{$json.prompt}}"}],
    "stream": false
  }
}

// Function-Node (Procesar resultado):
const category = $input.item.json.message.content.trim().toLowerCase();
return { category, email: $input.item.json.email };

Consulta Automatización de correo electrónico para más detalles.

Caso práctico 2: Resumen de documentos

// Flujo de trabajo:
// 1. Watch: Nueva carpeta
// 2. Read Binary File: Leer PDF
// 3. Function: Extraer texto
// 4. HTTP-Request: Ollama resume
// 5. Write File: Guardar resumen

// Function-Node:
const document = $input.item.json;
return {
  prompt: `Resume el siguiente documento en 5 oraciones:\n\n${document.text}`
};

Caso práctico 3: Traducción

// Function-Node:
return {
  prompt: `Traduce al español:\n\n${$input.item.json.text}`
};

// HTTP-Request-Node:
{
  "method": "POST",
  "url": "http://ollama:11434/api/chat",
  "body": {
    "model": "qwen2.5",  // Buen modelo para traducción
    "messages": [{"role": "user", "content": "{{$json.prompt}}"}],
    "stream": false
  }
}

Caso práctico 4: RAG con embeddings de Ollama

// 1. Crear embeddings para documentos
const embedding = await this.helpers.httpRequest({
  method: 'POST',
  url: 'http://ollama:11434/api/embeddings',
  body: {
    model: 'nomic-embed-text',
    prompt: document.text
  },
  json: true
});

// 2. Guardar en base de datos vectorial (p. ej. Qdrant, Pinecone)
await this.helpers.httpRequest({
  method: 'PUT',
  url: 'http://qdrant:6333/collections/docs/points',
  body: {
    points: [{
      id: docId,
      vector: embedding.embedding,
      payload: { text: document.text }
    }]
  },
  json: true
});

// 3. Para consultas: buscar documentos similares
const queryEmbedding = await this.helpers.httpRequest({
  method: 'POST',
  url: 'http://ollama:11434/api/embeddings',
  body: {
    model: 'nomic-embed-text',
    prompt: question
  },
  json: true
});

const similar = await this.helpers.httpRequest({
  method: 'POST',
  url: 'http://qdrant:6333/collections/docs/points/search',
  body: {
    vector: queryEmbedding.embedding,
    limit: 3
  },
  json: true
});

// 4. Generar respuesta con contexto
const context = similar.result.map(r => r.payload.text).join('\n');
const answer = await this.helpers.httpRequest({
  method: 'POST',
  url: 'http://ollama:11434/api/chat',
  body: {
    model: 'llama3.1',
    messages: [
      { role: 'system', content: 'Responde la pregunta basándote en el contexto.' },
      { role: 'user', content: `Contexto: ${context}\n\nPregunta: ${question}` }
    ],
    stream: false
  },
  json: true
});

Consulta RAG local para más detalles.

Ejemplo práctico 5: Extracción de datos

// Estructurar datos extraídos del texto
return {
  prompt: `Extrae del siguiente texto: nombre, correo electrónico, teléfono.

Texto: ${$input.item.json.text}

Responde como JSON:
{"name": "...", "email": "...", "phone": "..."}`
};

// Ollama con format: json para salida estructurada
{
  "model": "llama3.1",
  "messages": [{"role": "user", "content": "{{$json.prompt}}"}],
  "format": "json",
  "stream": false
}

Manejo de errores

// Function-Node con error-handling
try {
  const response = await this.helpers.httpRequest({
    method: 'POST',
    url: 'http://ollama:11434/api/chat',
    body: { model: 'llama3.1', messages: [...], stream: false },
    json: true,
    timeout: 30000  // 30 segundos de timeout
  });
  return { success: true, result: response.message.content };
} catch (error) {
  if (error.code === 'ECONNREFUSED') {
    return { success: false, error: 'Ollama no es accesible' };
  }
  if (error.code === 'ETIMEDOUT') {
    return { success: false, error: 'Timeout' };
  }
  return { success: false, error: error.message };
}

Optimización de rendimiento

1. Selección de modelo

// Para tareas simples: modelo pequeño
model: 'llama3.1:8b'  // Rápido

// Para tareas complejas: modelo grande
model: 'qwen2.5:32b'  // Más lento, pero mejor

2. Caché

// Cachear solicitudes idénticas
const cache = new Map();
const cacheKey = JSON.stringify(prompt);

if (cache.has(cacheKey)) {
  return cache.get(cacheKey);
}

const result = await callOllama(prompt);
cache.set(cacheKey, result);
return result;

3. Procesamiento por lotes

// Agrupar múltiples solicitudes
const batchPrompt = `Clasifica los siguientes textos:
1. ${texts[0]}
2. ${texts[1]}
3. ${texts[2]}

Responde como JSON-array.`;

Consideraciones de seguridad

• Protege Ollama: No expongas Ollama a internet. Consulta API-Schlüssel.
• Valida entradas: Evita inyección de prompts. Consulta Prompt Injection.
• Valida salidas: Verifica las salidas de IA antes de procesarlas.
• Auditoría: Registra todas las llamadas a Ollama. Consulta Protokollierung.
• Aislamiento de red: Ejecuta n8n y Ollama en su propia red Docker. Consulta Docker Netzwerk-Isolation.

Problemas comunes

• URL incorrecta: localhost en Docker es el contenedor mismo, no el host. Usa http://ollama:11434 o host.docker.internal.
• Timeout muy corto: Los modelos grandes necesitan tiempo. Establece el timeout en 60-120 segundos.
• Sin manejo de errores: Si Ollama no es accesible, el workflow no debería fallar.
• Modelo no cargado: Verifica con ollama list si el modelo está disponible.
• Límite de contexto excedido: Los documentos largos deben dividirse en fragmentos.
• Sin streaming: Para respuestas largas, streaming es mejor, pero más complejo de procesar.

Enlaces relacionados

• n8n Guide - n8n en detalle.
• Ollama REST API - Referencia de API.
• Instalar Ollama - Instalación.
• Automatización de correo electrónico - Workflows de correo.
• RAG local - Workflows de conocimiento.
• Integraciones Ollama - Otras herramientas con Ollama.
• Prompt Injection - Seguridad.
• Protokollierung - Logging.

Puntos clave:

• n8n envía solicitudes HTTP a la API de Ollama.
• IA local en workflows sin nube, sin costos de API.
• Aplicaciones: clasificación, resumen, traducción, extracción, RAG.
• El manejo de errores y caché son importantes.
• Seguridad: protege Ollama, valida entradas.

FAQ

Fuentes y material complementario

• Documentación de n8n - Docs de n8n.
• API de Ollama - Referencia de API.
• Docker Networking - Redes en Docker.
• Comunidad de n8n - Foro de n8n.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert