Dify: plataforma LLMOps self-hosted

Probado con Dify 1.17.1 · Weaviate 1.39.2 · PostgreSQL 15 · Docker Compose 2.40 · verificado 2026-09-16

Actualizado: 2026-09-16

Dify es una plataforma de código abierto que reúne en una sola interfaz todo lo que necesitas para construir aplicaciones de IA en producción. Incluye un lienzo visual para diseñar flujos, gestión de prompts, una base de conocimiento con RAG y las capas de LLMOps para vigilar cada ejecución. Lo mejor es que puedes autoalojarla entera con Docker Compose, de modo que ni tus prompts ni los datos de tus usuarios salen de tu servidor.

En esta guía verás qué es Dify, cómo desplegar la versión 1.17.1 sin dejar puertos abiertos y qué tipos de app crea. También verás cómo funciona su RAG y cuándo conviene frente a Flowise y Langflow. La misma explicación está disponible en inglés.

Puntos clave

• Dify es una plataforma de código abierto para desarrollar aplicaciones y agentes de IA; el 16 de septiembre de 2026 sumaba 155 981 estrellas y 1473 colaboradores en GitHub, y la última versión estable es la 1.17.1, del 10 de septiembre de 2026.
• Es autoalojable: un docker compose up -d levanta 16 servicios y, con el .env de serie, publica los puertos 80, 443 y 5003 en todas las interfaces de red, así que conviene atarlos a 127.0.0.1 antes de arrancar.
• Crea cuatro tipos de app sin escribir código: chatbot, agente (con Function Calling y ReAct sobre más de 50 herramientas), flujo de trabajo visual y generador de texto. Desde la 1.16.0 suma Dify Agent, un agente en beta que trabaja dentro de un sandbox Linux.
• Su base de conocimiento integra un RAG completo: subes PDF, PPT o Markdown, Dify los trocea, los indexa en una base de datos vectorial y los conecta a tus apps con filtrado por metadatos.
• Su licencia es una versión modificada de Apache 2.0: puedes usarla y venderla, pero no ofrecerla como servicio multiinquilino ni quitar el logotipo de Dify de la consola sin un acuerdo comercial.

Qué ha cambiado desde la 1.15.0

Esta guía se escribió con Dify 1.15.0 (25 de junio de 2026). La versión actual es la 1.17.1, publicada el 10 de septiembre de 2026, con la 1.16.0, la 1.16.1 y la 1.17.0 entre medias. Comprobado el 16 de septiembre de 2026 contra las notas de versión del repositorio y con una instalación nueva de la 1.17.1:

• Weaviate 1.39.2: la 1.17.1^[1] sube el Weaviate incluido desde la 1.27.0 y lo descarga de cr.weaviate.io. Si ya guardas vectores en él, no hagas pull y reinicio. Las notas exigen pasar por cada versión menor en orden con la ruta de actualización de Weaviate^[2], porque saltárselas puede romper la búsqueda vectorial sin avisar. Las instalaciones nuevas no se ven afectadas.
• Dify Agent (beta): la 1.16.0, del 17 de julio de 2026^[3], estrenó un agente que corre en un sandbox Linux, con su propio constructor, Skills y archivos, y que se puede usar como nodo dentro de un flujo de trabajo o publicar como web app. El propio equipo avisa de que solo debe ofrecerse a usuarios de confianza.
• Plugin de OpenAI: desde la 1.16.0 las configuraciones nuevas usan la API Responses en lugar de Chat Completions. Si guardaste una clave con el ajuste antiguo, revísala antes de atribuir a Dify los errores con los modelos recientes.
• Sandbox E2B, snapshots y gestor de Skills: la 1.17.0^[4] permite ejecutar el agente en sandboxes E2B (DIFY_AGENT_RUNTIME_BACKEND, con un docker-compose.e2b.yaml nuevo), captura el directorio home del agente al publicarlo para que cada ejecución arranque del mismo estado y añade un gestor de Skills por espacio de trabajo con ciclo borrador, publicación y versión.
• Variables de entorno de LLM en los flujos: la 1.17.0 deja definir una configuración de proveedor, modelo y parámetros una sola vez y referenciarla desde cualquier nodo LLM, de modo que un cambio de modelo se hace en un sitio y sobrevive a la exportación del DSL.
• Intervención humana dentro de bucles e iteraciones, trazado unificado opcional (OPS_TRACE_UNIFIED_ENABLED, con adaptadores para Phoenix y LangSmith), Cloudflare Turnstile en el inicio de sesión y un KMS enchufable con Azure Key Vault, todo en la 1.17.0.
• Claves de API por base de conocimiento: la 1.17.1 permite atar una clave de la API de servicio a bases de conocimiento concretas, y las claves que ya tenías siguen valiendo para todo el espacio de trabajo. También reduce de 3 días a 2 horas el tiempo que se guardan los eventos de cada ejecución del agente (DIFY_AGENT_RUN_RETENTION_SECONDS).

Los comandos de esta guía fijan ya la 1.17.1. Y una nota sobre la comparativa del final. El repositorio de Flowise se archivó en modo solo lectura el 13 de agosto de 2026, así que ha dejado de ser una alternativa para empezar nada nuevo.

¿Qué es Dify?

Dify es una plataforma de código abierto para construir aplicaciones basadas en modelos de lenguaje, desde un simple chatbot hasta un agente con acceso a herramientas o un flujo de trabajo multipaso. Su documentación la presenta como «una plataforma de código abierto para crear aplicaciones de IA» con la que diseñas agentes, flujos agénticos y chatbots sobre tus propios datos. Agrupa en un mismo producto lo que en otro caso montarías con media docena de bibliotecas sueltas: la orquestación, la gestión de prompts, la conexión a los modelos, el RAG y la observabilidad.

El proyecto nació en 2023 de la mano de LangGenius y se ha convertido en uno de los repositorios de IA más populares de GitHub. El 16 de septiembre de 2026 reunía 155 981 estrellas y 1473 colaboradores, y sus cuatro últimas versiones estables salieron con entre 11 y 28 días de separación.

La idea de fondo es la de una plataforma de LLMOps. No basta con que tu aplicación funcione una vez en tu portátil: también quieres revisar los registros de producción, comparar versiones de un prompt y afinar el modelo con datos reales. Dify pone esas piezas al alcance de un equipo que no quiere reinventar la fontanería.

Conviene aclarar el término del titular. LLMOps es al ciclo de vida de las aplicaciones con modelos de lenguaje lo que DevOps es al software tradicional: cubre el diseño, el despliegue, la supervisión y la mejora continua. Dify no es solo un editor visual, es esa capa operativa que registra cada llamada, su coste y su latencia, y te deja anotar respuestas para mejorar el sistema iterando con evidencia.

Desplegarlo con Docker Compose

La gran ventaja de Dify frente a un servicio en la nube es que puedes ejecutarlo entero en tu propia máquina. Su documentación pide 2 núcleos de CPU, 4 GiB de RAM y Docker Compose 2.24.0 o superior; en macOS, dale al menos 8 GiB a la máquina virtual de Docker Desktop. Si aún no tienes Docker, instálalo en Debian primero. Estas órdenes descargan la 1.17.1 y preparan la configuración:

git clone --depth 1 --branch 1.17.1 \
  https://github.com/langgenius/dify.git
cd dify/docker
cp .env.example .env

El parámetro --branch 1.17.1 fija la versión estable en lugar de la rama principal, y --depth 1 descarga solo ese estado. Antes de arrancar, cierra los puertos. Con el .env de serie, el contenedor nginx publica el 80 y el 443, y el plugin_daemon publica el 5003 de depuración remota de plugins, los tres en todas las interfaces de red.

Las variables EXPOSE_* del .env eligen el puerto del host, y las de nginx admiten además la IP. Estos son los valores de nuestra prueba; cambia los puertos por los tuyos:

EXPOSE_NGINX_PORT=127.0.0.1:22280
EXPOSE_NGINX_SSL_PORT=127.0.0.1:22243
EXPOSE_PLUGIN_DEBUGGING_PORT=22203
TRIGGER_URL=http://localhost:22280
ENDPOINT_URL_TEMPLATE=http://localhost:22280/e/{hook_id}
NEXT_PUBLIC_SOCKET_URL=ws://localhost:22280

Las tres últimas líneas añaden el puerto a las direcciones que Dify construye con localhost a secas. Son las de los disparadores por webhook, las de los endpoints de plugins y la del WebSocket de edición colaborativa. Si vas a entrar desde otra máquina, pon ahí el nombre público en lugar de localhost.

El puerto de depuración de plugins no admite la IP. Compose pasa también EXPOSE_PLUGIN_DEBUGGING_PORT al contenedor api como PLUGIN_REMOTE_INSTALL_PORT, que solo acepta un número. Con 127.0.0.1:22203, la configuración del api 1.17.1 falla al cargar con el error PLUGIN_REMOTE_INSTALL_PORT must be a bare port number.

La solución que propone ese mismo error es un docker-compose.override.yaml junto al docker-compose.yaml, que Compose lee sin que se lo indiques. La etiqueta !override sustituye la lista de puertos en lugar de añadirle otra entrada, y exige Docker Compose 2.24.4 o superior^[5], algo más que el mínimo de Dify:

services:
  plugin_daemon:
    ports: !override
      - "127.0.0.1:22203:5003"

Con los puertos cerrados, arranca la pila y comprueba el estado de cada servicio:

docker compose up -d
docker compose ps -a --format 'table {{.Service}}\t{{.Status}}'

Esta es la salida de la prueba. Los tiempos no coinciden porque algunos servicios se recrearon al cambiar el .env:

SERVICE            STATUS
agent_backend      Up About a minute
agent_ssrf_proxy   Up 13 minutes
api                Up About a minute (healthy)
api_websocket      Up About a minute
db_postgres        Up 13 minutes (healthy)
init_permissions   Exited (0) About a minute ago
local_sandbox      Up 13 minutes (healthy)
nginx              Up 13 minutes
plugin_daemon      Up About a minute
redis              Up 3 minutes (healthy)
sandbox            Up About a minute (healthy)
ssrf_proxy         Up 13 minutes
weaviate           Up 13 minutes
web                Up About a minute
worker             Up About a minute
worker_beat        Up About a minute

Son 16 servicios, los mismos que enumera la guía de despliegue con Docker Compose^[6]. Los siete servicios base empiezan por el api de Python y su variante api_websocket, que atiende la edición colaborativa. Les siguen el worker de Celery que procesa las tareas en cola, el worker_beat que las programa, el web de Next.js, el plugin_daemon y el agent_backend de Dify Agent.

Las ocho dependencias son Postgres 15 para los datos, Redis 6 para la caché y la cola de tareas de Celery, Weaviate 1.39.2 como base de datos vectorial y nginx delante de todo. Completan la lista dos proxies Squid contra la falsificación de peticiones del lado del servidor (SSRF), ssrf_proxy y agent_ssrf_proxy, y dos sandboxes: el del código de los flujos y el local_sandbox del agente. El servicio número 16, init_permissions, ajusta los permisos del almacenamiento y termina con código 0.

Si prefieres otra base de datos vectorial, cambia Weaviate por Qdrant, Milvus o pgvector con la variable VECTOR_STORE del .env. Con las imágenes ya descargadas, la API ya respondía a los 26 s del up -d, en una máquina arm64 de 18 núcleos compartida con otros trabajos (carga media entre 2,3 y 4,7). En reposo, con una app vacía y sin plugins, los 15 contenedores activos sumaban 2,0 GiB de RAM según docker stats.

Abre http://localhost:22280/install para crear la cuenta de administrador; a partir de ahí, http://localhost:22280 te lleva al panel. Hazlo nada más arrancar. Hasta que exista ese administrador, la ruta de instalación no pide credenciales, y cualquiera que alcance el puerto puede quedarse con la cuenta salvo que fijes INIT_PASSWORD en el .env.

Antes de exponerlo en internet, repasa estas variables del .env:

• SECRET_KEY: déjalo vacío y Dify genera uno persistente en su almacenamiento, o fija el tuyo
• DB_PASSWORD y REDIS_PASSWORD: llegan con el valor genérico difyai123456
• CELERY_BROKER_URL: repite la contraseña de Redis dentro de la URL. Si cambias solo REDIS_PASSWORD, docker compose ps sigue mostrando los servicios en Up, pero el worker escribe en bucle Cannot connect to redis://:**@redis:6379/1: invalid username-password pair or user is disabled.
• DIFY_AGENT_API_TOKEN y DIFY_AGENT_SERVER_SECRET_KEY: la documentación de Dify Agent^[7] pide sustituirlos por valores aleatorios en producción
• DO_NOT_TRACK=true: no viene en el .env.example. Añádelo y el worker deja de enviar a otel.dify.ai un latido anónimo con el identificador de la instancia, la versión, el sistema operativo y la arquitectura.

Por último, termina el HTTPS delante del contenedor nginx incluido, por ejemplo con Traefik, Caddy o certificados de Let’s Encrypt. Para actualizar, las notas de la 1.17.1 marcan este orden. En un clon hecho con --depth 1, la línea de git fetch sustituye a su git fetch --tags:

docker compose down
git fetch --depth 1 origin tag 1.17.1
git checkout 1.17.1
docker compose pull
docker compose up -d

Las dos órdenes de git las probamos al pasar un clon de la 1.17.0 a la 1.17.1. La parte de Docker con datos ya existentes no la hemos probado en esta revisión. Si usas el Weaviate incluido y ya tiene vectores, completa antes su ruta de actualización.

Recuerda su licencia, una versión modificada de Apache 2.0. El uso interno y comercial está permitido, pero no puedes ofrecer Dify como servicio multiinquilino ni retirar su logotipo de la consola sin autorización escrita.

Apps: chat, agente y flujo

Una vez dentro, Dify organiza todo en torno a cuatro tipos de aplicación que eliges al crearla. El chatbot es el más directo: eliges un modelo, escribes las instrucciones del sistema y, opcionalmente, le enganchas una base de conocimiento. El generador de texto es su primo de un solo turno, ideal para tareas como resumir o traducir a partir de una plantilla con variables.

Los dos tipos interesantes para quien construye agentes son el agente y el flujo de trabajo. El agente sigue el patrón clásico de razonamiento y acción: le das un objetivo y un conjunto de herramientas, como la búsqueda web, un lector de páginas o tu propia API mediante OpenAPI. El modelo decide en cada iteración qué invocar, con estrategias de Function Calling o ReAct. Dify trae más de cincuenta herramientas integradas de fábrica.

El flujo de trabajo, en cambio, es un lienzo visual donde encadenas nodos con un control total del recorrido. Esos nodos son llamadas al modelo, condiciones, bucles, código Python o un nodo de intervención humana que pausa la ejecución para pedir aprobación. Es algo parecido a lo que ofrece LangGraph pero sin escribir el grafo a mano. Ese mismo lienzo tiene además una variante pensada para el turno a turno de una conversación, llamada Chatflow, con memoria y variables propias de cada charla.

El nuevo Dify Agent, en beta desde la 1.16.0, tiene su propia página de agentes, y la documentación llama ahora Legacy Agent al tipo anterior. Trabaja en un sandbox propio donde ejecuta órdenes, instala programas y lee y escribe archivos, y lo usas como app de chat o como paso dentro de un flujo. En Docker Compose viene activado de serie, con su entorno de ejecución en los servicios agent_backend y local_sandbox. Para conectarlo a un modelo que corre en tu máquina, sigue la guía Dify Agent con un modelo local.

Cualquiera de esas apps se publica al instante como una API REST: Dify actúa de backend para tu producto, de modo que tu aplicación solo tiene que llamar a un endpoint. Así se conversa con un chatbot ya publicado:

curl -X POST 'http://localhost:22280/v1/chat-messages' \
  -H 'Authorization: Bearer app-tu_clave_de_api' \
  -H 'Content-Type: application/json' \
  -d '{
    "inputs": {},
    "query": "Resume que es una plataforma LLMOps",
    "response_mode": "streaming",
    "user": "usuario-1"
  }'

Con un chatbot recién creado y una clave válida, esa llamada devolvió {"code":"invalid_param","message":"Provider openai does not exist.","status":400}. La ruta y la clave funcionan, pero una instalación nueva no trae ningún proveedor de modelos: instala antes el plugin del tuyo desde el menú Integraciones. En la máquina de pruebas no pudimos descargar paquetes del Marketplace, así que esta revisión no comprueba la respuesta del modelo.

RAG y base de conocimiento

Aquí es donde Dify ahorra más trabajo. Montar un RAG a mano implica trocear documentos, calcular embeddings, elegir una base de datos vectorial, escribir la lógica de recuperación y coserlo todo al prompt. Dify empaqueta ese circuito en su base de conocimiento. Subes tus archivos (PDF, Word, PPT, Markdown o una URL), eliges cómo trocearlos y la plataforma se encarga del resto, con la vectorización y la indexación incluidas.

En el momento de la consulta, Dify recupera los fragmentos más relevantes y los inyecta en el contexto del modelo. Puedes ajustar la recuperación fina: elegir entre búsqueda vectorial, por palabras clave o híbrida, o activar un modelo de reordenación. Y, desde la versión 1.1.0, filtrar por metadatos para que una consulta solo mire ciertos documentos.

La versión 1.12.0 añadió el índice de resumen: genera un resumen por cada fragmento, no por documento entero. Cuando una consulta encaja con ese resumen, recupera de una vez todos los fragmentos relacionados, así que acelera la búsqueda sobre grandes volúmenes sin perder contexto.

Como el modelo que responde puede ser cualquiera, nada te impide servir uno en tu propia máquina con Ollama, a través de su API compatible con OpenAI. Así consigues un RAG completo donde ningún dato sale de tu red.

Dify frente a Flowise y Langflow

Dify no está solo: Flowise y Langflow compiten en el mismo terreno de los constructores visuales autoalojables. La diferencia está en la filosofía de cada uno.

Flowise y Langflow se apoyan en LangChain por debajo y piden menos recursos. Flowise arrancaba con npx flowise start, pero su repositorio ya no recibe cambios. Langflow destaca cuando necesitas nodos de Python personalizados, porque deja editar el código de cualquier componente, y su documentación fija el mínimo en 2 GB de RAM. Dify pesa más y pide 4 GiB.

A cambio, trae de serie lo que a los otros les falta. Es decir, una base de conocimiento madura, espacios de trabajo con roles y permisos, un depurador que muestra el tiempo y los tokens de cada nodo, y toda la capa de LLMOps.

Una regla práctica: empieza con Langflow para validar rápido una idea, y migra a Dify cuando necesites RAG serio, control de acceso por equipos o fiabilidad de producción. Flowise ya no entra en esa regla: sus mantenedores archivaron el repositorio el 13 de agosto de 2026 y han cerrado el proyecto.

Preguntas frecuentes

¿Es Dify realmente de código abierto y gratis?

Sí, con un matiz. Todo el producto es de código abierto y puedes autoalojarlo sin pagar nada, pero su licencia no es la Apache 2.0 estándar, sino una versión modificada con dos condiciones. La primera te impide ofrecer Dify como un servicio multiinquilino a terceros sin un acuerdo comercial; la segunda te prohíbe eliminar el logotipo y los avisos de copyright de la consola. Para uso interno de una empresa, para tus propios productos o para aprender, no hay ninguna limitación práctica.

¿Necesito saber programar para usar Dify?

No para lo básico. Puedes crear un chatbot con RAG, un agente con herramientas o un flujo multipaso con la interfaz visual, sin escribir una línea de código. Programar te ayuda en dos momentos: cuando quieres añadir un nodo de código Python dentro de un flujo para transformar datos y cuando integras las apps publicadas en tu producto mediante la API REST. En ese sentido es una herramienta de bajo código, no de cero código.

¿Puedo usar Dify con modelos locales en vez de con la API de OpenAI?

Sí. Dify es agnóstico respecto al proveedor del modelo: instalas como plugin el proveedor que quieras, incluidos los que sirven modelos en tu propia máquina, como Ollama o cualquier servidor compatible con OpenAI. Combinando Dify autoalojado con un modelo servido de forma local consigues una plataforma de IA completa en la que ningún prompt ni documento sale de tu red. Eso es decisivo en entornos con requisitos estrictos de privacidad.

Conclusión

Dify resuelve el salto entre «tengo una idea para una app de IA» y «tengo una app de IA en producción que puedo supervisar y mejorar». Con un docker compose up -d levantas una plataforma completa. Crea chatbots, agentes y flujos visuales, integra un RAG sobre tu propia base de conocimiento y registra cada ejecución con su coste. Todo dentro de tu red y con 1473 colaboradores detrás.

El siguiente paso es clonar la versión 1.17.1, atar sus puertos a 127.0.0.1 y levantar los contenedores. Después, instala un proveedor de modelos y crea tu primera app de chatbot conectada a un par de documentos para ver el RAG en marcha.

Fuentes

1. 1.17.1
2. ruta de actualización de Weaviate
3. 1.16.0, del 17 de julio de 2026
4. 1.17.0
5. exige Docker Compose 2.24.4 o superior
6. guía de despliegue con Docker Compose
7. documentación de Dify Agent
8. Documentación oficial de Dify
9. Dify en GitHub
10. Blog de Dify con las notas de versión
11. Comparativa independiente de Dify, Flowise y Langflow
12. Requisitos de instalación de Langflow
13. Repositorio archivado de Flowise

Ruta: Ecosistema de agentes: MCP, gateways y plataformas