Dify — 低代码 AI Agent 应用平台

GitHub: langgenius/dify
Stars: 145,000+ | Language: TypeScript (52.2%), Python (43.6%) | License: Dify Open Source License (基于 Apache 2.0)
官网: dify.ai

项目速览

Dify（取”Do It For You”之意）是 LangGenius 团队打造的开源 LLM 应用开发平台，定位为 “Production-ready platform for agentic workflow development”。截至 2026 年 6 月，项目在 GitHub 上已获得超过 145,000 颗 Star，是 AI 应用平台领域增长最快的项目之一。

Dify 的核心理念是”让 AI 应用开发民主化”：通过可视化工作流构建器、内置 RAG 引擎和 Agent 系统，将 LLM 应用的开发门槛从专业开发者降低到业务人员和领域专家。它将 AI 工作流（Workflow）、RAG 管道（Pipeline）、Agent 能力、模型管理和可观测性整合到一个统一界面中。

2025 年，Dify 发布了 v1.0 版本，引入了插件生态系统（Plugin Marketplace）和 Agent 策略节点（ReAct、Function Calling、Chain-of-Thought 等）。v1.9.0 进一步升级为基于队列的图引擎（Queue-Based Graph Engine），支持工作流暂停/恢复/终止和流式响应协调。Dify 提供云服务（SaaS）、社区版（自托管 Docker）和企业版三种部署方式，兼具开发者友好的 API-First 架构和业务用户友好的可视化界面。

功能概述

可视化工作流构建器

Dify 的 Web UI 基于 React Flow（xyflow）实现拖拽式画布，用户通过连接节点构建 AI 应用逻辑。支持的节点类型包括：

LLM 节点：调用大语言模型（支持 100+ 模型提供商）
知识检索节点：从向量知识库检索相关文档
代码节点：在安全沙箱中执行 Python/JavaScript 代码
HTTP 请求节点：调用外部 API
条件分支节点：基于条件判断进行流程分支
变量聚合节点：合并多个上游节点的输出
Agent 节点：智能决策中心，支持 ReAct / Function Calling 等策略

构建完成后，前端将画布序列化为 JSON，后端解析并构建 DAG（有向无环图），通过拓扑排序确定执行顺序。

插件生态系统（Plugin Marketplace）

Dify v1.0 将模型、工具和扩展从核心平台中解耦为可热插拔的插件，提供 120+ 官方和社区插件：

模型提供商插件：OpenAI、Anthropic、Google Gemini、DeepSeek、Llama 等
工具插件：Perplexity 搜索、Slack、Firecrawl、邮件、日历等
Agent 策略插件：ReAct、Function Calling、Chain-of-Thought、Tree-of-Thoughts
扩展插件：自定义节点类型、数据处理逻辑等

插件由独立的 dify-plugin-daemon 运行时管理，支持热插拔，无需重启平台。

RAG 知识库引擎

Dify 内置完整的 RAG 管道，可视化配置每一步：

文档摄取：支持 PDF、Word、Excel、网页、Notion 等格式批量上传
文档解析：自动分段清洗，支持 Q&A 分段模式（v1.9.0 新增）
向量嵌入：对接 OpenAI、Cohere、本地模型等嵌入提供商
混合检索：向量检索（ANN）+ 关键词检索（BM25），加权融合
重排序（Rerank）：Cross-Encoder 模型将 Top-20 候选压缩为 Top-5
上下文压缩：抽取式句子级压缩，控制在 2-3k token 预算内
引用标注：每个 answer 块绑定源文档元数据，内联引用可追溯

Agent 策略系统

Dify 的 Agent 节点支持两种主要推理策略：

Function Calling：一次性规划多个函数参数，并行执行，适合高效、确定性的多工具任务
ReAct（Reasoning + Acting）：Think-Act-Observe 循环，适合需要迭代探索的复杂推理任务

Agent 节点可以嵌入工作流或对话流（Chatflow）中的任意位置，作为智能决策中心动态调用工具、切换策略和控制流程。

LLMOps 可观测性

Dify 提供生产级的监控和日志能力：

实时日志：每次 LLM 调用的输入/输出、Token 消耗、延迟
标注与改进：对模型输出进行人工评分和标注，持续优化
A/B 测试：在 Prompt IDE 中同时对比多个提示词变体的效果
Langfuse / LangSmith 集成：对接外部追踪和评估平台
成本追踪：按应用、按模型的 Token 消耗和费用统计

适用场景

智能客服系统

Dify 最适合快速搭建企业级智能客服。通过知识库上传产品文档和 FAQ，配置 RAG 检索，使用 Chatflow 设计对话流程，加入条件分支实现意图识别和转人工逻辑。可视化界面让客服主管而非工程师即可迭代优化问答质量。

企业知识管理

将公司内部文档（制度、流程、技术文档等）上传到 Dify 知识库，构建内部知识助手。支持多知识库管理、权限控制和元数据过滤，确保不同部门的员工只能检索到授权范围内的文档。

数据分析与报告自动化

Dify 的代码节点支持在安全沙箱中执行 Python 代码，可以连接数据库查询数据，使用 Pandas 进行分析，生成图表和报告。LLM 节点将分析结果转化为自然语言解读，形成端到端的数据分析应用。

API 后端服务

Dify 的 API-First 架构意味着所有可视化构建的应用都会自动暴露为 REST API 端点。其他系统可以通过 API 调用这些 AI 应用，实现将 AI 能力嵌入现有业务流程。

内容生成流水线

通过工作流串联多步内容生成：选题研究（Web 搜索工具）→ 大纲生成（LLM 节点）→ 正文撰写（LLM 节点+知识库参考）→ SEO 优化（条件分支）→ 格式排版（代码节点）。整个过程可视化编排，非技术团队也能管理。

快速上手

环境要求

Docker 和 Docker Compose
至少 4GB 可用内存

Docker Compose 部署（最快方式）

# 克隆仓库
git clone https://github.com/langgenius/dify.git
cd dify/docker

# 复制环境配置
cp .env.example .env

# 启动所有服务（Web + API + 数据库 + Redis + 向量存储）
docker compose up -d

# 访问 http://localhost:3000 初始化管理员账号

服务启动后，Docker 会运行以下核心容器：

服务	端口	说明
Web Frontend	3000	React 前端界面
API Server	5001	FastAPI 后端服务
Plugin Daemon	5003	插件管理运行时
PostgreSQL	5432	主数据库
Redis	6379	缓存和队列
Weaviate	8080	默认向量数据库

快速构建第一个应用

配置模型提供商：登录后进入”设置 → 模型供应商”，填入 OpenAI（或其他）API Key
创建知识库：上传一份测试文档（PDF/TXT），系统自动分片和向量化
创建应用：选择”聊天助手”模板，关联刚创建的知识库
发布测试：点击”发布”，在预览界面测试问答效果
API 调用：发布后自动生成 API 端点，可复制 cURL 命令供外部系统调用

源码架构

Dify 采用前后端分离的微服务架构：

dify/
├── api/                           # 后端 API 服务（Python/FastAPI）
│   ├── core/                      #   核心业务逻辑
│   │   ├── workflow/              #     DAG 工作流引擎
│   │   ├── agent/                 #     Agent 策略执行
│   │   ├── rag/                   #     RAG 管道（检索、重排序）
│   │   └── model_manager/         #     模型管理抽象层
│   ├── controllers/               #   API 路由控制器
│   ├── services/                  #   业务服务层
│   ├── models/                    #   数据模型（SQLAlchemy ORM）
│   └── tasks/                     #   异步任务（Celery）
├── web/                           # 前端 Web 应用（React/TypeScript）
│   ├── app/components/            #   可视化画布组件
│   │   └── workflow/              #     React Flow 工作流节点
│   ├── app/components/chat/       #     对话界面组件
│   └── service/                   #     API 调用层
├── cli/                           # 命令行工具
├── dify-agent/                    # Agent 独立模块
├── sdks/                          # 多语言 SDK
├── docker/                        # Docker 部署配置
│   ├── docker-compose.yaml        #   一键部署编排
│   └── .env.example               #   环境变量模板
├── packages/                      # 共享包
├── docs/                          # 文档站点
└── e2e/                           # 端到端测试

**api/core/workflow/**：Dify 的心脏——基于队列的图执行引擎。负责解析前端 JSON、构建 DAG、拓扑排序、节点分发、流式响应协调和错误处理（指数退避重试、错误分支、补偿回滚）。
**api/core/rag/**：RAG 管道实现，涵盖文档摄取、分块清洗、向量嵌入、混合检索、重排序和上下文压缩的完整流程。
**api/core/agent/**：Agent 策略实现，支持 ReAct、Function Calling、CoT、ToT 等多种推理模式。
**web/app/components/workflow/**：基于 React Flow 的可视化画布，支持拖拽节点、连线、配置参数，最终序列化为工作流 JSON。
dify-plugin-daemon：独立的插件运行时进程，管理模型、工具、策略等插件的生命周期，支持本地和 serverless 两种运行时模式。

实操 Demo

下面展示如何利用 Dify API 创建知识库、上传文档并实现智能问答。

"""
Dify 知识库问答系统 Demo
使用 Dify API 创建知识库、上传文档、构建 Chat 应用
"""

import os
import requests
import json
import time

# ===================== 配置 =====================
DIFY_BASE_URL = "http://localhost:5001"  # 自托管 Dify API 地址
# 在 Dify 管理后台「设置 → API 访问」中创建 Access Token
API_TOKEN = "your-dify-api-token"  # 替换为你的 API Access Token

headers = {
    "Authorization": f"Bearer {API_TOKEN}",
    "Content-Type": "application/json",
}


def upload_document(file_path: str, dataset_id: str) -> dict:
    """上传文档到 Dify 知识库"""
    url = f"{DIFY_BASE_URL}/v1/datasets/{dataset_id}/document/create-by-file"

    with open(file_path, "rb") as f:
        files = {"file": (os.path.basename(file_path), f, "text/plain")}
        data = {
            "indexing_technique": "high_quality",
            "process_rule": {"mode": "automatic"},
        }
        response = requests.post(
            url,
            headers={"Authorization": f"Bearer {API_TOKEN}"},
            files=files,
            data=data,
        )
    response.raise_for_status()
    result = response.json()
    print(f"文档已上传: {result.get('document', {}).get('name')}")
    return result


def create_knowledge_base(name: str) -> dict:
    """通过 Dify 知识库 API 创建知识库"""
    url = f"{DIFY_BASE_URL}/console/api/datasets"

    payload = {
        "name": name,
        "description": f"{name} 的知识库",
        "indexing_technique": "high_quality",  # 高质量索引
        "permission": "only_me",
    }

    response = requests.post(url, headers=headers, json=payload)
    if response.status_code == 201:
        dataset = response.json()
        print(f"知识库创建成功！ID: {dataset['id']}")
        return dataset["id"]
    else:
        print(f"创建失败: {response.status_code} {response.text}")
        return None


def query_knowledge_base(question: str, dataset_id: str) -> dict:
    """通过 Dify 知识库 API 查询"""
    url = f"{DIFY_BASE_URL}/v1/datasets/{dataset_id}/retrieve"

    payload = {
        "query": question,
        "retrieval_model": {
            "search_method": "hybrid_search",  # 混合检索
            "reranking_enable": True,          # 启用重排序
            "reranking_model": {
                "reranking_provider_name": "cohere",
                "reranking_model_name": "rerank-multilingual-v2.0",
            },
            "top_k": 5,
            "score_threshold_enabled": True,
            "score_threshold": 0.5,
        },
    }

    response = requests.post(url, headers=headers, json=payload)
    return response.json()


def chat_with_app(message: str, conversation_id: str = "") -> dict:
    """与 Dify Chat 应用对话"""
    url = f"{DIFY_BASE_URL}/v1/chat-messages"

    payload = {
        "inputs": {},
        "query": message,
        "response_mode": "streaming",  # 流式响应
        "conversation_id": conversation_id,
        "user": "demo-user-001",
    }

    response = requests.post(url, headers=headers, json=payload)
    return response.json()


# ===================== 批量上传文档到知识库 =====================
def upload_documents_to_dataset(dataset_id: str, file_paths: list) -> list:
    """批量上传文档，返回已上传的文档 ID 列表"""
    url = f"{DIFY_BASE_URL}/v1/datasets/{dataset_id}/document/create-by-file"
    uploaded_docs = []

    for file_path in file_paths:
        with open(file_path, "rb") as f:
            files = {"file": (file_path.split("/")[-1], f, "application/octet-stream")}
            data = {
                "indexing_technique": "high_quality",
                "process_rule": json.dumps({
                    "mode": "automatic",  # 自动分片
                    "rules": {
                        "pre_processing_rules": [
                            {"id": "remove_extra_spaces", "enabled": True},
                            {"id": "remove_urls_emails", "enabled": False},
                        ],
                        "segmentation": {
                            "separator": "\n",
                            "max_tokens": 500,
                        },
                    },
                }),
            }

            auth_headers = {"Authorization": f"Bearer {API_TOKEN}"}
            response = requests.post(
                url, headers=auth_headers, files=files, data=data
            )

            if response.status_code in [200, 201]:
                result = response.json()
                doc_id = result["document"]["id"]
                print(f"  [OK] {file_path} -> document_id: {doc_id}")
                uploaded_docs.append(doc_id)

                # 等待文档处理完成
                wait_for_indexing(dataset_id, doc_id)
            else:
                print(f"  [FAIL] {file_path}: {response.status_code} {response.text}")

    return uploaded_docs


def wait_for_indexing(dataset_id: str, document_id: str, max_wait: int = 60):
    """等待文档向量化完成"""
    url = f"{DIFY_BASE_URL}/v1/datasets/{dataset_id}/documents/{document_id}/indexing-status"

    for _ in range(max_wait):
        response = requests.get(url, headers={
            "Authorization": f"Bearer {API_TOKEN}"
        })
        if response.status_code == 200:
            status = response.json().get("data", {}).get("indexing_status", "")
            if status == "completed":
                print(f"    [索引完成] document_id: {document_id}")
                return
            elif status == "error":
                print(f"    [索引失败] document_id: {document_id}")
                return
        time.sleep(1)

    print(f"    [超时] document_id: {document_id}，索引仍在处理中")


# ===================== 完整流程演示 =====================

if __name__ == "__main__":
    print("=" * 60)
    print("  Dify 知识库问答系统 Demo")
    print("=" * 60)

    # 1. 创建知识库
    print("\n[1] 创建知识库...")
    dataset_id = create_knowledge_base("产品文档知识库")
    # 假设返回: dataset_id = "abc123"

    # 2. 上传文档
    print("\n[2] 上传文档...")
    sample_files = [
        "./docs/product_manual.txt",
        "./docs/api_reference.md",
        "./docs/faq.pdf",
    ]
    # 创建知识库并上传文档（需填写实际 API 凭证）
    if API_TOKEN != "your-dify-api-token":
        doc_results = upload_documents_to_dataset(dataset_id, sample_files)
        print(f"  已上传 {len(doc_results)} 个文档")

    # 3. 显示 Chat API 调用示例
    print("\n[3] Chat API 调用示例:")
    print("""
curl -X POST '{DIFY_URL}/v1/chat-messages' \\
  -H 'Authorization: Bearer {API_KEY}' \\
  -H 'Content-Type: application/json' \\
  -d '{
    "inputs": {},
    "query": "如何配置 API 认证？",
    "response_mode": "blocking",
    "conversation_id": "",
    "user": "demo-user"
  }'
""")

    # 4. 展示知识库检索 API
    print("[4] 知识库检索 API 示例:")
    print("""
curl -X POST '{DIFY_URL}/v1/datasets/{dataset_id}/retrieve' \\
  -H 'Authorization: Bearer {API_KEY}' \\
  -H 'Content-Type: application/json' \\
  -d '{
    "query": "认证配置方法",
    "retrieval_model": {
      "search_method": "hybrid_search",
      "reranking_enable": true,
      "top_k": 3
    }
  }'
""")

    print("=" * 60)
    print("  Demo 完成！核心展示：")
    print("  1. Dify 知识库创建与管理 API")
    print("  2. 文档批量上传与自动向量化")
    print("  3. 混合检索 + 重排序的知识库查询")
    print("  4. Chat API 实现端到端问答")
    print("=" * 60)

运行前提：

# 1. 启动 Dify
cd dify/docker && docker compose up -d

# 2. 在 Web 界面 (http://localhost:3000) 创建应用
# 3. 在「API 访问」中创建 Access Token
# 4. 替换脚本中的 DIFY_BASE_URL 和 API_TOKEN

# 5. 运行脚本
pip install requests
python dify_demo.py

特性	Dify	LangChain	Open WebUI
定位	低代码 AI 应用平台	通用 Agent 工程框架	LLM 交互 Web 界面
Stars	145,000+	139,000+	42,000+
可视化	拖拽式工作流画布 + Prompt IDE + 知识库管理	无内置可视化（依赖 LangSmith / LangGraph Studio）	提供聊天界面和基础模型管理
RAG 能力	内置完整 RAG 管道，可视化配置，混合检索+重排序	通过链组合实现，灵活但需要编码	基础 RAG 支持，文档上传和检索
Agent 模式	Agent 节点 + 策略插件（ReAct/FC/CoT）	create_agent + LangGraph + Middleware	基础工具调用，不支持复杂 Agent
部署方式	Docker 一键部署、云服务、企业版	Python 库，需自行搭建服务	Docker 部署
适合用户	非技术人员和全栈团队均可	以开发者为中心	想要开箱即用界面的个人/小团队

参考资源

官方文档: https://docs.dify.ai/
GitHub 仓库: https://github.com/langgenius/dify
Dify Cloud: https://cloud.dify.ai/
插件市场: https://marketplace.dify.ai/
v1.0 发布博客: https://dify.ai/blog/dify-v1-0-building-a-vibrant-plugin-ecosystem
Discord 社区: https://discord.gg/dify

目录