n8n + LangChain: Crea Pipelines de IA Personalizados en 10 Minutos (Guía 2025)

n8n + LangChain: Crea Pipelines de IA Personalizados en 10 Minutos

¿Estás hasta las narices de copiar y pegar en ChatGPT? ¿Quieres automatizar tus flujos de IA pero no tienes ganas de escribir 500 líneas de Python? Estás en el lugar adecuado, porque hoy vamos a combinar la potencia visual de n8n con el cerebro de LangChain para crear pipelines de IA que funcionen solos mientras tú te tomas una cerveza.

En esta guía aprenderás a crear desde chatbots simples hasta agentes autónomos que buscan en tus datos, ejecutan acciones y toman decisiones. Todo sin salir del editor visual de n8n.

⚡ ¿Por qué combinar n8n y LangChain? La unión perfecta

n8n es la navaja suiza de la automatización: conecta APIs, procesa datos y orquesta workflows complejos con drag & drop. Pero cuando añades LangChain, le das superpoderes de IA:

• 🧠 Memoria conversacional: Chatbots que recuerdan el contexto
• 📚 RAG (Retrieval Augmented Generation): IA que responde con TUS datos
• 🤖 Agentes autónomos: IA que toma decisiones y ejecuta acciones
• 🔗 Chains personalizados: Pipelines complejos con lógica custom
• 🌐 Conectar múltiples LLMs: OpenAI, Anthropic, Ollama local, etc.

Casos de uso reales:

• 📧 Soporte técnico automatizado: Bot que busca en tu documentación y ejecuta comandos
• 🗂️ Asistente de investigación: Lee PDFs, extrae info y genera resúmenes
• 💬 Chatbot para e-commerce: Consulta inventario, recomienda productos
• 🔍 Analista de datos: Responde preguntas sobre tu base de datos SQL
• 📊 Generador de reportes: Extrae métricas, las analiza con IA y envía informe

🧰 Herramientas que necesitarás

• n8n: El cerebro orquestador visual (drag & drop) – guía completa aquí
• LangChain: Framework para conectar y personalizar modelos de lenguaje
• Un modelo LLM: OpenAI (GPT-4o), Anthropic (Claude), Ollama local o OpenRouter
• Base de datos: PostgreSQL o SQLite para persistencia (opcional)
• Vector DB: Qdrant, Pinecone o ChromaDB para RAG (opcional pero recomendado)
• Un servidor: PC local, Raspberry Pi 4+, o servidor casero con Docker

1️⃣ Instalación: Montando el Laboratorio

Opción A: Instalación local con Node.js

# Instalar Node.js 18+ (si no lo tienes)
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs

# Instalar n8n globalmente
npm install -g n8n

# Ejecutar n8n
n8n

# La interfaz estará disponible en http://localhost:5678

Opción B: Instalación con Docker (Recomendada)

# Crear directorio para datos persistentes
mkdir -p ~/.n8n

# Ejecutar n8n con Docker
docker run -it --rm \
  --name n8n \
  -p 5678:5678 \
  -v ~/.n8n:/home/node/.n8n \
  docker.n8n.io/n8nio/n8n

# Para producción, añade restart always:
docker run -d \
  --name n8n \
  --restart always \
  -p 5678:5678 \
  -v ~/.n8n:/home/node/.n8n \
  -e N8N_BASIC_AUTH_ACTIVE=true \
  -e N8N_BASIC_AUTH_USER=admin \
  -e N8N_BASIC_AUTH_PASSWORD=tu_password_seguro \
  docker.n8n.io/n8nio/n8n

Opción C: Docker Compose (Mejor para Producción)

# docker-compose.yml
version: '3.8'

services:
  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: n8n
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=cambiar_esto
      - N8N_HOST=0.0.0.0
      - WEBHOOK_URL=https://tu-dominio.com/
      - GENERIC_TIMEZONE=Europe/Madrid
    volumes:
      - ~/.n8n:/home/node/.n8n
    networks:
      - n8n-network

  postgres:
    image: postgres:15
    container_name: n8n-postgres
    restart: always
    environment:
      POSTGRES_USER: n8n
      POSTGRES_PASSWORD: cambiar_esto
      POSTGRES_DB: n8n
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - n8n-network

networks:
  n8n-network:
    driver: bridge

volumes:
  postgres-data:

# Levantar el stack
docker-compose up -d

# Ver logs
docker-compose logs -f n8n

Truco profesional: Si vas a usar n8n en producción, conecta PostgreSQL en vez de SQLite. Es mucho más robusto para workflows concurrentes.

2️⃣ Primera Conexión: Configurar tu LLM

Tienes varias opciones según tu presupuesto y necesidades de privacidad:

Opción A: OpenAI (API de pago, mejor calidad)

1. Accede a n8n: http://localhost:5678
2. Crea un workflow: Workflows → + New Workflow
3. Añade nodo OpenAI Chat Model:
   • Busca con + → «OpenAI»
   • Selecciona «OpenAI Chat Model»
4. Configura credenciales:
   • Clic en «Create New Credential»
   • API Key: Obtener en platform.openai.com/api-keys
   • Guardar
5. Configura el modelo:
   • Model: gpt-4o (mejor calidad) o gpt-4o-mini (más barato)
   • Temperature: 0.7 (creatividad) o 0 (determinista)
   • Max Tokens: 2000 (ajustar según necesidad)

Costos aproximados (Diciembre 2024):

• GPT-4o: $5 / 1M tokens input, $15 / 1M tokens output
• GPT-4o-mini: $0.15 / 1M tokens input, $0.60 / 1M tokens output
• Para un chatbot con 1000 conversaciones/día (~100k tokens): $1-5/día

Opción B: Anthropic Claude (Mejor razonamiento)

# En n8n, añadir nodo HTTP Request
# Método: POST
# URL: https://api.anthropic.com/v1/messages
# Headers:
#   x-api-key: tu_api_key_anthropic
#   anthropic-version: 2023-06-01
#   Content-Type: application/json

# Body (JSON):
{
  "model": "claude-3-5-sonnet-20241022",
  "max_tokens": 2000,
  "messages": [
    {
      "role": "user",
      "content": "{{$json.pregunta}}"
    }
  ]
}

¿Por qué Claude? Mejor para razonamiento largo, análisis de código y seguir instrucciones complejas. Similar en precio a GPT-4o.

Opción C: Ollama (100% Local y Gratis)

Ideal si tienes una GPU NVIDIA o quieres privacidad total.

# Instalar Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Descargar modelo (ejemplos)
ollama pull llama3.2          # 3B - Rápido, 8GB VRAM
ollama pull mistral           # 7B - Equilibrado, 16GB VRAM
ollama pull deepseek-r1:14b   # 14B - Mejor calidad, 24GB VRAM
ollama pull llama3.1:70b      # 70B - Producción, 48GB+ VRAM

# Verificar que funciona
ollama run llama3.2 "Hola, eres un asistente útil"

# Ollama expone API en http://localhost:11434

Configurar en n8n:

# Nodo: HTTP Request
Método: POST
URL: http://localhost:11434/api/chat
Headers:
  Content-Type: application/json

Body (JSON):
{
  "model": "llama3.2",
  "messages": [
    {
      "role": "system",
      "content": "Eres un asistente experto en automatización con n8n y LangChain."
    },
    {
      "role": "user",
      "content": "{{$json.pregunta}}"
    }
  ],
  "stream": false
}

Ventajas Ollama:

• ✅ Gratis (100% local)
• ✅ Privacidad total (datos no salen de tu servidor)
• ✅ Sin límites de requests
• ❌ Necesitas GPU con 8GB+ VRAM para modelos decentes
• ❌ Calidad inferior a GPT-4o (pero DeepSeek R1 70B se acerca)

Si tienes una GPU NVIDIA buena, monta tu servidor IA casero con Ollama + n8n.

Opción D: OpenRouter (Acceso a 200+ Modelos)

La navaja suiza: un solo API key para GPT-4, Claude, Gemini, Llama, etc.

# Nodo: HTTP Request
Método: POST
URL: https://openrouter.ai/api/v1/chat/completions
Headers:
  Authorization: Bearer tu_api_key_openrouter
  Content-Type: application/json

Body:
{
  "model": "anthropic/claude-3.5-sonnet",
  "messages": [
    {"role": "user", "content": "{{$json.pregunta}}"}
  ]
}

Modelos populares en OpenRouter:

• anthropic/claude-3.5-sonnet – Mejor razonamiento
• openai/gpt-4o – General purpose
• google/gemini-2.0-flash-exp:free – Gratis, rápido
• meta-llama/llama-3.1-405b – Open source potente

Guía completa: Crea tu chatbot con n8n + OpenRouter

3️⃣ Integración LangChain: El Poder Real

n8n tiene nodos nativos de LangChain, lo que significa que no necesitas escribir código Python. Todo desde la interfaz visual.

Nodos LangChain disponibles en n8n:

• 🧠 AI Agent: Agentes que toman decisiones y usan herramientas
• 💬 AI Chain: Chains personalizados con prompt templates
• 📚 Vector Store: Integración con Pinecone, Qdrant, Supabase
• 📄 Document Loaders: Cargar PDFs, CSVs, URLs
• ✂️ Text Splitters: Dividir documentos en chunks
• 🔢 Embeddings: Generar vectores con OpenAI, Cohere, HuggingFace
• 🧰 Tools: Herramientas para que agentes ejecuten acciones

Ejemplo básico: Chain con memoria

# Nodo: AI Chain
Modelo: OpenAI Chat Model (credential configurado)
Prompt Template:
  System: "Eres un asistente experto en n8n. Ayuda a los usuarios a crear workflows eficientes."
  Human: "{{$json.pregunta}}"

Memoria: Buffer Memory
  - Session ID: {{$json.user_id}}
  - Contexto máximo: 10 mensajes
  - Tipo: ConversationBufferMemory

Output Parser: String (por defecto)

Este chain simple ya tiene memoria conversacional. El usuario puede hacer preguntas de seguimiento y el LLM recordará el contexto.

4️⃣ RAG (Retrieval Augmented Generation): IA con TUS Datos

Esta es la killer feature: hacer que la IA responda basándose en tu documentación, bases de datos o archivos. No más alucinaciones genéricas.

Arquitectura RAG completa en n8n

Fase 1: Ingestión de documentos (ejecutar una vez)

1. Trigger: Manual o Schedule (cada 24h para actualizar)
2. Cargar documentos:
   • Nodo HTTP Request → Tu API/docs
   • O nodo Read Binary Files → PDFs locales
3. Procesar documentos:
   • Nodo Extract from File → Extrae texto de PDFs
   • Nodo Recursive Character Text Splitter:
     • Chunk Size: 1000
     • Chunk Overlap: 200
4. Generar embeddings:
   • Nodo Embeddings OpenAI o Embeddings Cohere
   • Model: text-embedding-3-small (OpenAI, barato)
5. Almacenar en vector DB:
   • Nodo Pinecone Vector Store o Qdrant
   • Index name: mi-documentacion
   • Insert mode: Insert

Fase 2: Query (cada vez que un usuario pregunta)

1. Trigger: Webhook o integración Telegram/Slack
2. Buscar contexto relevante:
   • Nodo Pinecone Vector Store
   • Operation: Retrieve Documents
   • Query: {{$json.pregunta}}
   • Top K: 3 (devuelve 3 documentos más relevantes)
3. Generar respuesta con contexto:
   • Nodo AI Chain
   • Prompt Template:

System: Eres un asistente experto. Responde SOLO basándote en el contexto proporcionado. Si no sabes, di "No tengo esa información".

Contexto:
{{$node["Pinecone Vector Store"].json["documents"]}}

Pregunta del usuario:
{{$json.pregunta}}

Ventajas de este sistema RAG:

• ✅ Respuestas basadas en TUS datos (no genéricas)
• ✅ Siempre actualizado (re-indexa documentos diariamente)
• ✅ Cita fuentes (metadata incluye URL origen)
• ✅ Sin alucinaciones (si dice «no sé», realmente no está en tus docs)

Guía completa RAG: RAG desde Cero – Dale Memoria a tu IA

5️⃣ Agentes Autónomos: IA que Ejecuta Acciones

Los agentes son el siguiente nivel: pueden decidir qué herramientas usar y ejecutar acciones automáticamente.

Ejemplo: Agente de soporte técnico

Este agente puede:

1. Buscar en la documentación (RAG)
2. Verificar estado del servidor (SSH command)
3. Reiniciar servicios si es necesario
4. Consultar logs
5. Responder al usuario

Configuración en n8n:

# Nodo: AI Agent
Agent Type: OpenAI Functions
LLM: OpenAI GPT-4o (necesita function calling)
System Message: "Eres un agente de soporte técnico. Tu trabajo es diagnosticar y resolver problemas."

Tools (herramientas disponibles):
  1. Search Documentation
     - Tipo: Vector Store Retriever
     - Vector Store: Pinecone
     - Description: "Busca en la documentación técnica"

  2. Check Server Status
     - Tipo: HTTP Request
     - URL: https://tu-api.com/server/status
     - Description: "Verifica el estado del servidor"

  3. Restart Service
     - Tipo: Custom Code (Node.js)
     - Code:
       // Ejecutar comando SSH o llamar API
       const result = await $http.post('https://tu-api.com/restart', {
         service: $parameter.serviceName
       });
       return result;
     - Description: "Reinicia un servicio específico"

Memoria: Buffer Memory (para recordar conversación)

Ejemplo de conversación:

Usuario: "Mi app no responde, ¿qué pasa?"

Agente (decisión interna):
  1. Primero verifico estado servidor → Tool: Check Server Status
  2. Resultado: CPU al 99%, servicio app-worker caído
  3. Busco en docs qué hacer → Tool: Search Documentation
  4. Encuentro: "Si app-worker cae, reiniciar con..."
  5. Ejecuto solución → Tool: Restart Service
  6. Verifico que funciona → Tool: Check Server Status

Agente: "He detectado que el servicio app-worker estaba caído. Lo he reiniciado y ahora todo funciona correctamente. El problema era un pico de CPU que lo tumbó. He consultado los logs y no parece un error recurrente."

6️⃣ Casos de Uso Reales Completos

Caso 1: Asistente de Investigación con PDFs

Workflow:

1. Usuario sube PDF por Telegram
2. n8n extrae texto del PDF
3. Divide en chunks (Text Splitter)
4. Genera embeddings y almacena en Qdrant
5. Usuario puede hacer preguntas sobre el documento
6. RAG busca fragmentos relevantes y responde

Nodos clave:

Telegram Trigger
  → Extract PDF Text
  → Text Splitter
  → Generate Embeddings
  → Store in Qdrant
  → Telegram Reply "Listo, pregúntame lo que quieras"

[Nueva conversación]
Telegram Trigger
  → Query Qdrant
  → AI Chain (contexto + pregunta)
  → Telegram Reply

Caso 2: Chatbot E-commerce con Inventario Real

Herramientas del agente:

• search_products: Busca productos en base de datos SQL
• check_stock: Verifica disponibilidad
• get_recommendations: Productos similares con embeddings
• create_order: Genera orden de compra

-- Tool: search_products
SELECT * FROM products
WHERE name ILIKE '%{{$parameter.query}}%'
  OR description ILIKE '%{{$parameter.query}}%'
LIMIT 5;

-- Tool: check_stock
SELECT stock, warehouse_location
FROM inventory
WHERE product_id = {{$parameter.productId}};

Caso 3: Automatización de Reportes Semanales

Workflow Schedule (cada Lunes 9am):

1. Query PostgreSQL → Métricas de la semana
2. AI Chain → Analiza datos y genera insights
3. AI Agent → Decide qué métricas son más importantes
4. Generate Chart (QuickChart API) → Gráficos visuales
5. Format Email (HTML template)
6. Send Email (Gmail/SMTP)
7. Post to Slack → Canal #analytics

7️⃣ Troubleshooting y Optimización

❌ Problema: Respuestas lentas (>10s)

Causas comunes:

• Modelo muy grande (GPT-4 turbo es lento)
• Demasiado contexto en RAG (chunks muy grandes)
• API rate limits

Soluciones:

• ✅ Usar GPT-4o-mini o Claude Haiku (3-5x más rápido)
• ✅ Reducir Top K de 5 a 3 en vector search
• ✅ Añadir nodo Cache para preguntas frecuentes
• ✅ Usar streaming (mostrar respuesta mientras se genera)

❌ Problema: RAG devuelve info irrelevante

Soluciones:

• ✅ Mejorar chunk strategy (overlap 200 → 300)
• ✅ Añadir metadata filters (fecha, categoría)
• ✅ Usar embeddings más potentes (text-embedding-3-large)
• ✅ Re-ranking con Cohere Rerank API

❌ Problema: Agente entra en loops infinitos

Soluciones:

• ✅ Limitar max iterations del agente (default: 15)
• ✅ Mejorar descriptions de tools (ser más específico)
• ✅ Añadir lógica IF antes del agente (pre-classify)

❌ Problema: Costos muy altos

Optimizaciones:

• 💰 Cambiar embeddings: OpenAI → Cohere (3x más barato)
• 💰 Usar GPT-4o-mini para tareas simples
• 💰 Cache de respuestas frecuentes (Redis)
• 💰 Ollama local para desarrollo/staging
• 💰 Prompt compression (remove fluff)

8️⃣ Mejores Prácticas y Tips Avanzados

1. Prompt Engineering en n8n

System: Eres {{$json.role}}. Tu objetivo es {{$json.objective}}.

Contexto actual:
- Usuario: {{$json.user_name}}
- Historial: {{$node["Get History"].json.last_5}}
- Datos relevantes: {{$node["Vector Search"].json.results}}

Instrucciones:
1. Lee el contexto cuidadosamente
2. Si falta información, pregunta al usuario
3. Sé conciso pero completo
4. Cita fuentes cuando sea posible

Pregunta: {{$json.question}}

2. Error Handling Robusto

# Añadir nodo "Error Trigger" después del AI Agent
# Si el agente falla, ejecuta workflow de fallback:

Error Trigger
  → Log to File
  → Notify Admin (Telegram/Slack)
  → Send Generic Response to User
  → Increment Error Counter (Redis)

3. A/B Testing de Prompts

# Nodo IF (50% traffic split)
IF {{$json.user_id}} % 2 == 0
  → Prompt A (directo)
ELSE
  → Prompt B (con ejemplos)

# Track metrics: response time, user satisfaction, accuracy

4. Observabilidad y Métricas

# Después de cada AI response, loggear:
{
  "timestamp": "{{$now}}",
  "user_id": "{{$json.user_id}}",
  "model": "gpt-4o",
  "tokens_used": {{$node["AI Chain"].json.usage.total_tokens}},
  "latency_ms": {{$executionTime}},
  "prompt_length": {{$node["AI Chain"].json.prompt.length}},
  "response_length": {{$node["AI Chain"].json.response.length}}
}

# Store in PostgreSQL o enviar a Grafana/Datadog

9️⃣ Recursos y Siguientes Pasos

Guías relacionadas en El Diario IA:

• 🤖 Guía Completa n8n v2 (4,900 palabras)
• 📚 RAG: Dale Memoria a tu IA (guía completa)
• 💬 Bot Telegram con n8n (paso a paso)
• 🏠 Monta tu Servidor IA Casero
• 🐋 Docker Compose para Homelab

Documentación oficial:

• 📘 n8n Documentation
• 🦜 LangChain Docs
• 🔗 n8n LangChain Integration

Comunidades activas:

• 💬 n8n Community Forum
• 🐦 LangChain Discord
• 📱 Reddit: r/n8n, r/LangChain

🎸 Conclusión: Automatiza lo Aburrido, Vive lo Interesante

Con n8n + LangChain has creado un sistema de IA que:

• ✅ Responde basándose en TUS datos (RAG)
• ✅ Recuerda conversaciones (memoria)
• ✅ Toma decisiones autónomas (agentes)
• ✅ Ejecuta acciones reales (tools)
• ✅ Conecta con 400+ apps (integraciones n8n)

Y lo mejor: Todo configurable con drag & drop, sin escribir cientos de líneas de Python. Solo te enfocas en la lógica de negocio, n8n se encarga del resto.

¿Próximos pasos?

1. 🚀 Empieza simple: Chatbot básico con OpenAI
2. 📚 Añade RAG: Conecta tu documentación
3. 🤖 Crea tu primer agente: Con 2-3 tools sencillos
4. 🔧 Optimiza y escala: Monitorea, mide, mejora
5. 💡 Comparte: Publica tus workflows en n8n community

¿Has creado algún pipeline interesante con n8n + LangChain? ¿Quieres que cubramos algún caso de uso específico? Cuéntanos en los comentarios. ¡Rebélate contra el código innecesario! 🤘