DifyNew

Updated

Open-source LLM app and agent platform: workflows, RAG knowledge bases, model management and observability in one interface, self-hostable community edition.

  • Popularity
  • LLM Apps
  • Agent
  • RAG
  • Open Source
  • Self-hosted
  • Coding
  • Free tier
Visit website
Dify: The Parts of an LLM App, in One Interface thumbnail
Report incorrect information

Choose an issue below. You do not need to sign in or leave contact details.

At a glance

Puts workflows, knowledge bases, model management and logs behind one visual interface, so prototype to production doesn't mean switching tools.

  • Free tierPartialFree self-hosted community edition; paid cloud plans
  • Open sourcePartialSource available; Apache 2.0 plus multi-tenant and logo conditions
  • Chinese supportYes
  • Works in ChinaYesSelf-hostable inside China
  • APIYes
Best for
  • Teams shipping AI features to business users without building a framework first
  • Companies that need self-hosting with data staying inside the network
  • People who want to prototype visually before deciding to write code
Pros
  • Workflows, RAG, agents and prompt versioning in one place
  • Community edition self-hosts via Docker, keeping data on your own infrastructure
  • Works with international and Chinese providers, plus local models
Cons
  • Self-hosting means owning Docker, the vector store and upgrades
  • Visual orchestration gets unwieldy with complex logic — deep customization still ends in code
  • Not MIT licensed: no multi-tenant SaaS without authorization, and the frontend logo and copyright can't be removed
Pricing

The community edition is open source and free to self-host; cloud and enterprise plans follow current official pricing.

Pricing changes over time; check the official site

Access from mainland China

Can be self-hosted on servers inside China and pointed at domestic model APIs for an entirely local setup.

Alternatives

Dify is a source-available LLM application platform that gathers AI workflows, RAG knowledge bases, agent capabilities, model management and observability into a single visual interface. It sits between "write code against an API" and "pure low-code tool": build the prototype in the UI, and use the API that every feature exposes to wire it into your own systems.

What It Does

  • Workflow orchestration: chain questions, retrieval, model calls, branches and tools into a visual flow.
  • Knowledge bases (RAG): upload PDFs, slide decks and other common formats and get text extraction, chunking, embedding and retrieval as the grounding for answers.
  • Agents: let a model call tools to finish multi-step tasks; newer versions also offer autonomous agents that run commands, install software and manage files inside a sandbox.
  • Tool ecosystem: connect tools from the Dify plugin marketplace, MCP servers or your own APIs.
  • Prompt management: variables, conditions, versioning and side-by-side model tests a team can collaborate on.
  • Model access: international providers, Chinese providers and locally deployed models all plug in.
  • Monitoring: track how applications run, with integrations for observability platforms such as Langfuse, Opik and Arize Phoenix.

Why It Earns Its Own Entry

Most teams' first AI app is the same pile of chores: chunk documents, store vectors, assemble prompts, keep logs, give the business side something clickable. Dify standardizes that pile. What it saves is the two weeks of building scaffolding from scratch — not any capability of the model itself.

It doesn't abolish code: complex logic still ends up in custom nodes or external services, and visual orchestration shows its limits as soon as a flow gets complicated. Treat it as scaffolding for the first 80%, not a complete replacement.

Two Ways to Start

Cloud: sign up on the official site and start right away; the free Sandbox plan includes 200 GPT-4 calls, enough to learn the product.

Self-hosted: the project asks for at least 2 CPU cores and 4 GB of RAM. After cloning the repository, run:

cd dify/docker
cp .env.example .env
docker compose up -d

Then open http://localhost/install in a browser to finish setup and create the administrator account. Next, add your model's API key under Settings → Model Provider, and you can create your first app.

Read the License

The community edition is not MIT licensed. It uses the Dify Open Source License, which adds conditions on top of Apache 2.0. The two main ones:

  • Without written authorization, you may not use the Dify source code to operate a multi-tenant environment (one workspace counts as one tenant) — in other words, you can't simply turn it into a multi-tenant SaaS you sell to others.
  • You may not remove or modify the logo or copyright information in the Dify console or application frontend.

Internal self-hosting inside a company is largely unaffected; if you plan to offer it as an external service or rebrand it, read the full license or contact the company first.

Deployment and Operations

The community edition self-hosts with Docker, keeping data on your own infrastructure; there are also cloud and enterprise offerings. For teams whose data can't leave the network, self-hosting is the most practical selling point — but the operational cost of Docker, a vector store and version upgrades is yours. Back up the data volumes and read the release notes before upgrading.

Using It in China

It deploys directly on servers inside China, and with a Chinese provider's API on the model side it runs entirely domestically. That is a big part of why it has spread faster among Chinese teams than comparable overseas products.

How It Compares

  • If you mainly automate business processes across systems (forms, CRM, notifications) and AI is just one step: n8n.
  • If you need full code-level control over every step: use a framework such as LangChain directly.
  • If you only want a team chat interface for local models: Open WebUI is lighter.