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 state management across pause-resume cycles. Each node is instantiated through a factory that resolves dependencies and manages execution context, enabling complex multi-step pipelines without code.

Dify abstracts LLM provider diversity through a Provider and Model architecture that normalizes APIs from OpenAI, Anthropic, Ollama, and 20+ others into a unified invocation pipeline. The system implements quota management via credit pools that track token usage per provider, model, and tenant, with fallback routing when quotas are exceeded. Model invocation pipelines handle streaming, function calling, and vision capabilities uniformly across heterogeneous providers.

Dify integrates OpenTelemetry (OTEL) for distributed tracing and Sentry for error tracking. Workflow execution traces are captured with span-level granularity (LLM calls, tool invocations, retrieval operations), enabling performance debugging and bottleneck identification. Traces are exported to OTEL-compatible backends (Jaeger, Datadog, etc.). Errors are automatically reported to Sentry with context (user, workflow, inputs).

Dify supports API-based extensions that allow third-party services to be integrated as tools or data sources without modifying core code. Extensions are registered via API endpoints that define tool schemas, input/output formats, and authentication methods. The extension system supports both synchronous and asynchronous operations, with result caching and error handling.

Dify includes a workflow testing framework that allows users to execute workflows with sample data before deployment. The mock system enables testing individual nodes with predefined inputs, capturing outputs for validation. Test results are displayed in the UI with execution logs and variable values at each step. Testing is non-destructive; test runs do not affect production data or quota usage.

Dify's RAG system implements a full document lifecycle: ingestion via Dataset Service, chunking and embedding via configurable indexing pipelines, storage in abstracted vector databases (Weaviate, Pinecone, Milvus, etc.), and retrieval via multiple strategies (semantic search, BM25 hybrid, metadata filtering, summary index). The Knowledge Retrieval node integrates into workflows, executing retrieval queries with optional re-ranking and returning ranked results with source metadata.

Dify implements Model Context Protocol (MCP) support via a dedicated MCP client that communicates with external tool providers over SSE (Server-Sent Events) or stdio transports. The MCP Tool Provider integrates with Dify's tool registry, allowing workflows to invoke remote tools (e.g., filesystem access, web browsing, database queries) as first-class nodes. Tool schemas are dynamically discovered from MCP servers and exposed in the workflow builder.

Dify implements multi-tenancy via a Tenant Model that isolates resources (workflows, datasets, API keys) at the workspace level. Role-based access control (RBAC) enforces permissions across 5+ roles (owner, admin, editor, viewer, guest) with fine-grained controls on workflow execution, dataset access, and API key management. Authentication flows support SSO, API keys, and OAuth, with session management via JWT tokens.

Dify exposes Chat and Completion APIs that accept user messages, route them through workflows, and return streamed or buffered responses. The Chat API maintains conversation history per session, enabling context-aware multi-turn interactions. Feedback APIs allow end-users to rate responses (thumbs up/down) or provide annotations, which are stored for model improvement and RLHF training. Streaming is implemented via Server-Sent Events (SSE) for real-time token delivery.

Dify uses Celery for background task processing, enabling asynchronous workflow execution, document indexing, and quota updates. Batch processing APIs accept multiple requests (e.g., 100 documents to index, 1000 chat messages to process) and queue them as Celery tasks. Task status is tracked via a task queue, and results are stored in a result backend (Redis, database) for later retrieval. Long-running workflows can be executed asynchronously without blocking the API.

Dify provides a curated gallery of pre-built templates for common use cases (customer support chatbot, content generation, code review agent, RAG pipeline) that users can fork and customize. Templates are stored as workflow definitions (JSON) with embedded prompts, node configurations, and example datasets. Users can clone templates, modify prompts and node parameters via UI, and deploy without code.

Dify includes a Prompt Manager that enables versioning of prompts within workflows, with UI-based editing and testing. Users can create multiple versions of a prompt, test each version against sample inputs, and compare outputs side-by-side. Prompt variables are extracted and exposed as workflow inputs, enabling dynamic prompt injection. Prompt history is maintained, allowing rollback to previous versions.

Dify implements file upload APIs that accept documents (PDF, DOCX, TXT, images) and process them asynchronously. The document processing pipeline includes format conversion (PDF to text, images to text via OCR), chunking, and embedding. Uploaded files are stored in a configurable backend (S3, local filesystem) and indexed for RAG retrieval. File metadata (size, type, upload date) is tracked.