Dify

Dify is an open-source LLM application development platform that bridges the gap between AI prototyping and production deployment. It provides a visual canvas for constructing multi-step AI workflows, a prompt IDE for iterating on prompts across models, a full RAG pipeline for building knowledge-grounded applications, and agent capabilities using both LLM Function Calling and ReAct patterns.

At its core, Dify handles the infrastructure that AI application builders typically have to wire up themselves: model provider integrations, vector database connections, conversation memory, file processing, observability hooks, and API generation. The platform ships with support for hundreds of LLMs from dozens of providers including OpenAI, Anthropic, Google Gemini, Mistral, and self-hosted open-source models via Ollama or any OpenAI-compatible endpoint.

Dify separates its product into a Python/Flask backend API server, Celery workers for asynchronous task execution, a Next.js 16 frontend console, and an nginx-fronted deployment stack. Everything can be stood up locally with a single docker compose up -d command. For teams that want to skip infrastructure management, Dify Cloud offers a hosted tier with a generous free sandbox plan.

The platform is designed around five application types — chatbot, text generation, agent, workflow, and chatflow — each with its own execution model and streaming pipeline. Workflows are defined as directed acyclic graphs with typed variable passing between nodes, enabling complex multi-step orchestration including conditional branching, iteration, knowledge retrieval, code execution, and now Human-in-the-Loop checkpoints where a workflow can pause and wait for human review or approval before continuing.

What You Get

• Visual workflow canvas with typed variable passing between nodes — LLM, code execution, knowledge retrieval, HTTP request, conditional branching, iteration, and human input nodes all connected via a drag-and-drop graph
• Comprehensive RAG pipeline covering document upload, chunking strategies (standard and parent-child), embedding, summary indexing, hybrid search, and reranking — with support for multiple vector databases including pgvector, Weaviate, Milvus, Qdrant, and others
• Model management layer that routes to hundreds of LLMs across OpenAI, Anthropic, Google, Mistral, Cohere, and self-hosted providers via a unified interface with per-tenant quota tracking
• LLMOps dashboard for monitoring application logs, conversation histories, token usage, and latency — with annotation tools for reviewing and correcting model outputs over time
• Backend-as-a-Service API generation for every app type, so your workflow or chatbot is immediately accessible via REST API with streaming support
• Built-in agent runtime with 50+ pre-built tools (Google Search, DALL-E, Stable Diffusion, WolframAlpha, web scraping) plus support for custom tools, MCP servers, and plugin marketplace
• Prompt IDE with multi-model comparison, variable templating, and text-to-speech capability baked in

Common Use Cases

• Customer support automation — connect a knowledge base of docs and FAQs to an LLM-powered chatbot that retrieves accurate answers from internal documents rather than hallucinating
• Document processing pipelines — build workflows that ingest PDFs or spreadsheets, extract structured data with LLMs, run conditional logic, and write results to external APIs or databases
• Internal tool augmentation — wrap existing internal tools and data sources in a Dify agent so employees can query CRMs, ticketing systems, or databases through a natural language interface
• Content generation workflows — chain prompt nodes, model calls, and code nodes to generate SEO content, summarize meeting transcripts, or draft emails in batch — with human review checkpoints before publishing
• Research and data analysis — build RAG-powered assistants that let analysts query large document corpora (research papers, legal contracts, financial reports) with citations and source grounding
• AI feature integration — use Dify’s generated APIs as a backend service to add AI capabilities to existing applications without building the LLM integration layer from scratch

Under The Hood

Architecture Dify follows a layered, modular architecture centered on a Python Flask API server with a clearly separated graph execution engine. The workflow system uses a directed acyclic graph abstraction where each node type is a distinct class implementing a common interface, with typed variable pools as the inter-node communication mechanism. Execution flows through composable GraphEngine layers — quota enforcement, observability, pause/resume for human input checkpoints — that wrap core execution without coupling concerns to node implementations. The application layer further separates app types (chat, workflow, agent, pipeline) into distinct runner classes, and asynchronous operations run through Celery task queues with Redis pub/sub for streaming event delivery back to the API server. This separation means adding a new node type, application type, or execution layer is well-isolated from existing concerns.

Tech Stack The backend is Python 3.12 on Flask with Flask-RESTX for API documentation and gevent for concurrent request handling, deployed via Gunicorn. Asynchronous tasks run on Celery workers backed by Redis, which also serves as the pub/sub layer for streaming workflow execution events to clients. Data persistence uses PostgreSQL via SQLAlchemy with Flask-Migrate for schema evolution. The frontend is a Next.js 16 application with React, Tailwind CSS, and Lexical for rich text editing, with Tanstack Query for data fetching and Zustand for client state. The model integration layer supports direct API calls to cloud providers alongside any OpenAI-compatible self-hosted endpoint. Vector storage is pluggable with official support for pgvector, Weaviate, Qdrant, Milvus, Chroma, Elasticsearch, OpenSearch, and more than a dozen others. Deployment targets Docker Compose for development and Kubernetes via Helm for production, with nginx fronting all services.

Code Quality Both the Python backend and TypeScript frontend have substantial test coverage — the API includes unit tests, integration tests, and container-based integration tests for database behavior and workflow pausing, while the frontend has extensive component-level tests using Vitest and testing-library across features including plugins, datasets, agents, MCP tools, and workflow nodes. The Python codebase uses type annotations throughout with a bootstrapped strict type checker, and error handling is generally explicit with typed exceptions rather than swallowed failures. CI includes ESLint with auto-fix bots and a codecov integration. The main quality consideration is the sheer scale of the codebase — well over ten thousand files — which introduces some inconsistency between older and newer modules as ongoing refactoring catches up to rapid feature growth.

What Makes It Unique Dify’s most distinctive technical contribution is its treatment of AI workflows as composable, typed data-flow graphs executed by a layered graph engine with genuine stateful pause/resume semantics. The Human-in-the-Loop node genuinely suspends a workflow mid-execution, persists its state to the database, delivers a review form via Webapp or Email, and resumes via Celery from an exact checkpoint — without any manual state serialization logic in node implementations. The combination of MCP server integration, native multi-modal RAG with AI-generated summary indexes for improved retrieval precision, and a sandboxed Skill Editor for reusable SOP blocks extends the platform in directions most competing frameworks have not yet reached. The open plugin marketplace with a creator platform for publishing and sharing workflow templates adds a community-driven capability layer on top of the orchestration engine.

Self-Hosting

Dify is released under a modified Apache 2.0 license. Commercially, individuals and teams can use it freely for internal applications and products, including production deployments. The key restriction is multi-tenancy at scale: if you intend to operate Dify as a service offered to multiple customers (each with their own workspace), you need a commercial license from LangGenius. Developers building a single-tenant internal tool or embedding Dify’s API into their own product are not affected by this restriction. The frontend UI (the web/ directory) also prohibits removing Dify’s logo or copyright notices unless you have an appropriate license.

Running Dify yourself means operating a moderately complex stack: a Python/Flask API server, Celery workers (including a dedicated workflow_based_app_execution queue added in v1.13), a Next.js frontend, PostgreSQL, Redis, and at least one vector store. The Docker Compose configuration handles all of this, but production deployments will need to think through persistence volumes, Redis cluster configuration for high-throughput streaming (using the PUBSUB_REDIS_URL and sharded PubSub settings), backup strategies for the PostgreSQL database and any uploaded document vectors, and horizontal scaling of Celery workers as workflow load increases. The team ships frequent releases (over 550 commits per month), which means staying current requires attention to upgrade notes — some releases (like v1.13) require new Celery queue configuration to be added before upgrading.

Compared to Dify Cloud, a self-hosted deployment gives you full data sovereignty and no usage-based billing on model calls (you pay your own provider directly), but you give up managed upgrades, SLA guarantees, built-in high-availability, and enterprise support. The cloud tier includes a sandboxed plan with free GPT-4 credits and a Dify Premium AMI on AWS Marketplace for teams that want a managed setup within their own VPC. Enterprise self-hosters can contact LangGenius for dedicated support channels, SLA agreements, and access to enterprise features like workspace permission controls and credential sync.