Flowise: construir agentes de IA arrastrando y soltando en Ollama

#¿Por qué Flowise?

Flowise es un constructor visual de código abierto (licencia Apache 2.0) basado en LangChain y LangGraph. Ofrece los mismos componentes —modelos, memoria, retrievers, herramientas— en forma de nodos que se conectan entre sí, lo que permite pasar de un prototipo de agente de varios cientos de líneas de Python a un grafo que se entiende de un vistazo.

Frente a Dify, la otra plataforma sin código del sitio, Flowise se orienta más a una orquestación detallada: mientras que Dify ofrece una experiencia de producto muy estructurada (apps, conjuntos de prompts, gestión de equipos), Flowise deja ver el funcionamiento interno de LangChain y resulta más adecuado cuando quieres entender y ajustar cada paso de un agente. Ambos se conectan a Ollama de la misma manera.

100 % local

Combinado con Ollama, ningún token ni documento se envía a una API en la nube. Ideal para datos sensibles o un uso sin conexión.

Iteración rápida

El chat de prueba está integrado en el canvas: modificas un nodo y ves el efecto inmediatamente, sin tener que volver a desplegar nada.

Publicación de la API y del widget

Cada chatflow se convierte automáticamente en un endpoint REST y un widget web integrable, sin necesidad de escribir backend.

Extensible

Marketplace de plantillas, nodos personalizados en JavaScript e integración de herramientas (búsqueda web, calculadora, llamadas HTTP).

#Prerrequisitos

Flowise es ligero: son Ollama y el modelo cargado los que consumen memoria. Prevé una máquina capaz de ejecutar cómodamente el LLM que quieres utilizar.

Ollama instalado

El daemon debe ejecutarse y escuchar en http://localhost:11434 (valor predeterminado). Verifica con « ollama list ».

Un modelo de chat

Un modelo capaz de realizar llamadas a herramientas para agentes: Qwen 3.5 8B, Granite 4.2 8B o Mistral Small 24B según tu VRAM (7B ≈ 5 GB, 14B ≈ 9 GB, 24B ≈ 16 GB en Q4_K_M).

Un modelo de embeddings

Para el RAG: «nomic-embed-text» o «mxbai-embed-large», ligeros y disponibles a través de Ollama.

Node.js 18.15+ o Docker

Flowise se instala mediante npm o en contenedor. Docker se recomienda para un despliegue limpio y persistente.

#Instalar Flowise

Dos métodos. El más rápido para probar es npx; para uso continuo con datos que persisten, prefiere Docker.

# Lancement direct, sans installation permanente
npx flowise start

# Ou installation globale puis démarrage
npm install -g flowise
flowise start

docker run -d \
  --name flowise \
  -p 3000:3000 \
  --add-host=host.docker.internal:host-gateway \
  -v ~/.flowise:/root/.flowise \
  flowiseai/flowise

Abre luego http://localhost:3000 en tu navegador: aparecerá la interfaz del canvas. El volumen montado (~/.flowise) conserva tus chatflows y tus claves entre dos reinicios del contenedor.

#Conectar Ollama a Flowise

El nodo « ChatOllama » es el puente entre Flowise y tu daemon local. El punto clave es la URL base: depende de la forma en que Flowise se inicie.

1. 01
   Añadir el nodo ChatOllama

   En el lienzo, abre el panel de nodos, categoría «Chat Models», y arrastra «ChatOllama» a la zona de trabajo.
2. 02
   Especificar la URL base

   Si Flowise se ejecuta de forma nativa (npx/npm), usa http://localhost:11434. Si se ejecuta en Docker, usa http://host.docker.internal:11434 — el contenedor no ve el « localhost » del host.
3. 03
   Elegir el modelo

   En el campo «Model Name», introduce el nombre exacto del modelo cargado en Ollama, por ejemplo «qwen3.5:8b» o «mistral-small».
4. 04
   Ajustar los parámetros

   Ajusta Temperature (0,7 para chat, 0,1-0,3 para RAG factual) y, si es necesario, el tamaño de contexto mediante num_ctx en las opciones avanzadas.

#Los nodos esenciales de un chatflow

Un chatflow se lee de izquierda a derecha: los nodos proveedores (modelo, memoria, herramientas) alimentan un nodo «cadena» o «agente» que produce la respuesta. Estos son los pocos bloques que se repiten en casi todos los flujos.

Chat Model (ChatOllama)

El cerebro: el LLM que genera las respuestas. Siempre presente.

Memory (Buffer Memory)

Mantiene el historial de conversación para que el agente conserve el hilo de un turno a otro.

Prompt Template

Define las instrucciones del sistema y el formato de la pregunta. Aquí se le da un rol y un marco al modelo.

Chain / Agent

El nodo terminal. «Conversation Chain» para un chat sencillo; «Tool Agent» cuando el modelo debe decidir si llamar a herramientas.

Tools

Capacidades externas: calculadora, búsqueda web, solicitud HTTP, lectura de archivos. Conectadas a un agente, amplían lo que sabe hacer.

Document Loaders & Vector Store

La parte RAG: cargan documentos, los dividen en fragmentos, los indexan y permiten consultarlos (ver más abajo).

#Crear un primer chatflow

Empecemos por lo más sencillo: un asistente conversacional con memoria, conectado a Ollama. Será la base de todo lo demás.

1. 01
   Crear un nuevo Chatflow

   Desde la pantalla de inicio, haz clic en «Add New» en la pestaña Chatflows. Se abre un lienzo en blanco.
2. 02
   Colocar los tres nodos básicos

   Arrastra «ChatOllama», «Buffer Memory» y «Conversation Chain» al lienzo.
3. 03
   Establecer las conexiones

   Conecta la salida de ChatOllama a la entrada «Chat Model» de Conversation Chain y la salida de Buffer Memory a la entrada «Memory» de la misma cadena.
4. 04
   Personalizar el prompt de sistema

   En Conversation Chain, abre el campo System Message y asigna un rol: «Eres un asistente técnico conciso que responde en francés».
5. 05
   Probar en el chat integrado

   Haz clic en el icono de chat en la esquina superior derecha, plantea una pregunta, luego otra que depende de la primera para comprobar que la memoria funcione.

#Un RAG completo mediante arrastrar y soltar

El RAG (Retrieval-Augmented Generation) permite al modelo responder a partir de tus propios documentos. En Flowise, todo se hace en el canvas: se cargan los archivos, se vectorizan y se conecta el retriever a una cadena de preguntas y respuestas.

1. 01
   Cargar los documentos

   Añade un nodo «Document Loader» adecuado a tu fuente: PDF File, Text File o Folder. Este nodo lee el contenido sin procesar.
2. 02
   Dividir en chunks

   Conecta un «Recursive Character Text Splitter» al cargador. Ajusta el tamaño de los chunks a unos 1000 caracteres, con un solapamiento de 100 caracteres para mantener el contexto entre fragmentos.
3. 03
   Generar embeddings

   Agrega un nodo « Ollama Embeddings » con el modelo « nomic-embed-text » y la misma URL base que ChatOllama.
4. 04
   Indexar en un almacén vectorial

   Arrastra un « In-Memory Vector Store » (simple, para comenzar) o « Chroma » para persistencia. Conéctalo con el splitter y los embeddings.
5. 05
   Conectar un nodo Retrieval QA Chain

   Conecta el vector store (como retriever) y ChatOllama a un nodo «Retrieval QA Chain» o «Conversational Retrieval QA Chain» para mantener la memoria de la conversación.
6. 06
   Consultar tus documentos

   Guarda, abre el chat y plantea una pregunta cuya respuesta está en tus archivos. El modelo ahora cita tu contenido.

ollama pull qwen3.5:8b
ollama pull nomic-embed-text

#Publicar e integrar el chatbot

Una vez que el flujo de chat sea satisfactorio, Flowise lo expone de dos maneras sin escribir una sola línea de código de backend: una API REST y un widget web para pegar en tu sitio.

Haz clic en « API Endpoint » o en el icono </> en la esquina superior derecha del lienzo. Flowise genera la URL de predicción y ejemplos listos para copiar. El endpoint sigue siempre el mismo esquema, con el identificador único del chatflow.

curl http://localhost:3000/api/v1/prediction/<CHATFLOW_ID> \
  -H "Content-Type: application/json" \
  -d '{"question": "Résume la politique de retour en une phrase."}'

Para la integración web, la pestaña «Embed» proporciona un fragmento de script que debes colocar antes de la etiqueta de cierre </body> de tus páginas. El widget muestra una burbuja de chat flotante completamente configurable (colores, mensaje de bienvenida, avatar).

<script type="module">
  import Chatbot from 'https://cdn.jsdelivr.net/npm/flowise-embed/dist/web.js'
  Chatbot.init({
    chatflowid: '<CHATFLOW_ID>',
    apiHost: 'http://localhost:3000',
  })
</script>

#Solución de los errores comunes

« fetch failed » en ChatOllama

URL base incorrecta. En Docker, usa host.docker.internal:11434, no localhost. Asegúrate también de que Ollama esté funcionando bien (ollama list).

El modelo nunca llama a herramientas

El LLM no admite llamadas a herramientas (tool calling) o las admite de forma deficiente. Cambia a un modelo reciente entrenado para ello (Qwen 3.5, Mistral Small) y comprueba que estés usando un «Tool Agent», no una simple cadena.

Respuestas lentas o truncadas

Contexto demasiado grande para la VRAM: parte del modelo pasa a ejecutarse en la CPU. Reduce num_ctx o el tamaño de los fragmentos RAG, o elige un modelo más pequeño.

El RAG no encuentra nada relevante

Chunks mal dimensionados o un modelo de embeddings inadecuado. Ajusta el tamaño de los chunks, aumenta el número de documentos recuperados (top-k) y verifica que la indexación se haya hecho bien.

Los datos desaparecen al reiniciar

En Docker sin un volumen montado, todo se pierde. Asegúrate de tener « -v ~/.flowise:/root/.flowise » y usa un almacén de vectores persistente en lugar de uno en memoria.

#Para ir más allá

Flowise es solo una capa visual: la calidad de tus agentes depende principalmente del modelo y de la pila que está debajo. Tres guías del sitio complementan esta: instalar correctamente Ollama antes de conectar Flowise, comparar el enfoque sin código de Dify con el de Flowise, y entender los mecanismos de un RAG en Python para ajustar con precisión lo que automatiza el canvas.