Plataforma de Flujo 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 con GPU.

Resumen

Dify.ai 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 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, 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

# 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

# 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

# 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

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

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

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:

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

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

Opción B: sidecar vLLM (alto rendimiento)

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

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

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

# 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

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

Monitorea el uso de recursos

# 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

# 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

# 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

# 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

# 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

# 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

# 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

• Repositorio de Dify en GitHub

• Guía de autoalojamiento de Dify

• Ejecutando Ollama en Clore.ai

• Ejecutando vLLM en Clore.ai

• Comparativa de GPU de Clore.ai

• Comunidad de Dify en Discord