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

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 bajo pedido. Consulta Precios y disponibilidad de GPU antes de dimensionar un despliegue.

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

# 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

# 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

# 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

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

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

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:

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

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

Opción B: sidecar de 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 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.

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

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

# 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

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

# 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

# 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

# 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

# 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

# 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

# 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

• Repositorio de GitHub de Dify

• Guía de autoalojamiento de Dify

• Ejecutar Ollama en Clore.ai

• Ejecutar vLLM en Clore.ai

• Comparación de GPU en Clore.ai

• Discord de la comunidad de Dify