Dify: a self-hosted LLMOps platform

Updated: 2026-09-02

Dify is an open-source platform that gathers into a single interface everything you need to build production AI applications. It includes a visual canvas to design workflows, prompt management, a knowledge base with RAG and the LLMOps layers to watch every run. The best part is that you can self-host the whole thing with Docker Compose, so neither your prompts nor your users’ data ever leave your server.

In this guide you will see what Dify is, how to deploy it, the four app types it builds, how its RAG works and when it beats Flowise and Langflow. The same explanation is available in Spanish.

Key takeaways

• Dify is an open-source platform for developing AI applications and agents; it has over 149,000 stars on GitHub, more than 450 contributors maintain it and it ships a new release almost weekly (the latest stable is 1.17.0, from 25 August 2026).
• It is self-hostable: a single docker compose up -d brings up 13 services and leaves the web UI on port 80, so your whole AI operation stays in your own infrastructure.
• It builds four app types with no code: chatbot, agent (with Function Calling and ReAct over more than 50 tools), a visual workflow and a text generator.
• Its knowledge base bundles a full RAG pipeline: you upload PDF, PPT or Markdown, Dify chunks them, indexes them in a vector database and connects them to your apps with metadata filtering.
• Its licence is a modified version of Apache 2.0: you may use and sell it, but you cannot offer it as a multi-tenant service or remove the Dify logo from the console without a commercial agreement.

What has changed since 1.15.0

This guide was written against Dify 1.15.0 (25 June 2026). The current version is 1.17.0, released on 25 August 2026, with 1.16.0 and 1.16.1 in between. Checked on 2 September 2026 against the repository’s release notes:

• Dify Agent (beta): 1.16.0, from 17 July 2026^[1], introduced an agent that runs in a Linux sandbox, with its own builder, Skills and files, usable as a node inside a workflow or published as a web app. The team itself warns it should only be offered to trusted users.
• OpenAI plugin: since 1.16.0 new configurations use the Responses API instead of Chat Completions. If you saved a key with the old setting, review it before blaming Dify for errors with recent models.
• E2B sandbox, snapshots and Skill management: 1.17.0^[2] lets the agent run on E2B sandboxes (DIFY_AGENT_RUNTIME_BACKEND, with a new docker-compose.e2b.yaml), captures the agent’s home directory when it is published so every run starts from the same state, and adds a workspace-level Skills manager with a draft, publish and version lifecycle.
• LLM environment variables in workflows: 1.17.0 lets you define a provider, model and parameter configuration once and reference it from any LLM node, so a model change happens in one place and survives DSL export.
• Human input inside loops and iterations, opt-in unified tracing (OPS_TRACE_UNIFIED_ENABLED, with Phoenix and LangSmith adapters), Cloudflare Turnstile on sign-in and a pluggable KMS with Azure Key Vault, all in 1.17.0.

The commands in this guide now pin 1.17.0. One note on the comparison at the end: the Flowise repository was archived read-only on 13 August 2026, so it is no longer an option for starting anything new.

What is Dify?

Dify is an open-source platform for building applications on top of language models, from a simple chatbot to an agent with tool access or a multi-step workflow. Its documentation describes it as a "production-ready platform for agentic workflow development": it gathers into one product what you would normally assemble from half a dozen separate libraries, namely orchestration, prompt management, model connectivity, RAG and observability.

The project started in 2023 from LangGenius and has become one of the most popular AI repositories on GitHub. It holds over 149,000 stars and a community of more than 450 contributors pushing a new release almost every week.

The underlying idea is that of an LLMOps platform. It is not enough for your application to work once on your laptop: you also want to review production logs, compare versions of a prompt and tune the model with real data. Dify puts those pieces within reach of a team that does not want to reinvent the plumbing.

Let us pin down the term in the title. LLMOps is to the lifecycle of language-model applications what DevOps is to traditional software: it covers design, deployment, monitoring and continuous improvement. Dify is not just a visual editor, it is that operational layer that logs every call, its cost and its latency, and lets you annotate responses to improve the system by iterating with evidence.

Deploying it with Docker Compose

Dify’s big advantage over a cloud service is that you can run it entirely on your own machine. The repository ships a docker-compose.yml meant to start in minutes; you only need a server with 2 CPU cores, 4 GiB of RAM and Docker Compose 2.24.0 or later. Startup is four commands:

git clone https://github.com/langgenius/dify.git
cd dify/docker

    # Pin a stable version instead of the main branch
git checkout 1.17.0
cp .env.example .env

    # Bring up the 13 services in the background
docker compose up -d

Behind that command, thirteen containers come up, grouped in three layers. The core services are the Python api, the Celery worker that processes queued tasks and the Next.js web. The dependencies are Postgres for data, Redis for cache and queues, a plugin server and a vector database.

Redis is an in-memory store that here works as the cache and the Celery task queue. Finally, an initialisation task prepares the schema. By default Dify uses Weaviate as its vector database, though you can swap it for Qdrant, Milvus or the pgvector of your own Postgres by editing the .env.

With the containers up, open http://localhost/install to create the admin account; from there, http://localhost takes you to the dashboard.

Before exposing it to the internet, edit the .env. Change the value of SECRET_KEY: leave it empty and Dify generates a persistent one on its own, or set your own. Replace the default DB_PASSWORD and REDIS_PASSWORD passwords, which ship with the generic value difyai123456. And terminate HTTPS in front of the bundled nginx container, for example with Traefik, Caddy or Let’s Encrypt certificates.

Remember its licence, a modified version of Apache 2.0. Internal and commercial use is allowed, but you cannot offer Dify as a multi-tenant service or remove its logo from the console without written authorisation.

Apps: chat, agent and workflow

Once inside, Dify organises everything around four app types you pick when you create one. The chatbot is the most direct: you choose a model, write the system instructions and, optionally, attach a knowledge base to it. The text generator is its single-turn cousin, ideal for tasks like summarising or translating from a template with variables.

The two interesting types for anyone building agents are the agent and the workflow. The agent follows the classic reason-and-act pattern: you give it a goal and a set of tools, such as web search, a page reader or your own API through OpenAPI. The model decides at each iteration what to call, with Function Calling or ReAct strategies. Dify ships more than fifty built-in tools out of the box.

The workflow, in contrast, is a visual canvas where you chain nodes with full control over the path. Those nodes are model calls, conditions, loops, Python code or a human-input node that pauses execution to ask for approval. It is something like what LangGraph offers but without writing the graph by hand. That same canvas also has a variant built for the turn-by-turn flow of a conversation, called Chatflow, with its own memory and per-conversation variables.

Any of those apps is published instantly as a REST API: Dify acts as the backend for your product, so your application only has to call an endpoint. This is how you talk to an already-published chatbot:

curl -X POST 'http://localhost/v1/chat-messages' \
  -H 'Authorization: Bearer app-YOUR-API-KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "inputs": {},
    "query": "Summarise what an LLMOps platform is",
    "response_mode": "streaming",
    "user": "user-1"
  }'

RAG and knowledge base

This is where Dify saves the most work. Building a RAG by hand means chunking documents, computing embeddings, choosing a vector database, writing the retrieval logic and stitching it all into the prompt. Dify packages that circuit in its knowledge base: you upload your files (PDF, Word, PPT, Markdown or a URL), choose how to chunk them and the platform handles the rest, vectorisation and indexing included.

At query time, Dify retrieves the most relevant chunks and injects them into the model’s context. You can tune the retrieval finely: choose between vector, keyword or hybrid search, or turn on a reranking model. And, since version 1.1.0, filter by metadata so a query only looks at certain documents.

Version 1.12.0 added the summary index: it generates a summary per chunk, not per whole document. When a query matches that summary, it retrieves every related chunk at once, which speeds up search over large volumes without losing context.

Because the answering model can be any of them, nothing stops you from serving one on your own machine with Ollama, through its OpenAI-compatible API. That gives you a full RAG where no data leaves your network.

Dify versus Flowise and Langflow

Dify is not alone: Flowise and Langflow compete on the same self-hostable visual-builder ground. The difference lies in each one’s philosophy.

Flowise and Langflow build on LangChain underneath and shine for their lightness. Flowise starts with a single command and runs on a 1 GiB server. Langflow, backed by DataStax, stands out when you need custom Python nodes and the power of LangGraph. Dify weighs more and needs 4 GiB.

In exchange, it ships out of the box what the others lack. That is a mature knowledge base, workspaces with roles and permissions, a debugger that shows the time and tokens of each node, and the whole LLMOps layer.

A rule of thumb: start with Langflow to validate an idea fast, and migrate to Dify when you need serious RAG, team-based access control or production reliability. Flowise no longer belongs in that rule: its maintainers archived the repository on 13 August 2026 and wound the project down.

Frequently asked questions

Is Dify really open source and free?

Yes, with a caveat. The whole product is open source and you can self-host it at no cost, but its licence is not the standard Apache 2.0, rather a modified version with two conditions. The first stops you from offering Dify as a multi-tenant service to third parties without a commercial agreement; the second forbids removing the logo and copyright notices from the console. For a company’s internal use, for your own products or for learning, there is no practical limitation.

Do I need to know how to code to use Dify?

Not for the basics: you can build a chatbot with RAG, an agent with tools or a multi-step workflow with the visual interface, without writing a line of code. Coding helps you at two moments. The first is when you add a Python code node inside a workflow to transform data; the second, when you integrate the published apps into your product through the REST API. In that sense it is a low-code tool, not a no-code one.

Can I use Dify with local models instead of the OpenAI API?

Yes. Dify is agnostic about the model provider: in its settings you add whichever provider you want, including the models you run on your own machine with Ollama or an OpenAI-compatible server. By combining self-hosted Dify with a locally served model you get a complete AI platform in which no prompt or document leaves your network, which is decisive in environments with strict privacy requirements.

Conclusion

Dify solves the jump between "I have an idea for an AI app" and "I have an AI app in production that I can monitor and improve". With a docker compose up -d you bring up a complete platform. It builds chatbots, agents and visual workflows, integrates a RAG over your own knowledge base and logs every run with its cost. All within your network, and with a community of more than 450 contributors behind it.

The next step is to clone the repository, pin version 1.17.0 and bring up the containers. Then create your first chatbot app connected to a couple of documents to see the RAG in action.

Sources

1. 1.16.0, from 17 July 2026
2. 1.17.0
3. Official Dify documentation
4. Dify on GitHub
5. Dify blog with the release notes
6. Independent comparison of Dify, Flowise and Langflow

Route: Agent Ecosystem: MCP, Gateways and Platforms