Constructor de agentes de IA Flowise

Despliega Flowise en Clore.ai: crea y aloja chatbots visuales con LLM, agentes de IA y canalizaciones RAG en servidores de nube GPU asequibles con una interfaz no-code de arrastrar y soltar y endpoints API instantáneos.

Descripción general

Flowise es una herramienta de código abierto de arrastrar y soltar para crear aplicaciones impulsadas por LLM sin escribir código. Con más de 35 mil estrellas en GitHub y más de 5 millones de descargas en Docker Hub, Flowise se ha convertido en una de las herramientas de IA autoalojadas más desplegadas en el ecosistema. Permite a los equipos crear chatbots, sistemas RAG, agentes de IA y flujos de trabajo automatizados a través de una interfaz visual intuitiva, y desplegarlos como endpoints de API REST en minutos.

Flowise está construido sobre LangChain.js y ofrece un lienzo basado en nodos donde conectas componentes: LLM, bases de datos vectoriales, cargadores de documentos, almacenes de memoria, herramientas y agentes. Cada flujo genera automáticamente un widget de chat integrable y un endpoint de API que puedes integrar en cualquier aplicación.

Capacidades clave:

• Constructor de flujos de arrastrar y soltar — Orquestación visual de LLM con más de 100 nodos preconstruidos

• Creación de chatbots — Widgets de chat integrables para sitios web y aplicaciones

• Pipelines RAG — Conecta visualmente cargadores de documentos, embeddings y almacenes vectoriales

• Compatibilidad con múltiples agentes — Crea jerarquías de agentes con uso de herramientas y delegación

• API instantánea — Cada flujo genera un /api/v1/prediction/<flowId> endpoint

• Nodos de LangChain — Acceso completo al ecosistema de LangChain.js

• Gestor de credenciales — Gestiona centralmente claves API, conexiones a bases de datos

¿Por qué Clore.ai para Flowise?

Flowise es un servidor Node.js ligero: se encarga de la orquestación, no del cómputo. Combinarlo con Clore.ai permite:

• Inferencia local de modelos — Ejecuta Ollama o vLLM en el mismo servidor GPU, eliminando los costes de API

• Procesamiento privado de documentos — Pipelines RAG que nunca envían datos a servicios externos

• Despliegue persistente — Alojamiento siempre activo de chatbots y APIs a precios de servidor GPU

• Rentable a escala — Construye plataformas de chatbots multiinquilino sin tarifas de API por llamada

• Alojamiento de IA de pila completa — Flowise + Ollama + Qdrant/Chroma, todo en un solo servidor asequible

---

Requisitos

Flowise en sí es una aplicación Node.js con requisitos mínimos de recursos. La GPU solo es necesaria si añades un backend LLM local.

Configuración	GPU	VRAM	RAM	Almacenamiento	Precio est.
Solo Flowise (APIs externas)	Ninguno	—	2–4 GB	10 GB	~$0.03–0.08/h
+ Ollama (Llama 3.1 8B)	RTX 3090	24 GB	16 GB	40 GB	$0.07–0.21/h
+ Ollama (Mistral 7B + embeddings)	RTX 3090	24 GB	16 GB	30 GB	$0.07–0.21/h
+ Ollama (Qwen2.5 32B)	RTX 4090	24 GB	32 GB	60 GB	$0.14–0.42/h
+ vLLM (producción)	A100 80GB	80 GB	64 GB	100 GB	bare metal

Nota: Flowise funciona cómodamente en cualquier servidor de Clore.ai. La GPU solo es necesaria si quieres inferencia local gratuita. Consulta los Guía de comparación de GPU.

requisitos del servidor Clore.ai:

• Docker Engine (preinstalado en todas las imágenes de Clore.ai)

• NVIDIA Container Toolkit (solo para GPU/Ollama)

• Puerto 3000 accesible (o mapeado en el panel de Clore.ai)

• Mínimo 2 GB de RAM libre, 10 GB de espacio en disco

---

Inicio rápido

Paso 1: Reserva un servidor en Clore.ai

En la mercado de Clore.ai:

• Para uso solo de API: cualquier servidor, filtra por RAM ≥ 4 GB

• Para LLM local: filtra GPU ≥ 24 GB de VRAM

• Asegúrate de que Docker esté habilitado en la plantilla

Conéctate por SSH:

ssh root@<ip-del-servidor> -p <puerto-ssh>

Paso 2: Ejecuta Flowise (un solo comando)

docker run -d \\
  --name flowise \
  --restart unless-stopped \\
  -p 3000:3000 \
  flowiseai/flowise

Eso es todo. Flowise estará disponible en http://<server-ip>:3000 en 20–30 segundos.

Paso 3: Verifica que esté ejecutándose

# Comprueba el estado del contenedor
docker ps | grep flowise

# Ver registros
docker logs flowise --tail 20

# Probar la API
curl http://localhost:3000/api/v1/chatflows

Paso 4: Abre la interfaz

Navega a http://<server-ip>:3000 en tu navegador.

Mapeo de puertos de Clore.ai: Asegúrate de que el puerto 3000 esté redirigido en la configuración de tu servidor Clore.ai. Ve a los detalles de tu servidor → Puertos → confirma 3000:3000 que está mapeado. Algunas plantillas solo exponen SSH por defecto.

---

Configuración

Almacenamiento persistente

Monta volúmenes para que tus flujos, credenciales y cargas persistan tras reinicios del contenedor:

mkdir -p /opt/flowise/{data,uploads,logs}

docker run -d \\
  --name flowise \
  --restart unless-stopped \\
  -p 3000:3000 \
  -v /opt/flowise/data:/root/.flowise \
  -v /opt/flowise/uploads:/app/uploads \
  -e DATABASE_PATH=/root/.flowise \
  -e APIKEY_PATH=/root/.flowise \
  -e SECRETKEY_PATH=/root/.flowise \
  -e LOG_PATH=/root/.flowise/logs \
  flowiseai/flowise

Autenticación

Protege tu instancia de Flowise con usuario/contraseña:

docker run -d \\
  --name flowise \
  --restart unless-stopped \\
  -p 3000:3000 \
  -v /opt/flowise/data:/root/.flowise \
  -e FLOWISE_USERNAME=admin \
  -e FLOWISE_PASSWORD=$(openssl rand -base64 16) \
  -e FLOWISE_SECRETKEY_OVERWRITE=$(openssl rand -hex 32) \
  flowiseai/flowise

Nota de seguridad: Establece siempre credenciales al exponer Flowise públicamente en Clore.ai. Sin autenticación, cualquiera con la IP de tu servidor puede acceder a tus flujos y claves API.

Referencia completa de variables de entorno

docker run -d \\
  --name flowise \
  --restart unless-stopped \\
  -p 3000:3000 \
  -v /opt/flowise/data:/root/.flowise \
  -e PORT=3000 \
  -e FLOWISE_USERNAME=admin \
  -e FLOWISE_PASSWORD=tu-contraseña-segura \
  -e FLOWISE_SECRETKEY_OVERWRITE=tu-clave-secreta \
  -e DATABASE_TYPE=sqlite \
  -e DATABASE_PATH=/root/.flowise \
  -e APIKEY_PATH=/root/.flowise \
  -e SECRETKEY_PATH=/root/.flowise \
  -e LOG_PATH=/root/.flowise/logs \
  -e LOG_LEVEL=info \
  -e TOOL_FUNCTION_BUILTIN_DEP=crypto,fs \
  -e TOOL_FUNCTION_EXTERNAL_DEP=moment,lodash \
  -e CORS_ORIGINS=* \
  -e IFRAME_ORIGINS=* \
  flowiseai/flowise

Variable	Descripción	Valor predeterminado
PORT	Puerto del servidor web	3000
FLOWISE_USERNAME	Nombre de usuario administrador (habilita la autenticación)	— (sin autenticación)
FLOWISE_PASSWORD	Contraseña de administrador	—
FLOWISE_SECRETKEY_OVERWRITE	Clave de cifrado para credenciales	Generada automáticamente
DATABASE_TYPE	sqlite o mysql o postgres	sqlite
DATABASE_PATH	Ruta de almacenamiento de SQLite	/root/.flowise
LOG_LEVEL	error, warn, info, debug	info
TOOL_FUNCTION_BUILTIN_DEP	Builtins de Node.js permitidos en nodos de código	—
TOOL_FUNCTION_EXTERNAL_DEP	Paquetes npm permitidos en nodos de código	—
CORS_ORIGINS	Orígenes CORS permitidos para la API	*
IFRAME_ORIGINS	Orígenes permitidos para incrustación en iframe	*

Docker Compose (recomendado)

El repositorio oficial de Flowise incluye una configuración de Docker Compose. Este es el enfoque recomendado para Clore.ai:

# Descarga el docker-compose.yml oficial
curl -o /opt/flowise/docker-compose.yml \
  https://raw.githubusercontent.com/FlowiseAI/Flowise/main/docker/docker-compose.yml

cd /opt/flowise

O crea el tuyo propio con PostgreSQL:

# /opt/flowise/docker-compose.yml
version: "3.9"

services:
  flowise:
    image: flowiseai/flowise:latest
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - PORT=3000
      - FLOWISE_USERNAME=${FLOWISE_USERNAME:-admin}
      - FLOWISE_PASSWORD=${FLOWISE_PASSWORD:-changeme}
      - FLOWISE_SECRETKEY_OVERWRITE=${SECRET_KEY}
      - DATABASE_TYPE=postgres
      - DATABASE_HOST=db
      - DATABASE_PORT=5432
      - DATABASE_USER=flowise
      - DATABASE_PASSWORD=flowise-secret
      - DATABASE_NAME=flowise
    volumes:
      - flowise-data:/root/.flowise
    depends_on:
      db:
        condition: service_healthy

  db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      - POSTGRES_USER=flowise
      - POSTGRES_PASSWORD=flowise-secret
      - POSTGRES_DB=flowise
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U flowise"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  flowise-data:
  pgdata:

SECRET_KEY=$(openssl rand -hex 32) \
FLOWISE_PASSWORD=tucontraseña \
docker compose -f /opt/flowise/docker-compose.yml up -d

---

Aceleración GPU (integración LLM local)

Flowise orquesta: la GPU hace el trabajo pesado en los servicios conectados.

Flowise + Ollama (recomendado)

Ejecuta Ollama en el mismo servidor Clore.ai y conecta Flowise a él:

# Paso 1: Inicia Ollama con acceso a GPU
docker run -d \\
  --name ollama \
  --gpus all \\
  --restart unless-stopped \\
  -p 11434:11434 \
  -v ollama-models:/root/.ollama \
  ollama/ollama:latest

# Paso 2: Descarga modelos
docker exec ollama ollama pull llama3.1:8b          # Modelo de chat/agente
docker exec ollama ollama pull nomic-embed-text     # Embeddings para RAG
docker exec ollama ollama pull mistral:7b           # Modelo de chat alternativo

# Paso 3: Inicia Flowise con acceso a la red del host
docker run -d \\
  --name flowise \
  --restart unless-stopped \\
  -p 3000:3000 \
  -v /opt/flowise/data:/root/.flowise \
  --add-host host.docker.internal:host-gateway \
  -e FLOWISE_USERNAME=admin \
  -e FLOWISE_PASSWORD=changeme \
  flowiseai/flowise

En la interfaz de Flowise:

1. Crea un nuevo Chatflow

2. Añade Ollama nodo (en Chat Models)

   • URL base: http://host.docker.internal:11434

   • Nombre del modelo: llama3.1:8b

3. Añade OllamaEmbeddings nodo (para RAG)

   • URL base: http://host.docker.internal:11434

   • Nombre del modelo: nomic-embed-text

4. Conéctalo a tu Vector Store (Chroma, FAISS, Qdrant)

Consulta la guía completa de Ollama para la descarga de modelos y la configuración de GPU.

Flowise + vLLM (escala de producción)

Para una implementación de alto rendimiento compatible con OpenAI:

# Inicia vLLM
docker run -d \\
  --name vllm \
  --gpus all \\
  --restart unless-stopped \\
  -p 8000:8000 \
  --ipc=host \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --gpu-memory-utilization 0.85

# En Flowise, usa el nodo ChatOpenAI con una URL base personalizada:
# URL base: http://host.docker.internal:8000/v1
# Clave API de OpenAI: (cualquier valor)
# Nombre del modelo: mistralai/Mistral-7B-Instruct-v0.3

Consulta la Guía de vLLM para cuantización y configuraciones multi-GPU.

Crear un chatbot RAG solo local

Flujo completo de Flowise sin llamadas externas a la API en Clore.ai:

Nodo	Componente	Settings
1	Cargador de archivos PDF	Sube un documento
2	Divisor recursivo de texto	Fragmento: 1000, Solapamiento: 200
3	Embeddings de Ollama	Modelo: nomic-embed-text
4	Almacén vectorial en memoria	(o Chroma para persistencia)
5	Chat de Ollama	Modelo: llama3.1:8b
6	QA de recuperación conversacional	Tipo de cadena: Stuff
7	Memoria de búfer	Memoria basada en sesión

Expórtalo como API e incrusta el widget de chat en cualquier sitio web.

---

Consejos y mejores prácticas

1. Exporta los flujos regularmente

Antes de detener o cambiar de servidor Clore.ai:

# Exporta todos los flujos vía API
curl http://localhost:3000/api/v1/chatflows \
  -H "Authorization: Basic $(echo -n admin:password | base64)" \
  > /opt/flowise/backup-flows.json

# O usa la interfaz: Chatflows → Exportar todo

2. Usa el widget incrustable

Cada chatflow de Flowise genera un widget de chat listo para producción:

1. Abre tu chatflow → Haz clic en </> botón (Incrustar)

2. Copia el fragmento de script

3. Pega en cualquier página HTML: bot de atención al cliente instantáneo

3. Gestiona las claves API de forma segura

Guarda todas las claves API de LLM en el panel de Credenciales (no codificadas en los flujos):

• Menú → Credenciales → Añadir credencial

• Las claves se cifran con FLOWISE_SECRETKEY_OVERWRITE

4. Limitación de tasa

Para despliegues públicos, añade limitación de tasa mediante Nginx o Caddy delante de Flowise:

# Configuración simple de proxy inverso nginx
docker run -d \\
  --name nginx \
  -p 80:80 \
  -v /opt/flowise/nginx.conf:/etc/nginx/conf.d/default.conf:ro \
  --link flowise:flowise \
  nginx:alpine

5. Monitoriza el rendimiento

# Monitorización de recursos en tiempo real
watch -n 3 'docker stats flowise ollama --no-stream'

# Comprueba los logs de Flowise en busca de errores
docker logs flowise --tail 50 -f

# Comprueba si se están llamando los flujos
docker logs flowise 2>&1 | grep "Prediction"

6. Haz una copia de seguridad de la base de datos SQLite

# Crea una copia de seguridad con marca de tiempo
cp /opt/flowise/data/database.sqlite \
   /opt/flowise/backup-$(date +%Y%m%d-%H%M%S).sqlite

# O automatízalo con cron
echo "0 */6 * * * cp /opt/flowise/data/database.sqlite /opt/flowise/backup-\$(date +\%Y\%m\%d-\%H\%M\%S).sqlite" | crontab -

---

Solución de problemas

El contenedor se cierra inmediatamente

# Comprueba el motivo de salida
docker logs flowise

# Causas comunes:
# 1. El puerto 3000 ya está en uso
lsof -i :3000
# Solución: usa un puerto diferente
docker run ... -p 3001:3000 ...

# 2. Error de permisos en el volumen
ls -la /opt/flowise/
chown -R 1000:1000 /opt/flowise/data

La interfaz muestra "Connection Failed"

# Verifica que Flowise realmente esté ejecutándose
docker ps -a | grep flowise
docker stats flowise --no-stream

# Comprueba que esté enlazando a todas las interfaces
docker logs flowise | grep "listening"
# Debería mostrar: Server is listening at port 3000

# Prueba localmente primero
curl -s http://localhost:3000/api/v1/chatflows | head -20

Los flujos fallan con errores de LLM

# Prueba la conectividad de Ollama desde el contenedor de Flowise
docker exec flowise wget -qO- http://host.docker.internal:11434/api/tags

# Si falla, verifica que se incluyó --add-host:
docker inspect flowise | grep -A5 ExtraHosts

# Prueba que Ollama esté ejecutándose
curl http://localhost:11434/api/tags

Errores de migración de base de datos durante la actualización

# Al actualizar la versión de Flowise, haz primero una copia de seguridad
cp -r /opt/flowise/data /opt/flowise/data-backup-$(date +%Y%m%d)

# Descarga la nueva imagen
docker pull flowiseai/flowise:latest

# Reinicia con el mismo volumen (las migraciones se ejecutan automáticamente)
docker stop flowise && docker rm flowise
docker run -d --name flowise ... flowiseai/flowise:latest
docker logs flowise -f  # Observa la salida de la migración

Errores de descifrado de credenciales después del reinicio

# Si no estableciste FLOWISE_SECRETKEY_OVERWRITE, se genera una nueva clave al reiniciar
# Establécelo siempre explícitamente:
-e FLOWISE_SECRETKEY_OVERWRITE=tu-secreto-estable-de-32-caracteres

# Para recuperar: vuelve a introducir las credenciales en la interfaz después de establecer una clave estable

Errores de CORS del widget de chat

# Permite orígenes específicos (reemplaza * con tu dominio para producción)
-e CORS_ORIGINS=https://tu-dominio.com,http://localhost:3000
-e IFRAME_ORIGINS=https://tu-dominio.com

---

Lecturas adicionales

• Repositorio de GitHub de Flowise — Código fuente, lanzamientos, docker-compose oficial

• Documentación de Flowise — Referencia de nodos, documentación de la API, guías de despliegue

• Discord de Flowise — Plantillas de la comunidad, compartición de flujos, soporte

• Docker Hub: flowiseai/flowise — Más de 5 millones de descargas, etiquetas disponibles

• Ollama en Clore.ai — Ejecuta LLM locales para inferencia gratuita de Flowise

• vLLM en Clore.ai — Servicio de LLM a escala de producción para Flowise

• Guía de comparación de GPU — Selecciona la GPU adecuada para tu pila

• Documentación de LangChain.js — Referencia del framework subyacente