# Constructor de agentes de IA Flowise

## Resumen

[Flowise](https://github.com/FlowiseAI/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](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md).

**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](https://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:

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

### Paso 2: Ejecuta Flowise (comando único)

```bash
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

```bash
# 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:

```bash
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:

```bash
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

```bash
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:

```bash
# 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:

```yaml
# /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:
```

```bash
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:

```bash
# 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](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) 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:

```bash
# 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](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) 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:

```bash
# 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:

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

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

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

```bash
# 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"

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

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

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

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

```bash
# 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](https://github.com/FlowiseAI/Flowise) — Código fuente, releases, docker-compose oficial
* [Documentación de Flowise](https://docs.flowiseai.com) — Referencia de nodos, documentación de API, guías de despliegue
* [Discord de Flowise](https://discord.gg/jn8n7yb9N) — Plantillas de la comunidad, compartir flujos, soporte
* [Docker Hub: flowiseai/flowise](https://hub.docker.com/r/flowiseai/flowise) — Más de 5M descargas, etiquetas disponibles
* [Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — Ejecuta LLMs locales para inferencia Flowise gratuita
* [vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — Servicio de LLM a escala de producción para Flowise
* [Guía de comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — Selecciona la GPU adecuada para tu stack
* [Documentación de LangChain.js](https://js.langchain.com/docs/) — Referencia del marco subyacente


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/plataformas-y-agentes-de-ia/flowise.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.