Flujos de trabajo RAG en n8n

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué cubre este artículo sobre flujos de trabajo RAG en n8n

• Cómo construir pipelines RAG completamente en n8n.
• Cómo indexar documentos, dividirlos en chunks e incrustarlos.
• Cómo conectar Qdrant, Weaviate o Pinecone.
• Cómo funcionan la búsqueda, el reranking y la generación de respuestas.
• Ejemplos prácticos para bases de conocimiento y Q&A de documentos.

Introducción: Flujos de trabajo RAG en n8n explicados

RAG (Retrieval-Augmented Generation) significa lo siguiente: en lugar de dejar que el modelo responda de memoria, primero buscas documentos relevantes y los proporcionas como contexto. En n8n construyes esta pipeline visualmente: el documento entra, se divide en chunks, se incrustan, se almacenan en una base de datos vectorial. Cuando surge una pregunta, buscas chunks similares y se los das al modelo como contexto.

Este artículo está dirigido a usuarios que quieren implementar RAG en n8n. Encontrarás los conceptos fundamentales en RAG local e Integración n8n-Ollama.

¿Por qué necesito flujos de trabajo RAG en n8n?

Imagina que tienes 500 documentos internos. Un compañero pregunta: “¿Cómo funciona la solicitud de vacaciones?” Sin RAG, el modelo genera alucinaciones. Con RAG, el flujo de trabajo busca el documento sobre vacaciones, lo proporciona como contexto y el modelo responde correctamente, con fuentes citadas.

Flujos de trabajo RAG en n8n explicados brevemente

RAG en n8n consta de dos pipelines: la pipeline de indexación (documento → chunks → embeddings → base de datos vectorial) y la pipeline de consulta (pregunta → embedding → chunks similares → contexto → respuesta). Ambas se ejecutan como flujos de trabajo de n8n.

La idea central es: primero buscar, luego responder.

Para quién está pensado este artículo

• Usuarios de n8n que construyen pipelines RAG.
• Gestores de conocimiento que quieren hacer documentos buscables.
• Desarrolladores que construyen sistemas Q&A.
• Auto-hospedadores que ejecutan RAG localmente con Ollama.

Se requieren conocimientos previos en n8n y RAG.

Términos importantes

• RAG - Retrieval-Augmented Generation. Cuándo es útil: el concepto central.
• Embeddings - Representaciones vectoriales. Cuándo es útil: para búsqueda semántica.
• Chunking - Dividir texto en fragmentos. Cuándo es útil: para mejor calidad de recuperación.
• Bases de datos vectoriales - Almacenamiento para embeddings. Cuándo es útil: Qdrant, Weaviate, Pinecone.
• Ollama - Servidor de modelos local. Cuándo es útil: para embeddings y generación.
• Reranking - Reordenar resultados. Cuándo es útil: para mejor relevancia. Ver Reranking.
• Búsqueda híbrida - Semántica + palabras clave. Cuándo es útil: para mejores resultados.

Arquitectura

PIPELINE DE INDEXACIÓN:
Documento (PDF/DOCX)
    │
    ▼
Extracción de texto ──► Chunking ──► Embeddings (Ollama)
    │                                │
    │                                ▼
    └────────────────────────► Base de datos vectorial (Qdrant)
                                   │
PIPELINE DE CONSULTA:               │
Pregunta                            │
    │                              │
    ▼                              │
Embedding (Ollama)                 │
    │                              │
    ▼                              │
Búsqueda vectorial ────────────────┘
    │
    ▼
Chunks principales ──► (Reranking) ──► Contexto + Pregunta ──► LLM (Ollama)
                                                        │
                                                        ▼
                                                    Respuesta

Configuración: Qdrant + Ollama + n8n

version: "3.8"

services:
  qdrant:
    image: qdrant/qdrant:latest
    container_name: qdrant
    restart: unless-stopped
    ports:
      - "6333:6333"
    volumes:
      - qdrant_data:/qdrant/storage
    networks:
      - ai-network

  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    networks:
      - ai-network

  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    restart: unless-stopped
    ports:
      - "5678:5678"
    volumes:
      - n8n_data:/home/node/.n8n
    networks:
      - ai-network

volumes:
  qdrant_data:
  ollama_data:
  n8n_data:

networks:
  ai-network:
    driver: bridge

Pipeline de indexación en n8n

Paso 1: Leer documento

// Read Binary File Node o HTTP Request para upload
// Después: extraer texto

// Function Node: Extrae texto de PDF
const pdfParse = require('pdf-parse');
const buffer = $input.item.binary.data;
const data = await pdfParse(Buffer.from(buffer, 'base64'));
return { text: data.text, filename: $input.item.json.filename };

Paso 2: Chunking

// Function Node: Divide texto en chunks
function chunkText(text, chunkSize = 500, overlap = 50) {
  const chunks = [];
  const sentences = text.split(/[.!?]\s+/);
  let current = "";

  for (const sentence of sentences) {
    if ((current + sentence).length > chunkSize) {
      chunks.push(current.trim());
      current = sentence;
    } else {
      current += " " + sentence;
    }
  }
  if (current) chunks.push(current.trim());
  return chunks;
}

const chunks = chunkText($input.item.json.text);
return chunks.map((chunk, i) => ({
  json: { text: chunk, index: i, source: $input.item.json.filename }
}));

Ver Chunking para estrategias.

Paso 3: Crear embeddings

// HTTP Request Node: Ollama Embeddings
{
  "method": "POST",
  "url": "http://ollama:11434/api/embeddings",
  "body": {
    "model": "nomic-embed-text",
    "prompt": "{{$json.text}}"
  }
}

Ver Modelos de embedding para elegir modelo.

Paso 4: Guardar en Qdrant

// HTTP Request Node: Insertar en Qdrant
{
  "method": "PUT",
  "url": "http://qdrant:6333/collections/dokumente/points",
  "body": {
    "points": [{
      "id": "{{$json.index}}",
      "vector": "{{$json.embedding}}",
      "payload": {
        "text": "{{$json.text}}",
        "source": "{{$json.source}}"
      }
    }]
  }
}

Pipeline de consulta en n8n

Paso 1: Incrustar la pregunta

// HTTP Request: Embedding de consulta
{
  "method": "POST",
  "url": "http://ollama:11434/api/embeddings",
  "body": {
    "model": "nomic-embed-text",
    "prompt": "{{$json.question}}"
  }
}

Paso 2: Buscar chunks similares

// HTTP Request: Búsqueda en Qdrant
{
  "method": "POST",
  "url": "http://qdrant:6333/collections/dokumente/points/search",
  "body": {
    "vector": "{{$json.embedding}}",
    "limit": 5,
    "with_payload": true
  }
}

Paso 3: Generar contexto y respuesta

// Function Node: Construir contexto
const results = $input.item.json.result;
const context = results.map(r => r.payload.text).join("\n\n");
const sources = results.map(r => r.payload.source);

return {
  context,
  sources,
  question: $('Webhook').item.json.question
};

// HTTP Request: Generar respuesta
{
  "method": "POST",
  "url": "http://ollama:11434/api/chat",
  "body": {
    "model": "llama3.1",
    "messages": [
      {"role": "system", "content": "Responde la pregunta basándote en el contexto. Proporciona fuentes. Si el contexto no responde la pregunta, sé honesto al respecto."},
      {"role": "user", "content": "Contexto:\n{{$json.context}}\n\nPregunta: {{$json.question}}"}
    ],
    "stream": false
  }
}

Caso práctico 1: Base de datos de conocimiento para FAQ

Flujo: Bot de FAQ con RAG

Indexación (una sola vez / al actualizar):
  1. Monitorear carpeta: Nuevos documentos
  2. Extraer texto
  3. Chunking
  4. Embeddings (Ollama nomic-embed-text)
  5. Guardar en Qdrant

Consulta (cada pregunta):
  1. Webhook: Llega la pregunta
  2. Embedding de consulta
  3. Qdrant: Top-5 chunks
  4. Contexto + pregunta → Ollama llama3.1
  5. Devolver respuesta + fuentes

Caso práctico 2: Indexar archivos adjuntos de email

Flujo: Hacer buscables los archivos adjuntos de email

1. Trigger IMAP: Nuevo email con adjunto
2. Extraer archivo binario
3. Si es PDF: extraer texto
4. Chunking + embeddings
5. Guardar en Qdrant con metadatos (remitente, fecha)

Caso práctico 3: Búsqueda híbrida

// Function Node: Combinar búsqueda semántica + por palabras clave
const semanticResults = $input.item.json.semantic;
const keywordResults = $input.item.json.keyword;

// Reciprocal Rank Fusion
function rrf(semantic, keyword, k = 60) {
  const scores = {};
  semantic.forEach((r, i) => {
    scores[r.id] = (scores[r.id] || 0) + 1 / (k + i + 1);
  });
  keyword.forEach((r, i) => {
    scores[r.id] = (scores[r.id] || 0) + 1 / (k + i + 1);
  });
  return Object.entries(scores).sort((a, b) => b[1] - a[1]);
}

return { ranked: rrf(semanticResults, keywordResults) };

Ver Búsqueda híbrida.

Mejorar la calidad

Reranking

// Después de la búsqueda vectorial: obtener Top-20, luego reranquear
{
  "method": "POST",
  "url": "http://ollama:11434/api/chat",
  "body": {
    "model": "llama3.1",
    "messages": [
      {"role": "user", "content": "Evalúa la relevancia de este texto para la pregunta [PREGUNTA] en una escala 0-10:\n\n{{$json.chunk_text}}"}
    ]
  }
}

Ver Reranking.

Citas de fuentes

// Siempre incluir las fuentes
return {
  answer: response.message.content,
  sources: results.map(r => ({
    file: r.payload.source,
    chunk: r.payload.text.substring(0, 100) + "..."
  }))
};

Ver Citas de fuentes.

Notas de seguridad

• Control de acceso: ¿Quién puede consultar qué documentos? Filtra según permisos.
• Inyección de prompts: Los documentos pueden contener inyecciones. Ver Inyección de prompts.
• Calidad de datos: Documentos malos generan respuestas malas. Ver Preparar documentos.
• Protección de datos: Todos los datos permanecen localmente con Ollama + Qdrant. Ver Protección de datos.

Errores comunes

• Chunks demasiado grandes: Por encima de 1000 caracteres pierden precisión. 300-800 suele ser óptimo.
• Muy pocos chunks: Top-5 no siempre es suficiente. Obtén Top-20 y reranquea a Top-5.
• Modelo de embedding incorrecto: nomic-embed-text funciona bien, pero multilingual-e5 es mejor para documentos multilingües.
• Sin citas de fuentes: Sin fuentes, la respuesta no se puede verificar.
• Alucinaciones: Sin un buen retrieval, el modelo alucina. Ver Probar calidad.
• Contexto demasiado largo: Muchos chunks sobrecargan el contexto. Ver Longitud de contexto.

Enlaces útiles

• RAG local - Fundamentos de RAG.
• Chunking - División de texto.
• Modelos de embedding - Elegir modelo.
• Bases de datos vectoriales - Qdrant, Weaviate y más.
• Reranking - Mejorar resultados.
• Búsqueda híbrida - Semántica + palabras clave.
• Integración Ollama-n8n - Ollama en n8n.
• Agentes de IA en n8n - Agentes con RAG.

Puntos clave:

• RAG en n8n: pipeline de indexación + pipeline de consulta.
• Ollama para embeddings (nomic-embed-text) y generación (llama3.1).
• Qdrant como base de datos vectorial, n8n orquesta todo.
• La estrategia de chunking y reranking determinan la calidad.
• Siempre incluir fuentes, nunca confiar ciegamente.

FAQ

Fuentes y lecturas complementarias

• Qdrant - Base de datos vectorial.
• Ollama Embeddings - Modelos de embedding.
• n8n Vector Stores - Nodos de almacenamiento vectorial.
• RAG Guide - Técnicas de RAG.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert