Dify Plugin Daemon

The cache system manages namespaces using a prefix system:

• Default Prefix: plugin_daemon.
• Override: Use the REDIS_KEY_PREFIX environment variable to change the prefix.
• Scope: The prefix applies to both standard keys and Pub/Sub channels.
• Namespace Switching: Changing the prefix switches the active namespace; it does not migrate existing data to the new prefix.
• Cluster Hash Tags: Logical keys containing Redis Cluster hash tags (e.g., {remote:key:manager}) will keep those tags intact because the prefix is prepended to the full logical key.

The Stream[T] type provides a thread-safe, generic, and buffered communication channel between goroutines, specifically designed for asynchronous producer-consumer patterns. It implements backpressure control using a configurable buffer size, which determines the maximum number of items that can be held before producers are blocked or encounter errors. It is built using a deque for efficient FIFO operations and uses mutexes, atomic operations, and condition variables to ensure thread safety and manage blocking states.

// Create with buffer size (max items before blocking)
s := stream.NewStream[T](128)
defer s.Close()

The Dify Plugin Daemon manages three distinct runtime types to execute plugins, forwarding HTTP requests from the Dify API server based on the selected runtime:

1. Local runtime: Runs on the same machine as the Dify server. The daemon starts the plugin as a subprocess and communicates via STDIN/STDOUT.
2. Debug runtime: Used for local development. The daemon waits for a plugin to connect via a TCP-based, full-duplex connection.
3. Serverless runtime: Runs on platforms like AWS Lambda. The plugin is packaged as a third-party service and invoked by the daemon via HTTP.

For detailed information on the Serverless Runtime Interface, refer to the SRI Docs.

To prevent failures due to platform payload limits (e.g., the 6 MB limit on AWS Lambda Function URLs), the daemon implements automatic batching for requests like text embedding and token counting that exceed MAX_SERVERLESS_REQUEST_BYTES.

• Transparent Processing: The daemon automatically splits large requests into batches and merges the results; plugin developers do not need to handle this.
• Sequential Execution: Batches are processed in order to ensure consistent results.
• Error Handling: If a single item within a request is itself larger than the limit, the daemon returns a ServerlessPayloadTooLargeError.

Dify plugins extend three main capabilities. Depending on your goal, you will implement one of the following types:

• Tool: Performs specific tasks (e.g., Google Search, Stable Diffusion). Can be a tool provider with optional endpoints.
• Model: Provides AI model integrations (e.g., OpenAI, Anthropic). These are model providers only.
• Endpoint: Provides HTTP services (e.g., Custom APIs, integrations). Also referred to as an Extension.

Important Restrictions:

• You cannot extend both tools and models in the same plugin.
• You cannot extend both models and endpoints in the same plugin.
• A plugin must have at least one extension.
• You are limited to one supplier per extension type.

To prevent exceeding platform-specific payload limits (such as the 6 MB limit for AWS Lambda Function URLs), the Dify Plugin Daemon implements automatic batching for large requests.

Key Behaviors:

• Transparent batching: The daemon automatically splits and merges text embedding and token counting requests. Plugin developers do not need to implement custom logic for this.
• Serial processing: Batches are processed one after another to ensure consistent results.
• Automatic merging: Results from all batches are merged into a single response for the user.
• Error handling: If a single text item is so large that it exceeds MAX_SERVERLESS_REQUEST_BYTES even when alone, the request will fail with a ServerlessPayloadTooLargeError.

When setting up the http.Client for use with the http_requests utilities, it is recommended to configure a custom Transport with specific Dial timeouts and IdleConnTimeout to manage connection lifecycles effectively.

client := &http.Client{
    Transport: &http.Transport{
        Dial: (&net.Dialer{
            Timeout:   5 * time.Second,
            KeepAlive: 120 * time.Second,
        }).Dial,
        IdleConnTimeout: 120 * time.Second,
    },
}

To develop Dify plugins using Python, ensure you meet the following requirements:

• Python Version: 3.11 or higher.
• Dependency Management: It is recommended to use uv. If using pip, ensure you maintain both pyproject.toml and requirements.txt and keep them in sync.

To install dependencies using uv:

uv sync

Or using pip:

pip install -r requirements.txt

The Dify Plugin Daemon connects to remote serverless environments (like AWS Lambda) using the Serverless Runtime Interface (SRI). This connection is configured via the following environment variables:

Note: The SRI is currently in Alpha. Stability and backward compatibility are not guaranteed.