CommunityCoding & Developmentgithub.com

SystemTce/dify-skills

Complete skill system for Dify workflow and plugin development - modular, progressive, and practical.

What is dify-skills?

Dify Master SKILL is a modular, progressively disclosed skill system designed to guide developers through every stage of building with Dify, an open-source LLMOps platform. It covers the complete development lifecycle, from visual workflow design and custom plugin creation to performance optimization, secure deployment, and external system integration. The system is organized into six independent sub-skills, each targeting a specific domain: workflow design (01-workflow), plugin development (02-plugin), performance optimization (03-performance), security and deployment (04-security), integration and extensibility (05-integration), and reference materials (06-reference). Each sub-skill provides ready-to-use code templates, best practices, and detailed configuration examples, enabling developers to start building immediately while minimizing cognitive load through progressive disclosure. Supported by community resources and compatible with Dify versions 0.15.x through 1.9.x, this skill system is ideal for AI application developers, plugin creators, DevOps engineers, and solution architects looking to harness Dify's full potential.

Works with✓Claude Code✓Codex CLI~Cursor
npx skills add SystemTce/dify-skills

Installed? Explore more Coding & Development skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Ask in your favorite AI

Open a new chat with this agent skill pre-loaded.

Documentation

Dify Master SKILL

A modular, progressively disclosed Dify development skill system

Quick Navigation


What is Dify

Dify is an open-source LLMOps platform that provides visual workflow orchestration and a powerful plugin system, helping developers quickly build and deploy AI applications.

Core Features

  • Visual Workflows: Drag-and-drop orchestration, build complex AI apps without coding
  • Plugin System: Supports multiple plugin types: tools, models, data sources
  • Production Ready: Complete support from local development to large-scale distributed deployment
  • Open Source Ecosystem: 114K+ GitHub Stars, active community, and rich plugin marketplace

Technical Architecture

  • Beehive Architecture: Modular, extensible system design
  • Queue-Driven Graph Engine: Event-driven, parallel execution, high performance
  • Multi-Runtime Support: Local, Debug, and Serverless operating modes
  • MCP Protocol Integration: Standardized integration with AI assistants like Claude

SKILL System Overview

Dify Master SKILL adopts a modular design with 6 core sub-skills covering the complete development-to-deployment pipeline.

dify-master (main entry)
├── 01-workflow      # Workflow design
├── 02-plugin        # Plugin development
├── 03-performance   # Performance optimization
├── 04-security      # Security and deployment
├── 05-integration   # Integration and extension
└── 06-reference     # Reference materials

Design Philosophy

  1. Modular: Each sub-skill is independent and complete, usable on its own
  2. Progressive Disclosure: From overview to details, go deeper as needed
  3. Context Optimized: Minimize the amount of content loaded per session
  4. Practical Oriented: Provide ready-to-use code and configurations

Quick Start

Scenario 1: Create Your First Workflow

# Simple Q&A workflow
workflow:
  graph:
    nodes:
    - data:
        type: start
        variables: []
      id: start

    - data:
        type: llm
        model:
          provider: openai
          name: gpt-4
        prompt_template:
        - role: system
          text: "You are an assistant"
        - role: user
          text: "{{#sys.query#}}"
      id: llm

    - data:
        type: answer
        answer: "{{#llm.text#}}"
      id: answer

    edges:
    - source: start
      target: llm
    - source: llm
      target: answer

Next step: Learn 01-workflow SKILL for more node types and design patterns

Scenario 2: Develop Your First Plugin

# Simple tool plugin
from typing import Any, Generator
from dify_plugin.entities.tool import ToolInvokeMessage
from dify_plugin import Tool

class MyTool(Tool):
    def _invoke(
        self,
        tool_parameters: dict[str, Any]
    ) -> Generator[ToolInvokeMessage, None, None]:
        # Get parameters
        input_text = tool_parameters.get("text", "")

        # Processing logic
        result = input_text.upper()

        # Return result
        yield self.create_text_message(result)

Next step: Learn 02-plugin SKILL for the complete plugin development workflow

Scenario 3: Optimize Workflow Performance

# Use parallel branches to boost performance
- data:
    type: parallel
    branches:
    - nodes: [tool1, process1]
    - nodes: [tool2, process2]
    - nodes: [tool3, process3]
  id: parallel_execution

Next step: Learn 03-performance SKILL for more optimization techniques


Sub-SKILL Index

01. Workflow Design SKILL

Use Cases: Design and develop Dify workflows

Trigger Keywords: node, LLM, Agent, workflow, variable, knowledge retrieval, HTTP Request, Code, If-Else, Iteration, template, DSL, YAML

Core Content:

  • 10+ node types explained (Start, LLM, Agent, Knowledge Retrieval, Code, HTTP Request, Tool, If-Else, Iteration, Answer)
  • 5 design patterns (Sequential Pipeline, Conditional Branching, Iterative Processing, Knowledge Retrieval, Multi-Source Aggregation)
  • Ready-to-use workflow templates
  • Variable system and reference syntax
  • Best practices and common issues

Quick Access: 01-workflow/SKILL.md

Recommended for: Workflow designers, AI application developers, product managers


02. Plugin Development SKILL

Use Cases: Develop custom tool, model, and data source plugins

Trigger Keywords: plugin, Tool, Provider, development, manifest, OAuth, data source, model, extension

Core Content:

  • 4 plugin types (Tool, Model, Datasource, Extension)
  • Complete development workflow (initialize, implement, test, package, publish)
  • Standard project structure and configuration files
  • Provider and Tool development guides
  • Plugin templates and code examples
  • Testing strategies and debugging tips

Quick Access: 02-plugin/SKILL.md

Recommended for: Plugin developers, backend engineers, tool integrators


03. Performance Optimization SKILL

Use Cases: Optimize execution performance of workflows and plugins

Trigger Keywords: performance, optimization, cache, parallel, latency, throughput, monitoring, benchmark

Core Content:

  • Workflow optimization (graph structure, parallel execution, variable pool)
  • LLM optimization (model selection, prompt engineering, caching, structured output)
  • Plugin optimization (runtime selection, resource limits, async processing)
  • Monitoring and analysis tools
  • Performance benchmarks

Quick Access: 03-performance/SKILL.md

Recommended for: Performance engineers, architects, operations staff


04. Security and Deployment SKILL

Use Cases: Production environment deployment and security hardening

Trigger Keywords: security, deployment, Docker, Kubernetes, SSL, authentication, authorization, sandbox, SSRF

Core Content:

  • Security practices (SSRF protection, sandbox isolation, data encryption, authentication/authorization)
  • Deployment guides (Docker Compose, Kubernetes, Serverless, high availability)
  • Operations practices (monitoring, logging, backup, troubleshooting)
  • Environment configuration and resource planning
  • Best practices and case studies

Quick Access: 04-security/SKILL.md

Recommended for: DevOps engineers, security engineers, system administrators


05. Integration and Extension SKILL

Use Cases: Integrate with external systems and services

Trigger Keywords: integration, API, Webhook, MCP, Server, Client, database, Redis, message queue, RabbitMQ, Kafka, S3

Core Content:

  • API integration (REST API, Webhook, Streaming)
  • MCP protocol (MCP Server, MCP Client, bidirectional communication)
  • External services (databases, storage, message queues)
  • Integration case studies and best practices
  • Troubleshooting and debugging

Quick Access: 05-integration/SKILL.md

Recommended for: Integration engineers, full-stack developers, architects


06. Reference SKILL

Use Cases: Look up syntax, API, CLI, and other reference information

Trigger Keywords: reference, API, SDK, CLI, DSL, YAML, command, documentation, syntax

Core Content:

  • DSL syntax reference (complete YAML structure and field descriptions)
  • API reference (RESTful API interface documentation)
  • SDK reference (Python SDK classes and methods)
  • CLI reference (dify command line tool)
  • Common questions and solutions
  • Learning resources and community links

Quick Access: 06-reference/SKILL.md

Recommended for: All Dify developers


Common References

Variable Reference Syntax

# System variables
{{#sys.query#}}              # User query
{{#sys.files#}}              # Uploaded files
{{#sys.conversation_id#}}    # Conversation ID

# Node output
{{#nodeID.outputField#}}     # Reference node output
{{#llm.text#}}               # LLM text output
{{#knowledge.result#}}       # Knowledge retrieval result

# Conversation variables
{{#conversation.variableName#}}  # Conversation-level variable

# Iteration variables
{{#item#}}                   # Current iteration item
{{#index#}}                  # Current index

Common Node Configurations

# LLM node
- data:
    type: llm
    model:
      provider: openai
      name: gpt-4
      completion_params:
        temperature: 0.7
        max_tokens: 2000
    prompt_template:
    - role: system
      text: "System prompt"
    - role: user
      text: "{{#sys.query#}}"
    context:
      enabled: true
      variable_selector: ["knowledge", "result"]

# Agent node
- data:
    type: agent
    agent_parameters:
      instruction:
        value: "Call tools based on user requirements"
      model:
        value:
          provider: openai
          model: gpt-4
      query:
        value: "{{#sys.query#}}"
      tools:
        value:
        - enabled: true
          provider_name: time
          tool_name: current_time
          type: builtin
    agent_strategy_name: function_calling

# Knowledge retrieval node
- data:
    type: knowledge-retrieval
    dataset_ids: ["dataset-id"]
    query_variable_selector: ["start", "sys.query"]
    retrieval_mode: single
    single_retrieval_config:
      model:
        provider: openai
        name: text-embedding-3-small
      top_k: 3
      score_threshold: 0.7

Plugin Configuration Template

# manifest.yaml
version: 0.0.1
type: plugin
author: your-name
name: plugin-name
label:
  en_US: Plugin Name
  zh_Hans: Plugin Name
description:
  en_US: Plugin description
  zh_Hans: Plugin description
icon: icon.svg

resource:
  memory: 268435456  # 256MB

plugins:
  tools:
    - provider/provider.yaml

meta:
  version: 0.0.1
  arch: [amd64, arm64]
  runner:
    language: python
    version: "3.12"
    entrypoint: main

tags:
  - utilities

Common CLI Commands

# Plugin development
dify plugin init                    # Initialize a plugin project
dify plugin run                     # Debug plugin locally
dify plugin package                 # Package plugin
dify plugin publish                 # Publish plugin

# Workflow management
dify workflow export <id>           # Export a workflow
dify workflow import <file>         # Import a workflow
dify workflow validate <file>       # Validate a workflow

# Environment management
dify env list                       # List environment variables
dify env set <key> <value>          # Set environment variable
dify env get <key>                  # Get environment variable

Learning Path

Beginner Path (0-1 Week)

  1. Read this SKILL to understand the Dify landscape
  2. Learn 01-workflow SKILL to master workflow fundamentals
  3. Create your first workflow using a template
  4. Test and debug on the Dify platform

Intermediate Path (1-4 Weeks)

  1. Deep-dive into 01-workflow SKILL design patterns
  2. Learn 02-plugin SKILL to develop custom plugins
  3. Learn 03-performance SKILL to optimize performance
  4. Build and deploy a real project

Expert Path (1-3 Months)

  1. Master all sub-skill content
  2. Learn 04-security SKILL for production deployment
  3. Learn 05-integration SKILL to integrate external systems
  4. Contribute to the community and share best practices

Getting Help

Official Resources

Community Resources

SKILL Support

  • Architecture Document: ARCHITECTURE.md
  • Issue Feedback: Submit via GitHub Issues
  • Contribution Guide: Help improve and extend SKILL content

Version Information

  • Current Version: v1.1.0
  • Last Updated: 2026-03-05
  • Compatible Dify Versions: 0.15.x - 1.9.x
  • Update Content: Completed 05-integration and 06-reference SKILLs, added on-demand loading mechanism
  • Next Version Plan: v1.2.0 (add more templates and case studies)

License

This SKILL is open-sourced under the MIT License. You are free to use, modify, and distribute it.


Start your Dify development journey! Choose a sub-SKILL to dive deeper, or jump directly into templates to get started quickly.

Individual skills in this repo

This repo contains 6 individual skills — each has its own dedicated page.

Related Skills