# Plataforma de flujos de trabajo Dify.ai

## Resumen

[Dify.ai](https://github.com/langgenius/dify) es una plataforma de desarrollo de aplicaciones LLM de código abierto con **114K+ estrellas en GitHub**. Combina un constructor visual de flujos de trabajo, una 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 única pila autoalojable.

En **Clore.ai** puedes ejecutar la pila completa de Dify —incluida su base de datos Postgres, caché Redis, almacén vectorial Weaviate, proxy inverso Nginx, trabajadores de API y frontend web— en un servidor GPU alquilado por tan solo **$0.20–$0.35/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 backends Ollama o vLLM.

**Capacidades clave:**

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

***

## Requisitos

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

| Configuración                | GPU                | VRAM  | RAM del sistema | Disco  | Precio de Clore.ai |
| ---------------------------- | ------------------ | ----- | --------------- | ------ | ------------------ |
| **Mínima** (solo claves API) | Ninguno / Solo CPU | —     | 8 GB            | 30 GB  | \~$0.05/h (CPU)    |
| **Estándar**                 | RTX 3080           | 10 GB | 16 GB           | 50 GB  | \~$0.15/h          |
| **Recomendado**              | RTX 3090 / 4090    | 24 GB | 32 GB           | 80 GB  | $0.20–0.35/h       |
| **Producción + LLM local**   | A100 80 GB         | 80 GB | 64 GB           | 200 GB | \~$1.10/h          |
| **Alto rendimiento**         | H100 SXM           | 80 GB | 128 GB          | 500 GB | \~$2.50/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 importa solo cuando ejecutas modelos locales vía Ollama o vLLM — ver [Aceleración por GPU](#gpu-acceleration) más abajo.

### Nota sobre el disco

Los datos de Weaviate y Postgres crecen rápidamente con las cargas de documentos. Provisión **al menos 50 GB** y monta almacenamiento persistente mediante las opciones de volúmenes de Clore.ai.

***

## Inicio rápido

### 1. Alquila un servidor Clore.ai

Navega a [clore.ai](https://clore.ai), filtra por la GPU deseada y 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. Conectar y preparar el servidor

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

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

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

### 3. Clona Dify y lanza

```bash
# Clonar 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 ajustes antes de lanzar
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 (tarda 2-3 minutos en la primera ejecución)
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:
# NAME                    STATUS
# 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 lanzamiento, 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 vive en `dify/docker/.env`. Aquí están los ajustes más importantes:

### Variables de entorno esenciales

```bash
# ── Claves secretas (CAMBIA ESTO) ──────────────────────────────────────────────
SECRET_KEY=tu-clave-super-secreta-cámbiala-inmediatamente
# 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ámbialo en producción!
DB_HOST=db
DB_PORT=5432
DB_DATABASE=dify

# ── Redis ───────────────────────────────────────────────────────────────────
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_PASSWORD=difyai123456       # ¡Cámbialo 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=tu-bucket-dify
# S3_ACCESS_KEY=...
# S3_SECRET_KEY=...

# ── Proveedor LLM por defecto ──────────────────────────────────────────────────
# Configúralo en la UI tras iniciar sesión, o pré-configura aquí:
# OPENAI_API_KEY=sk-...
```

### Cambiar el puerto expuesto

Por defecto 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 del 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 por defecto:

```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 copia de seguridad:

```bash
# Detén los servicios primero, luego empaqueta (tar) los volúmenes 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 por GPU

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

### Opción A: sidecar Ollama (lo más sencillo)

Ejecuta Ollama junto a Dify en el mismo servidor 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 "¡Hola!"
nvidia-smi   # Debería mostrar el proceso ollama usando VRAM
```

Luego en la UI de Dify → **Ajustes → Proveedores de modelos → Ollama**:

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

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

### Opción B: sidecar 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 UI de Dify → **Ajustes → Proveedores de modelos → Compatible con OpenAI**:

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

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

### Recomendaciones de memoria GPU para modelos locales

| Modelo             | VRAM requerida | GPU 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 mejores prácticas

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

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

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

# Comprime el volumen de almacenamiento para transferir
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 por separado
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 del Caddyfile:
# your-domain.com {
#     reverse_proxy nginx:80
# }
```

### Escala trabajadores para cargas 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 contenedores
docker stats

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

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

### Ajuste de rendimiento RAG

* Establecer **tamaño de fragmento** a 512–1024 tokens para la mayoría de tipos de documentos
* Habilite **recuperación padre-hijo** para documentos largos en los ajustes del Dataset
* Usa **búsqueda híbrida** (palabra clave + vector) para mejor recall en contenido técnico
* Indexa documentos durante horas de baja carga para evitar límites de tasa de 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 errónea o conexión a 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 las migraciones de BD manualmente
docker compose exec api flask db upgrade

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

### No se puede conectar a Ollama desde Dify

```bash
# Ollama por defecto 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 bajo [Service]:
# Environment="OLLAMA_HOST=0.0.0.0"
systemctl restart ollama

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

### Sin espacio en disco

```bash
# Comprueba el tamaño de los volúmenes
df -h
docker system df

# Elimina imágenes no usadas
docker image prune -a

# Los registros de Weaviate pueden crecer mucho — rótales
docker compose exec weaviate truncate -s 0 /tmp/weaviate.log
```

### Errores del almacén vectorial Weaviate

```bash
# Reinicia Weaviate (ADVERTENCIA: borra todos los embeddings, se necesita reindexado)
docker compose stop weaviate
docker volume rm docker_weaviate_data
docker compose up -d weaviate

# Luego reindexa tus datasets en la UI de Dify → Datasets → [dataset] → Re-index
```

### El puerto 80 ya está en uso

```bash
# Encuentra 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 Dify en GitHub](https://github.com/langgenius/dify)
* [Guía de autoalojamiento de Dify](https://docs.dify.ai/getting-started/install-self-hosted/docker-compose)
* [Ejecutando Ollama en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md)
* [Ejecutando vLLM en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md)
* [Comparativa de GPU de Clore.ai](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md)
* [Comunidad de Dify en Discord](https://discord.gg/FngNHpbcY7)


---

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