Dify Documentation

Dify provides a workspace to orchestrate, publish, and monitor AI applications. The core capabilities include:

• Orchestrate: Build complex AI logic using workflows, chatflows, agents, and chatbots on a visual canvas.
• Knowledge: Ground your applications in specific data by importing documents for retrieval and citation.
• Publish: Deploy applications as standalone web apps, embed them into existing websites, or integrate them into your own software via API.
• Monitor: Track application usage, review execution logs, and improve model performance using annotations.
• Integrations: Extend functionality by connecting model providers, tools, data sources, and external services.

The tools/translate/ directory contains utilities to maintain documentation quality and synchronization across English, Chinese, and Japanese:

• Localization Rules: formatting-zh.md (Chinese) and formatting-ja.md (Japanese) define formatting standards.
• Terminology Management:
  • termbase_i18n.md: The core terminology database (en/zh/ja).
  • derive-termbase.py: Script to regenerate the termbase from the glossary. Use the --check flag to verify synchronization.
  • check-glossary-keys.py: Validates that i18n keys cited in the glossary exist in the Dify web UI strings.
• JSON & OpenAPI Utilities:
  • json_formatter.py: A format-preserving JSON writer used when editing docs.json to ensure clean git diffs.
  • openapi/: Utilities for translating OpenAPI specs by extracting translatable fields to markdown and rehydrating them back into JSON.

Dify is a workspace for orchestrating, publishing, and monitoring AI applications. The platform provides several core functional areas:

• Orchestrate: Build AI applications using a visual canvas to create workflows, chatflows, agents, and chatbots.
• Knowledge: Ground your applications in your own data by importing documents for retrieval and citation.
• Publish: Deploy applications as standalone web apps, embed them into existing websites, or interact with them via API.
• Monitor: Track application usage, review execution logs, and refine AI responses using annotations.
• Integrations: Connect to various model providers, tools, data sources, and external services.

The Dify CLI (difyctl) allows you to execute Dify applications from outside the browser, such as from a terminal, shell scripts, CI/CD pipelines, or AI agents. It bridges the gap between the browser-based application builder and programmatic environments.

Key Capabilities:

• Execute Apps: Run any Dify application from the terminal and capture its output.
• App Discovery: List applications within your workspace and inspect their required input parameters.
• Flexible Output: Choose between real-time streaming for long responses or structured JSON for script processing.
• Secure Automation: Use OAuth to sign in once, enabling subsequent automated runs without storing passwords or API keys in scripts.
• AI Agent Integration: Enables AI agents to detect and invoke Dify applications as tools.

Dify Tools allow LLMs to interact with external services and APIs (e.g., web searches, database queries, or content processing).

Where to use tools:

• Workflow / Chatflow apps: As standalone Tool nodes or within Agent nodes.
• Agent apps: During the app building process.
• Legacy Agent apps: By extending the agent with Dify tools.

Management: All tools are managed via the Integrations > Tools menu in the Dify workspace.

The Dify built-in analytics dashboard allows you to monitor application performance, costs, and user engagement by tracking four key metrics over time:

• Total Messages: Measures the overall conversation volume.
• Active Users: Tracks users who have had meaningful interactions (defined as more than one exchange).
• Average User Interactions: Measures the engagement depth per session.
• Token Usage: Monitors resource consumption and associated costs.

You can use the time selector within the dashboard to view trends across different time periods.

Dify provides four primary ways to deploy your applications depending on your use case:

• Web Apps: Instant, shareable links. Best for testing ideas or serving end users directly without building a custom interface.
• API Integration: Provides full control over the user experience and data flow. Best for building AI capabilities directly into your own existing products.
• Embed on Websites: Allows you to deploy your web app as a chat widget or an inline frame on any website, regardless of the website's technology stack.
• MCP Server: Connects your application to AI tools like Claude Desktop and Cursor, making your app available as a native tool within development workflows.

Introduced in Dify v1.10.0, a Trigger Plugin is a specialized plugin type that acts as a bridge between third-party platforms and Dify workflows.

Unlike functional nodes (Code, Tool, Knowledge Retrieval) that process data within a workflow, a Trigger Plugin converts third-party webhook events into a Dify-compatible input format. This allows external events (e.g., a new email in Gmail or a new issue in GitHub) to automatically start a Dify workflow by parsing the platform's unique event payload into a unified schema that Dify recognizes.

A knowledge pipeline is a document processing workflow designed to transform raw data into searchable knowledge bases. It functions as an orchestration of different processing nodes and tools to optimize data for accuracy and relevance.

A standard knowledge pipeline follows a four-step structured flow:

1. Data Sources: Gathering content from various origins.
2. Data Extraction: Converting raw data into processable text.
3. Data Processing: Refining the text to optimize it for search.
4. Knowledge Storage: Storing the processed data in a format that enables fast and accurate retrieval.

You can use Dify's built-in pipeline templates for specific use cases or build a custom pipeline from scratch by visually combining and configuring different nodes.