Dify Template Gallery

Dify implements a drag-and-drop workflow builder that compiles visual node graphs into directed acyclic graphs (DAGs) executed via a Node Factory pattern with dependency injection. The workflow engine supports 8+ node types (LLM, HTTP, code execution, knowledge retrieval, human input, conditional branching) with a pause-resume mechanism for human-in-the-loop workflows. Node execution is serialized through a state machine that tracks context propagation between nodes, enabling complex multi-step orchestrations without code.

Dify abstracts LLM provider differences through a Provider and Model architecture that normalizes API calls across OpenAI, Anthropic, Ollama, Azure, and 20+ other providers. The Model Invocation Pipeline applies quota management via credit pools, rate limiting, and cost tracking per tenant/workspace. Provider configurations are stored in a centralized registry with environment-based credential injection, enabling multi-tenant isolation where each workspace can use different provider credentials.

Dify provides a Template Gallery with pre-built workflow templates for common use cases (customer support chatbot, content summarization, code review agent, email classifier). Templates are stored as JSON workflow definitions that users can import, customize, and deploy with minimal configuration. Templates include example prompts, tool configurations, and dataset references, enabling rapid prototyping without building workflows from scratch.

Dify exposes Chat and Completion APIs that accept user messages and return LLM responses with streaming support via Server-Sent Events (SSE). The API Architecture normalizes requests across different application types (chatbot, agent, workflow) with a unified request/response format. Streaming responses enable real-time display of LLM output as tokens arrive, improving perceived latency. The API supports conversation context injection, enabling stateless clients to maintain multi-turn conversations.

Dify provides a React-based web frontend with a visual workflow builder featuring drag-and-drop node composition, real-time preview, and inline prompt editing. The Frontend Build System uses Vite for fast development builds and supports dark mode, responsive design, and accessibility features. Workflow Node UI Components render different node types (LLM, HTTP, code, knowledge retrieval) with context-aware configuration panels. The Chat Interface supports message rendering, file uploads, and feedback collection.

Dify implements a centralized Configuration Management system that reads settings from environment variables, YAML files, and database records with a priority hierarchy. Provider credentials (API keys, OAuth tokens) are injected at runtime from environment variables, preventing hardcoding of secrets. The configuration system supports feature flags for A/B testing and gradual rollouts, enabling teams to enable/disable features without redeployment.

Dify implements a complete RAG system with a Document Indexing Pipeline that chunks, embeds, and stores documents in pluggable vector databases (Weaviate, Pinecone, Milvus, Qdrant). The Retrieval Strategies layer supports hybrid search (keyword + semantic), metadata filtering, and summary index generation for large document collections. Knowledge Retrieval Nodes in workflows query these indices with configurable similarity thresholds and result ranking, enabling semantic search without writing database queries.

Dify provides a Tool Provider architecture supporting three integration patterns: built-in tools (web search, file operations), API-based tools (REST endpoints with schema-driven function calling), and MCP (Model Context Protocol) plugins executed in isolated daemon processes. Tools are registered in a central registry with JSON schema definitions, enabling LLM agents to discover and invoke them via function calling. The Plugin Daemon manages lifecycle, sandboxing, and communication with external tool providers.

Dify implements a Tenant Model with workspace-level resource isolation, enabling multiple teams to operate independently within a single deployment. Role-Based Access Control (RBAC) defines permissions at workspace, dataset, and app levels with roles including Admin, Editor, and Viewer. Authentication supports multiple flows (email/password, OAuth, SAML) with session management via Flask-Login. Account Lifecycle Management handles user provisioning, deprovisioning, and workspace invitations.

Dify persists all conversations in PostgreSQL with message-level granularity, enabling retrieval of full chat histories, user feedback (thumbs up/down, ratings), and conversation analytics. The Conversation API supports streaming responses, message editing, and conversation branching (creating alternate paths from a message). Feedback is stored with optional annotations, enabling training data collection for model fine-tuning or RLHF workflows.

Dify uses Celery for background task processing, enabling long-running operations (document indexing, batch inference, report generation) to execute asynchronously without blocking the API. Tasks are queued in Redis or RabbitMQ with configurable retry logic, dead-letter handling, and task status tracking. Batch processing APIs allow users to submit multiple requests (e.g., 1000 documents for embedding) and poll for completion status.

Dify provides a Prompt Management system that stores prompt templates with variable placeholders (e.g., {{user_input}}, {{context}}), version history, and A/B testing support. Prompts are compiled at runtime by substituting variables from workflow context, enabling non-technical users to edit prompts without modifying workflows. Prompt versioning allows rollback to previous versions and comparison of prompt changes.

Dify implements a File Upload API that accepts documents in multiple formats (PDF, DOCX, TXT, Markdown, CSV, JSON) with automatic format detection and parsing. Uploaded files are stored in configurable backends (local filesystem, S3, Azure Blob Storage) and indexed asynchronously via Celery. The Document Management system tracks file metadata (size, upload time, processing status) and enables deletion with cascading cleanup of indexed embeddings.

Dify integrates OpenTelemetry for distributed tracing, capturing execution traces across workflow nodes, LLM calls, and tool invocations. The Trace Manager exports traces to backends like Jaeger, Datadog, or Sentry, enabling visibility into latency bottlenecks and error propagation. Traces include metadata (model name, token usage, cost) and support sampling for high-volume applications. Integration with Sentry provides error tracking and alerting.