> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/plataformas-y-agentes-de-ia/flowise.md).

# 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](https://github.com/FlowiseAI/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](https://clore.ai/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](/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 la [mercado de Clore.ai](https://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:

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

### Paso 2: Ejecuta Flowise (un solo comando)

```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é ejecutándose

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

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

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

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

```bash
# 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](/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 una implementación de alto rendimiento compatible con OpenAI:

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

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

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

# 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

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

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

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

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

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

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

```bash
# 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](https://github.com/FlowiseAI/Flowise) — Código fuente, lanzamientos, docker-compose oficial
* [Documentación de Flowise](https://docs.flowiseai.com) — Referencia de nodos, documentación de la API, guías de despliegue
* [Discord de Flowise](https://discord.gg/jn8n7yb9N) — Plantillas de la comunidad, compartición de flujos, soporte
* [Docker Hub: flowiseai/flowise](https://hub.docker.com/r/flowiseai/flowise) — Más de 5 millones de descargas, etiquetas disponibles
* [Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — Ejecuta LLM locales para inferencia gratuita de Flowise
* [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 pila
* [Documentación de LangChain.js](https://js.langchain.com/docs/) — Referencia del framework subyacente


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.