Constructor de Agentes AI Flowise

Despliega Flowise en Clore.ai — crea y aloja chatbots conversacionales LLM visuales, agentes de IA y canalizaciones RAG en servidores GPU en la nube asequibles con interfaz sin código de arrastrar y soltar y endpoints de API instantáneos.

Resumen

Flowise es una herramienta de código abierto, de arrastrar y soltar, para construir aplicaciones impulsadas por LLM sin escribir código. Con más de 35K 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 REST API en minutos.

Flowise está construido sobre LangChain.js y proporciona un lienzo basado en nodos donde conectas componentes: LLMs, bases de datos vectoriales, cargadores de documentos, almacenes de memoria, herramientas y agentes. Cada flujo genera automáticamente un widget de chat y un endpoint API embebible 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 embebibles para sitios web y aplicaciones

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

• Soporte multiagente — Construye jerarquías de agentes con uso de herramientas y delegación

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

• Nodos LangChain — Acceso completo al ecosistema LangChain.js

• Administrador de credenciales — Gestiona de forma centralizada claves de API, conexiones a bases de datos

¿Por qué Clore.ai para Flowise?

Flowise es un servidor Node.js ligero — maneja la orquestación, no el cómputo. Emparejarlo con Clore.ai permite:

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

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

• Despliegue persistente — Hosting de chatbot y API siempre activo a precios de servidor GPU

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

• Hosting AI full-stack — Flowise + Ollama + Qdrant/Chroma todo en un servidor asequible

---

Requisitos

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

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

Nota: Flowise se ejecuta cómodamente en cualquier servidor de Clore.ai. GPU solo se necesita si deseas inferencia local gratuita. Ver el 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 el mercado de Clore.ai:

• Para uso solo con API: Cualquier servidor, filtrar por RAM ≥ 4 GB

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

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

Conéctate vía SSH:

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

Paso 2: Ejecuta Flowise (comando único)

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é en ejecución

# Comprueba el estado de los contenedores
docker ps | grep flowise

# Revisa los logs
docker logs flowise --tail 20

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

Paso 4: Abre la UI

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

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

---

Configuración

Almacenamiento Persistente

Monta volúmenes para que tus flujos, credenciales y cargas sobrevivan a 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: Siempre establece credenciales cuando expongas Flowise públicamente en Clore.ai. Sin autenticación, cualquiera con la IP de tu servidor puede acceder a tus flujos y claves de 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 por defecto
PUERTO	Puerto del servidor web	3000
FLOWISE_USERNAME	Nombre de usuario administrador (habilita autenticación)	— (sin autenticación)
FLOWISE_PASSWORD	Contraseña del 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 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 embebido en iframe	*

Docker Compose (recomendado)

El repo 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 por GPU (integración de LLM local)

Flowise orquesta — la GPU realiza 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 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 UI de Flowise:

1. Crea un nuevo Chatflow

2. Agregar Ollama nodo (bajo Modelos de Chat)

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

   • Nombre del modelo: llama3.1:8b

3. Agregar OllamaEmbeddings nodo (para RAG)

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

   • Nombre del modelo: nomic-embed-text

4. Conéctate a tu almacén vectorial (Chroma, FAISS, Qdrant)

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

Flowise + vLLM (escala de producción)

Para servicio compatible con OpenAI y alto rendimiento:

# 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 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

Ver el guía de vLLM para cuantización y configuraciones multi-GPU.

Construyendo un chatbot RAG solo local

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

Nodo	Componente	Configuraciones
1	Cargador de archivos PDF	Subir documento
2	Divisor de texto recursivo	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

Exporta esto como una API e incrusta el widget de chat en cualquier sitio web.

---

Consejos y mejores prácticas

1. Exporta flujos regularmente

Antes de detener o cambiar servidores 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 UI: Chatflows → Export All

2. Usa el widget embebido

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

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

2. Copia el fragmento de script

3. Pégalo en cualquier página HTML — bot de soporte al cliente instantáneo

3. Gestiona las claves de API de forma segura

Almacena todas las claves de API de LLM en el Panel de credenciales de Flowise (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'

# Revisa los logs de Flowise por errores
docker logs flowise --tail 50 -f

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

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

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

# O automatiza 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 sale inmediatamente

# Comprueba la razón de la salida
docker logs flowise

# Causas comunes:
# 1. Puerto 3000 ya 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 UI muestra "Conexión fallida"

# Verifica que Flowise esté realmente en ejecución
docker ps -a | grep flowise
docker stats flowise --no-stream

# Comprueba que se enlace 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 Flowise
docker exec flowise wget -qO- http://host.docker.internal:11434/api/tags

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

# Comprueba que Ollama esté en ejecución
curl http://localhost:11434/api/tags

Errores de migración de base de datos al actualizar

# Al actualizar la versión de Flowise, haz copia de seguridad primero
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 las migraciones

Errores de descifrado de credenciales tras reinicio

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

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

Errores CORS del widget de chat

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

---

Lecturas adicionales

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

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

• Discord de Flowise — Plantillas de la comunidad, compartir flujos, soporte

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

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

• 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 stack

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