Monta tu propio “copiloto interno” con modelos open-source y n8n

GUÍAS · TUTORIALES · AUTOMATIZACIÓN

1. Qué es un “copiloto interno” (de verdad)

Llamo “copiloto interno” a un sistema que combina tres cosas:

• Un modelo de lenguaje (LLM) que entiende tus preguntas y genera respuestas útiles.
• Acceso a tu conocimiento interno: documentos, políticas, base de conocimiento, tickets, etc.
• Capacidad de actuar sobre tus herramientas: crear tareas, enviar emails, actualizar filas en Sheets, registrar notas en el CRM…

No es solo “un chat para preguntarle cosas”. Bien montado, tu copiloto puede:

• Responder dudas típicas de equipos (RRHH, procesos internos, precios, soporte…).
• Resumir contratos, propuestas o actas de reunión y dejar los puntos clave en el gestor de tareas.
• Ayudar a preparar campañas, posts o contenidos reutilizando material que ya tenéis, como explico cuando hablo de usar IA para crear un blog que atrae clientes.
• Automatizar tareas de backoffice: volcado de datos de formularios, seguimiento de leads, reportes periódicos…

La gracia de hacerlo con modelos open-source y n8n es que no dependes solo de una API externa, puedes desplegarlo en tu propia infraestructura y diseñar tu copiloto como una especie de segunda mente digital para tu organización.

2. Arquitectura mínima: las 4 piezas que necesitas

Antes de entrar en pasos, visualiza el sistema como un diagrama muy simple de cuatro bloques:

1. Modelo open-source: LLM que corre en tu servidor, en una instancia cloud o en un PC dedicado (Llama, Mistral, Qwen, etc.).
2. n8n: el “orquestador”. Un motor de workflows que recibe mensajes, llama al modelo, consulta bases de datos y ejecuta acciones.
3. Capa de conocimiento: donde viven tus documentos indexados para búsqueda semántica (RAG: embeddings + vector DB).
4. Canales de entrada/salida: Slack, Teams, email, un formulario web o incluso un botón en tu intranet.

Tu copiloto interno no es un producto mágico: es el resultado de que estos cuatro bloques hablen bien entre sí. Vamos a montar esa conversación.

3. Paso 1: elegir el modelo open-source correcto (sin volverte loco)

Lo primero es decidir qué modelo vas a usar como “cerebro” del copiloto. Aquí tienes tres variables clave:

• Idioma y dominio: si tu equipo trabaja en español, busca modelos con buen rendimiento multilingüe. Si el uso principal es código, prioriza modelos especializados en programación.
• Licencia: asegúrate de que puedes usarlo comercialmente y alojarlo tú. Muchos modelos open-source lo permiten, pero no todos tienen la misma letra pequeña.
• Hardware disponible: no es lo mismo correr un modelo de 7B parámetros en una máquina modesta que uno de 70B en una GPU potente.

A día de hoy, familias como Llama, Mistral o Qwen son opciones habituales para copilotos internos porque tienen versiones “medianas” que funcionan bien en servidores razonables y soportan escenarios tipo chat empresarial. Si quieres una comparativa más sistemática, te puede ayudar esta guía sobre cómo elegir modelo open-source en 2025.

¿Dónde lo despliego?

Tienes tres caminos típicos:

• Local / on-premise: instalas el modelo en tus propios servidores o incluso en una máquina dedicada usando herramientas como Ollama o LM Studio. Máximo control y privacidad, pero necesitas cuidar bien el mantenimiento.
• Cloud propia: levantas una instancia en un proveedor (con GPU o CPU potente) y sirves el modelo con una API HTTP cualquiera de tus aplicaciones (incluida n8n) pueda llamar.
• Proveedor gestionado de modelos open-source: empresas que alojan por ti modelos abiertos y te dan una API compatible con los principales LLMs, pero sin estar atado a un “modelo propietario puro”.

En todos los casos, el patrón es el mismo: acabas con un endpoint HTTP tipo /v1/chat/completions que recibe un prompt y devuelve una respuesta. Eso es justo lo que n8n necesita para convertir tu LLM en un “nodo” más dentro de los workflows.

4. Paso 2: n8n como cerebro orquestador

n8n es un orquestador de workflows open-source: conectas apps, transformas datos y automatizas procesos arrastrando nodos en un canvas visual. Desde hace tiempo, además, trae nodos específicos para IA (cadenas de prompts, agentes, RAG…) y se lleva muy bien con modelos externos.

Para un copiloto interno, n8n suele jugar tres papeles:

• Punto de entrada: recibe mensajes desde Slack, un webhook, un formulario, etc.
• Router inteligente: decide si la pregunta se responde solo con el LLM, si hay que ir a la base de conocimiento, si toca ejecutar una automatización…
• Ejecutor de acciones: crea tareas en el gestor de proyectos, manda correos, actualiza bases de datos, genera documentos, etc.

Puedes instalar n8n en Docker, en una VM o usar su versión cloud. Si vas en serio con un copiloto que va a tocar datos sensibles, lo habitual es desplegarlo en tu propia infraestructura o en una cuenta cloud bajo tu control.

Piensa en n8n como una capa intermedia entre “la inteligencia del modelo” y “la realidad de tu negocio”. Ahí es donde pones reglas, permisos y lógica para que el copiloto haga cosas útiles y no se convierta en un juguete más en la empresa.

5. Paso 3: conectar el modelo open-source con n8n

Con el modelo corriendo y n8n instalado, el siguiente paso es unirlos. Hay dos enfoques comunes:

A) Usar nodos de LLM de n8n

n8n incorpora nodos tipo “Basic LLM Chain” y “AI Agent” que abstraen parte del trabajo de hablar con modelos. Muchos ejemplos ya muestran cómo conectar modelos open-source (vía Hugging Face, instancias propias, etc.) directamente a estos nodos. Tú defines:

• El endpoint y la clave de la API de tu modelo.
• El prompt base (rol del asistente, instrucciones, formato de salida).
• Opcionalmente, cómo parsear la respuesta (por ejemplo, devolver siempre JSON con campos concretos).

Ventaja: menos “pegamento” que escribir y mejor integración con otros nodos de IA que ya trae n8n (herramientas, memoria, etc.).

B) Tratar tu modelo como cualquier API HTTP

La alternativa simple: usas el nodo “HTTP Request” de n8n para llamar a tu modelo como llamarías a cualquier API REST. Sueles mandar un JSON con:

• El historial de mensajes (usuario / sistema / asistente).
• Parámetros como máximo de tokens, temperatura, top_p, etc.
• Metadatos opcionales (id de usuario, contexto, etc.).

Luego parseas la respuesta con un nodo de “Function” o “Set” y la devuelves al canal de origen (Slack, web, etc.). Es un poco más manual, pero te da control total y funciona igual con modelos locales, self-hosted o gestionados.

En ambos casos, te recomiendo encapsular esta lógica en un workflow o sub-workflow que haga solo una cosa: recibir un mensaje + contexto y devolver una respuesta del modelo. Ese será el “core” de tu copiloto, reutilizable desde otros flujos.

6. Paso 4: darle memoria con tus documentos (RAG)

Un LLM “puro” puede responder bien a preguntas generales, pero tu equipo quiere respuestas sobre vuestros procesos, plantillas, clientes, productos.... Para eso necesitas RAG (Retrieval Augmented Generation): buscar primero en tus datos y luego pasar ese contexto al modelo.

Cómo montar la capa de conocimiento con n8n

El patrón típico es:

1. Ingesta: un workflow que escucha cambios en tu fuente de documentos (carpetas de Google Drive, Notion, Confluence, CRM, etc.).
2. Particionamiento: divide cada documento en trozos pequeños (párrafos, secciones) para que las respuestas sean granulares.
3. Embeddings: envía esos trozos a un modelo de embeddings (open-source o no) y convierte cada fragmento en un vector numérico.
4. Almacenamiento vectorial: guarda los vectores en una base de datos vectorial (Postgres+pgvector, Qdrant, Pinecone, Supabase, lo que prefieras).
5. Búsqueda: cuando llegue una pregunta, creas un vector de la query y recuperas los fragmentos más cercanos para pasárselos al LLM como contexto.

n8n ya tiene guías y ejemplos de RAG donde se ve este patrón completo: conectas la fuente de datos, generas embeddings, los guardas y, en otro workflow, vinculas la búsqueda + LLM para crear el chat. Si quieres ir más lejos, puedes explorar enfoques como GraphRAG, que enriquecen tus datos con relaciones tipo grafo para responder preguntas más complejas.

La clave práctica: empieza con poca información pero muy bien seleccionada (FAQs internas, manuales, políticas clave). Es mejor un copiloto que responde de lujo a 200 preguntas frecuentes que uno que “medio responde” a cualquier cosa perdida en 200.000 archivos.

7. Paso 5: que no solo hable, que haga cosas (automatizaciones)

Hasta aquí tenemos un asistente que responde muy bien. Pero la magia de n8n es que el copiloto puede convertir respuestas en acciones. Algunos ejemplos reales:

• Cuando pides “resúmeme esta reunión y crea tareas para marketing”, el flujo:

– Genera el resumen.
– Extrae las acciones en formato estructurado (JSON).
– Crea tareas en tu gestor (Asana, ClickUp, Jira…).
– Envía el resumen al canal correspondiente de Slack.

• Cuando subes un nuevo contrato a una carpeta, el workflow:

– Lo detecta.
– Lo pasa por el modelo para extraer campos clave (fechas, importes, partes).
– Rellena automáticamente una fila en Sheets o en tu ERP.
– Notifica al responsable legal con un resumen.

• Cuando recibes un formulario web de un lead, el copiloto:

– Clasifica al lead según criterios internos.
– Genera un primer email de respuesta personalizado.
– Registra el lead en tu CRM y sugiere próximos pasos.

Aquí es donde se mezcla muy bien con cosas como automatizar datos en Excel/Sheets con IA o con embudos comerciales que aprovechan IA para responder 24/7. Un copiloto interno no es solo un chatbot listo; es la pieza que engancha ese “cerebro” a tus pipelines reales de negocio.

8. Seguridad, permisos y límites (muy importante si usas datos sensibles)

En cuanto montas un copiloto que habla con documentos internos, la pregunta obvia es: ¿y esto quién lo puede ver? Algunas prácticas básicas:

• Segmenta fuentes de conocimiento: no mezcles en el mismo índice documentos de RRHH, finanzas y soporte. Crea varios “espacios” y haz que cada canal de entrada solo consulte lo que debe.
• Respeta permisos de origen: si usas Drive, Notion, etc., intenta que el workflow consulte siempre con una identidad que respete los permisos que ya tienes configurados allí.
• Cuida los logs: desactiva o anonimiza logs que puedan incluir datos personales o sensibles. n8n permite controlar cuánto guardas de cada ejecución.
• Define modos de operación: quizá al principio tu copiloto solo puede “leer y sugerir” y más adelante le dejas crear tareas o actualizar registros, siempre con ventanas de revisión humana en medio.

Cuanto más potente sea tu copiloto, más importante es tratarlo como un sistema crítico: controles de acceso, entornos de desarrollo y producción separados, monitorización y alertas si algo se sale de lo normal.

9. Blueprint rápido: ejemplo de copiloto interno con Slack + Drive + LLM local

Para aterrizarlo, te dejo un flujo sencillo que puedes usar como referencia. Imagina que quieres un copiloto al que tu equipo de operaciones pueda hablar desde Slack para:

• Preguntar por procesos y políticas internas.
• Subir documentos y recibir resúmenes.
• Crear tareas en el gestor de proyectos.

Pasos resumidos

1. Despliega el modelo (por ejemplo, un Llama o Mistral mediano) en una máquina accesible por n8n, exponiendo un endpoint HTTP de chat.
2. Instala n8n en tu servidor y crea credenciales para Slack, Google Drive y tu gestor de tareas.
3. Crea un workflow de ingesta que monitorice una carpeta “Operaciones” en Drive, divida los documentos en trozos, genere embeddings y los guarde en una base vectorial.
4. Crea un sub-workflow “LLM Chat” que reciba {usuario, mensaje, contexto} y llame al modelo open-source por HTTP o con el nodo de LLM correspondiente.
5. Monta el flujo principal de chat con un trigger de Slack (slash command o mensajes en un canal concreto).
6. Según el mensaje, tu lógica puede:

– Lanzar una búsqueda en la base vectorial para recuperar 3–5 fragmentos relevantes.
– Construir un prompt que mezcle esos fragmentos con la pregunta del usuario.
– Llamar al sub-workflow “LLM Chat” y devolver la respuesta a Slack.

7. Si el usuario escribe algo tipo “crea tareas con estos puntos”, el workflow:

– Pide al LLM que devuelva las acciones en formato JSON (título, responsable, fecha).
– Recorre ese JSON y crea tareas en tu herramienta de proyectos.
– Devuelve un mensaje confirmando lo que se ha creado.

8. Añade métricas: loguea cuántas preguntas se responden bien, qué tipo de cosas pide la gente, dónde falla más… eso te dará pistas para mejorar tanto el modelo como los procesos que hay detrás.

Con este patrón básico, puedes ir añadiendo capas: otros equipos, otros canales (Teams, email), otras fuentes de datos (tickets, CRM) e incluso agentes más complejos como los que veremos cada vez más en escenarios de asistentes multimodales y agentic.

10. Errores típicos al montar un copiloto interno

Algunos tropiezos que veo una y otra vez (y que puedes ahorrarte):

• Intentar cubrir toda la empresa de golpe. Mucho mejor empezar con un equipo o proceso concreto (por ejemplo, soporte interno de TI) y expandir desde ahí.
• Meter todos los documentos sin filtrar. Si tu índice está lleno de basura, tu copiloto también. Curar el contenido inicial es trabajo pesado, pero marca la diferencia.
• Obsesionarse solo con el modelo. Un LLM espectacular con workflows mal pensados da una experiencia mediocre. Invertir tiempo en los flujos de n8n y en el diseño de prompts compensa mucho.
• Olvidar la parte humana. Hay que explicar al equipo qué hace el copiloto, qué no hace, cómo se usan las respuestas y cómo se reportan errores o mejoras. Sin eso, acabará cogiendo polvo.

Al final, tu copiloto interno es tanto un proyecto de producto y cambio cultural como uno de tecnología. Igual que cuando montas un sistema de automatización comercial o una intranet nueva, no va solo de “ponerlo a funcionar”, sino de integrarlo en la rutina diaria.

11. Cierre: tu propio copiloto, a tu manera

La narrativa dominante ahora mismo es que los copilotos te llegarán “empaquetados” desde los grandes proveedores: un botón más en tu suite de oficina y listo. Esa opción está bien para empezar, pero si quieres algo realmente adaptado a tu negocio, tarde o temprano te tocará hacer lo que hemos visto aquí: montar tu propio copiloto interno con piezas que controlas.

La buena noticia es que la tecnología ya no es el cuello de botella: modelos open-source potentes, herramientas como n8n y un ecosistema creciente de plugins y ejemplos hacen que esto sea alcanzable para cualquier equipo técnico medio. Lo que marca la diferencia es tener claro el problema que quieres resolver y empezar pequeño, con un caso de uso donde el valor del copiloto sea imposible de ignorar.

Si haces eso, en unos meses no estarás preguntando “¿montamos un copiloto interno?”, sino “¿cómo hemos trabajado tantos años sin uno?”.