> 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/dify.md).

# Plataforma de flujos de trabajo Dify.ai

Despliega Dify.ai en Clore.ai: crea flujos de trabajo de IA listos para producción, canalizaciones RAG y aplicaciones de agentes con una interfaz visual a precios de nube GPU.

## Descripción general

[Dify.ai](https://github.com/langgenius/dify) es una plataforma de desarrollo de aplicaciones LLM de código abierto con **más de 114 mil estrellas en GitHub**. Combina un constructor visual de flujos de trabajo, canalización de generación aumentada por recuperación (RAG), orquestación de agentes, gestión de modelos y una capa de despliegue de API con un clic en una sola pila autohospedable.

En **Clore.ai** puedes ejecutar toda la pila de Dify —incluida su base de datos Postgres, la caché Redis, el almacén vectorial Weaviate, el proxy inverso Nginx, los workers de la API y el frontend web— en un servidor GPU alquilado por tan solo **$0.07–0.21/h** (RTX 3090/4090). La GPU es opcional para Dify en sí, pero se vuelve esencial cuando integras inferencia de modelos locales a través de los backends de Ollama o vLLM.

**Capacidades clave:**

* 🔄 **Constructor visual de flujos de trabajo** — canalizaciones LLM de arrastrar y soltar con ramificaciones, bucles y lógica condicional
* 📚 **Canalización RAG** — sube PDFs, URL, páginas de Notion; fragmentación + embeddings + recuperación, todo gestionado en la interfaz
* 🤖 **Modo agente** — agentes ReAct y de llamada a funciones con uso de herramientas (búsqueda web, intérprete de código, API personalizadas)
* 🚀 **API-first** — cada app genera al instante un endpoint REST y fragmentos de SDK
* 🔌 **Más de 100 integraciones de modelos** — OpenAI, Anthropic, Mistral, Cohere, además de modelos locales vía Ollama/vLLM
* 🏢 **Multiinquilino** — equipos, espacios de trabajo, RBAC, cuotas de uso

***

## Requisitos

{% hint style="warning" %}
**Los equipos multinodo de clase 80GB no aparecen listados en el marketplace de Clore.ai.** Los equipos más grandes listados hoy son 4× RTX PRO 6000 Blackwell (96GB cada una, 380GB en total) y 8–11× RTX 5090 (32GB cada una). La capacidad A100 / H200 / B200 se vende como [bare metal](https://clore.ai/bare-metal) bajo pedido. Consulta [Precios y disponibilidad de GPU](/guides/guides_v2-es/primeros-pasos/pricing.md) antes de dimensionar un despliegue.
{% endhint %}

Dify se ejecuta como una pila de Docker Compose con varios contenedores. El servidor mínimo viable para desarrollo es una instancia solo CPU; para producción con inferencia de modelos locales querrás un nodo GPU.

| Configuración                   | GPU             | VRAM  | RAM del sistema | Disco  | Precio de Clore.ai                        |
| ------------------------------- | --------------- | ----- | --------------- | ------ | ----------------------------------------- |
| **Mínima** (solo claves de API) | Ninguno / CPU   | —     | 8 GB            | 30 GB  | \~$0.05/h (CPU)                           |
| **Estándar**                    | RTX 3080        | 10 GB | 16 GB           | 50 GB  | $0,05–0,19/h                              |
| **Recomendado**                 | RTX 3090 / 4090 | 24 GB | 32 GB           | 80 GB  | $0.07–0.21/h                              |
| **Producción + LLM local**      | A100 80 GB      | 80 GB | 64 GB           | 200 GB | [bare metal](https://clore.ai/bare-metal) |
| **Alto rendimiento**            | H100 SXM        | 80 GB | 128 GB          | 500 GB | \~$1.04/h                                 |

> **Consejo:** Si solo usas proveedores de API en la nube (OpenAI, Anthropic, etc.), cualquier instancia de CPU de 2 núcleos con 8 GB de RAM funciona. Una GPU solo importa cuando ejecutas modelos locales vía Ollama o vLLM — ver [Aceleración GPU](#gpu-acceleration) a continuación.

### Nota sobre el disco

Los datos de Weaviate y Postgres crecen rápidamente con las cargas de documentos. Provisiona **al menos 50 GB** y monta almacenamiento persistente mediante las opciones de volumen de Clore.ai.

***

## Inicio rápido

### 1. Alquila un servidor de Clore.ai

Ve a [clore.ai](https://clore.ai)y filtra por la GPU que desees; luego despliega un servidor con:

* **Docker** preinstalado (todas las imágenes de Clore lo incluyen)
* Puertos expuestos **80** y **443** (añade puertos personalizados en la configuración de la oferta si es necesario)
* Acceso SSH habilitado

### 2. Conecta y prepara el servidor

```bash
# Conéctate por SSH a tu servidor de Clore
ssh root@<clore-server-ip> -p <ssh-port>

# Actualiza los paquetes del sistema
apt-get update && apt-get upgrade -y

# Verifica que Docker esté disponible
docker --version
docker compose version   # Debería ser v2.x
```

### 3. Clona Dify e inicia

```bash
# Clona el repositorio
git clone https://github.com/langgenius/dify.git
cd dify/docker

# Copia el archivo de entorno de ejemplo
cp .env.example .env

# (Opcional) Edita la configuración antes de iniciar
nano .env

# Descarga todas las imágenes e inicia todos los servicios en segundo plano
docker compose up -d

# Observa los registros durante el inicio (la primera ejecución tarda 2-3 minutos)
docker compose logs -f
```

### 4. Verifica que todos los servicios estén saludables

```bash
# Comprueba el estado de los contenedores
docker compose ps

# Salida esperada:
# NOMBRE                  ESTADO
# docker-api-1            Up (healthy)
# docker-web-1            Up (healthy)
# docker-worker-1         Up (healthy)
# docker-nginx-1          Up
# docker-db-1             Up (healthy)
# docker-redis-1          Up (healthy)
# docker-weaviate-1       Up (healthy)
# docker-sandbox-1        Up (healthy)
```

### 5. Accede a la interfaz web

Abre tu navegador y navega a:

```
http://<clore-server-ip>:80
```

En el primer inicio, Dify te redirigirá al asistente de configuración para crear la cuenta de administrador. Completa el asistente y luego inicia sesión.

***

## Configuración

Toda la configuración está en `dify/docker/.env`. Aquí están los ajustes más importantes:

### Variables de entorno esenciales

```bash
# ── Claves secretas (CAMBIA ESTO) ──────────────────────────────────────────────
SECRET_KEY=your-super-secret-key-change-this-immediately
# Genera una clave fuerte:
# python3 -c "import secrets; print(secrets.token_hex(32))"

# ── URL de la aplicación ──────────────────────────────────────────────────────────
# Establécela en la IP pública o dominio de tu servidor
CONSOLE_WEB_URL=http://<clore-server-ip>
APP_WEB_URL=http://<clore-server-ip>

# ── Base de datos (Postgres) ─────────────────────────────────────────────────────
DB_USERNAME=postgres
DB_PASSWORD=difyai123456          # ¡Cámbiala en producción!
DB_HOST=db
DB_PORT=5432
DB_DATABASE=dify

# ── Redis ───────────────────────────────────────────────────────────────────
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_PASSWORD=difyai123456       # ¡Cámbiala en producción!

# ── Almacenamiento (disco local por defecto) ─────────────────────────────────────────
STORAGE_TYPE=local
# O usa almacenamiento compatible con S3:
# STORAGE_TYPE=s3
# S3_ENDPOINT=https://s3.amazonaws.com
# S3_BUCKET_NAME=your-dify-bucket
# S3_ACCESS_KEY=...
# S3_SECRET_KEY=...

# ── Proveedor LLM predeterminado ─────────────────────────────────────────────────────
# Configúralo en la interfaz después de iniciar sesión, o préconfigúralo aquí:
# OPENAI_API_KEY=sk-...
```

### Cambiar el puerto expuesto

De forma predeterminada, Nginx escucha en el puerto **80**. Para cambiarlo:

```bash
# En docker-compose.yaml, edita el servicio nginx:
# ports:
#   - "8080:80"   ← cambia 8080 por el puerto de host que prefieras

# Luego reinicia:
docker compose down && docker compose up -d
```

### Volúmenes de datos persistentes

El archivo Compose de Dify monta estos volúmenes de forma predeterminada:

```yaml
volumes:
  oradata:          # Datos de Postgres
  redis_data:       # AOF de Redis
  weaviate_data:    # Almacén vectorial
  app_storage:      # Documentos subidos y archivos generados
```

Para hacer una copia de seguridad:

```bash
# Primero detén los servicios y luego empaqueta los volúmenes de Docker
docker compose stop
docker run --rm \\
  -v docker_oradata:/data \\
  -v $(pwd)/backups:/backup \\
  alpine tar czf /backup/postgres-$(date +%Y%m%d).tar.gz /data
docker compose start
```

***

## Aceleración GPU

La plataforma central de Dify se basa en CPU, pero desbloqueas la inferencia local de modelos al integrar **Ollama** o **vLLM** como proveedores de modelos — ambos se benefician enormemente de una GPU.

### Opción A: sidecar de Ollama (la más fácil)

Ejecuta Ollama junto a Dify en el mismo servidor de Clore:

```bash
# Instalar Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Descarga un modelo (p. ej., Llama 3 8B)
ollama pull llama3:8b

# Verifica que se use la GPU
ollama run llama3:8b "Hello!"
nvidia-smi   # Debería mostrar que el proceso de ollama usa VRAM
```

Luego en la interfaz de Dify → **Configuración → Proveedores de modelos → Ollama**:

* URL base: `http://localhost:11434`
* Selecciona tu modelo y guarda

> Para una guía completa de Ollama, consulta [language-models/ollama.md](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md).

### Opción B: sidecar de vLLM (alto rendimiento)

```bash
# Ejecuta vLLM como un contenedor separado con passthrough de GPU
docker run -d \\
  --name vllm \
  --gpus all \\
  --runtime nvidia \\
  -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \\
  -e HUGGING_FACE_HUB_TOKEN=<tu-token-hf> \\
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.2 \\
  --dtype auto \\
  --max-model-len 4096

# Verifica el endpoint
curl http://localhost:8000/v1/models
```

Luego en la interfaz de Dify → **Configuración → Proveedores de modelos → Compatible con OpenAI**:

* URL base: `http://localhost:8000/v1`
* Clave de API: `dummy`
* Nombre del modelo: `mistralai/Mistral-7B-Instruct-v0.2`

> Para la configuración completa de vLLM, consulta [language-models/vllm.md](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md).

### Recomendaciones de memoria GPU para modelos locales

| Modelo             | VRAM requerida | GPU de Clore recomendada |
| ------------------ | -------------- | ------------------------ |
| Llama 3 8B (Q4)    | 6 GB           | RTX 3060                 |
| Llama 3 8B (FP16)  | 16 GB          | RTX 3090 / 4090          |
| Mistral 7B (Q4)    | 5 GB           | RTX 3060                 |
| Llama 3 70B (Q4)   | 40 GB          | A100 40GB                |
| Llama 3 70B (FP16) | 140 GB         | 2× H100                  |

***

## Consejos y buenas prácticas

### Optimización de costos en Clore.ai

```bash
# Usa precios spot — las bases de datos de Dify mantienen el estado en volúmenes
# así puedes detener/reiniciar la instancia a bajo costo

# Antes de detener tu instancia de Clore, haz un volcado de la base de datos:
docker exec docker-db-1 pg_dump -U postgres dify > dify_backup_$(date +%Y%m%d).sql

# Comprime el volumen de almacenamiento para transferirlo
tar czf dify_storage_$(date +%Y%m%d).tar.gz \\
  $(docker volume inspect docker_app_storage --format '{{.Mountpoint}}')
```

### Habilita HTTPS con Caddy (recomendado para producción)

```bash
# Añade Caddy a docker-compose.yaml o ejecútalo de forma independiente
docker run -d \\
  --name caddy \\
  --network docker_default \\
  -p 443:443 -p 80:80 \\
  -v $PWD/Caddyfile:/etc/caddy/Caddyfile \\
  -v caddy_data:/data \\
  caddy:latest

# Contenido de Caddyfile:
# your-domain.com {
#     reverse_proxy nginx:80
# }
```

### Escala los workers para cargas de trabajo pesadas

```bash
# Ejecuta 4 workers de celery en lugar de 1
docker compose up -d --scale worker=4
```

### Monitorea el uso de recursos

```bash
# Estadísticas en vivo de los contenedores
docker stats

# Utilización de la GPU (si usas modelos locales)
watch -n1 nvidia-smi

# Registros de la aplicación Dify
docker compose logs -f api worker
```

### Ajuste del rendimiento de RAG

* Establece **tamaño del fragmento** a 512–1024 tokens para la mayoría de tipos de documentos
* Habilita **recuperación padre-hijo** para documentos largos en la configuración del conjunto de datos
* Usa **búsqueda híbrida** (palabra clave + vector) para mejor recuperación en contenido técnico
* Indexa los documentos durante las horas de menor actividad para evitar límites de tasa de la API

***

## Solución de problemas

### Los servicios siguen reiniciándose

```bash
# Revisa los registros del servicio que falla
docker compose logs --tail=50 api
docker compose logs --tail=50 worker

# Causa común: SECRET_KEY incorrecta o conexión a la BD
# Asegúrate de que SECRET_KEY en .env esté configurada y sea única
grep SECRET_KEY .env
```

### "La migración falló" al iniciar

```bash
# Ejecuta manualmente las migraciones de la BD
docker compose exec api flask db upgrade

# Si eso falla, comprueba primero que Postgres esté saludable
docker compose exec db pg_isready -U postgres
```

### No se puede conectar a Ollama desde Dify

```bash
# Ollama, de forma predeterminada, se enlaza a 127.0.0.1
# Cámbialo para que escuche en todas las interfaces:
OLLAMA_HOST=0.0.0.0 ollama serve

# O edita el servicio systemd:
systemctl edit ollama
# Añade debajo de [Service]:
# Environment="OLLAMA_HOST=0.0.0.0"
systemctl restart ollama

# Prueba desde dentro de un contenedor de Dify:
docker compose exec api curl http://host.docker.internal:11434/api/tags
```

### Sin espacio en disco

```bash
# Revisa los tamaños de los volúmenes
df -h
docker system df

# Elimina las imágenes no utilizadas
docker image prune -a

# Los registros de Weaviate pueden crecer mucho — gíralos
docker compose exec weaviate truncate -s 0 /tmp/weaviate.log
```

### Errores del almacén vectorial Weaviate

```bash
# Reinicia Weaviate (ADVERTENCIA: elimina todos los embeddings, será necesario reindexar)
docker compose stop weaviate
docker volume rm docker_weaviate_data
docker compose up -d weaviate

# Luego reindexa tus conjuntos de datos en la interfaz de Dify → Conjuntos de datos → [conjunto de datos] → Reindexar
```

### El puerto 80 ya está en uso

```bash
# Averigua qué está usando el puerto 80
ss -tlnp | grep :80
# o
lsof -i :80

# Detén el servicio en conflicto o cambia el puerto de nginx de Dify en docker-compose.yaml
```

***

## Lecturas adicionales

* [Documentación oficial de Dify](https://docs.dify.ai)
* [Repositorio de GitHub de Dify](https://github.com/langgenius/dify)
* [Guía de autoalojamiento de Dify](https://docs.dify.ai/getting-started/install-self-hosted/docker-compose)
* [Ejecutar Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md)
* [Ejecutar vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md)
* [Comparación de GPU en Clore.ai](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md)
* [Discord de la comunidad de Dify](https://discord.gg/FngNHpbcY7)


---

# 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/dify.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.