Dify 完全使用指南：零代码搭建企业级 AI 应用，比自研快 10 倍（2026版）

摘要：Dify 是目前最成熟的开源 AI 应用开发平台，支持可视化 RAG、工作流编排、多模型管理，私有化部署后数据完全自主。本文覆盖 Docker 部署、DeepSeek V4 接入、知识库问答搭建、多步骤工作流设计，以及 API 集成到 Java/Python 系统的完整方案。关键词：Dify教程、Dify部署、Dify接入DeepSeek、Dify知识库、Dify工作流、低代码AI、AI应用开发平台。

一、Dify 是什么？与 LangChain 自研的适用场景对比

1.1 核心定位

Dify 不是编程框架，而是AI 应用的可视化操作系统：

LangChain 自研：
  代码量大 → 开发周期长 → 灵活度高 → 适合复杂定制

Dify：
  可视化拖拽 → 小时级交付 → 功能固定 → 适合标准场景

两者不对立，Dify 内置的 API 可以调用 LangChain 写的自定义工具

1.2 Dify 最擅长的五类场景

二、Docker 私有化部署

2.1 最低配置要求

2.2 一键部署（Docker Compose）

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

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

# 关键配置修改（.env 文件）
# 修改以下几项：
vim .env

# .env 关键配置项
SECRET_KEY=your-random-secret-key-change-this   # 必改，用于加密
INIT_PASSWORD=YourAdminPassword123               # 管理员初始密码

# 数据库配置（使用内置 PostgreSQL 则无需改）
DB_PASSWORD=your-db-password

# Redis 配置（使用内置 Redis 则无需改）
REDIS_PASSWORD=your-redis-password

# 启动所有服务（首次拉取约 5-10 分钟）
docker compose up -d

# 查看启动状态
docker compose ps

# 正常状态应该看到以下服务都是 running：
# dify-api-1         running
# dify-worker-1      running
# dify-web-1         running
# dify-db-1          running
# dify-redis-1       running
# dify-nginx-1       running
# dify-weaviate-1    running（向量数据库）

# 访问地址
echo "管理后台：http://your-server-ip"
echo "API 地址：http://your-server-ip/v1"

2.3 数据持久化（重要！）

# 所有数据默认存储在 Docker volumes
# 升级前务必备份

# 备份数据库
docker compose exec db pg_dump -U postgres dify > backup_$(date +%Y%m%d).sql

# 备份向量数据库
docker compose exec weaviate tar -czf /tmp/weaviate_backup.tar.gz /var/lib/weaviate
docker compose cp weaviate:/tmp/weaviate_backup.tar.gz ./

2.4 版本升级

cd dify/docker
git pull
docker compose pull   # 拉取最新镜像
docker compose up -d  # 重启服务（数据不丢失）

三、接入 DeepSeek V4 / 本地 Ollama 模型

3.1 添加 DeepSeek V4

管理员登录 → 设置 → 模型供应商 → 点击"OpenAI 兼容"

配置项：
  供应商名称：DeepSeek
  API Base URL：https://api.deepseek.com/v1
  API Key：sk-your-deepseek-key

添加模型：
  模型名称：deepseek-v4-flash
  模型类型：聊天
  上下文长度：131072

  模型名称：deepseek-v4-pro
  模型类型：聊天
  上下文长度：131072

3.2 接入本地 Ollama

管理员登录 → 设置 → 模型供应商 → Ollama

配置项：
  Ollama 服务地址：http://host.docker.internal:11434

  （注意：在 Docker 内访问宿主机要用 host.docker.internal，不是 localhost）

添加模型：
  Ollama 模型名：qwen3:7b
  类型：聊天
  上下文长度：32768

3.3 配置 Embedding 模型

设置 → 模型供应商 → 添加 Embedding

推荐配置（免费本地方案）：
  供应商：Ollama
  模型：nomic-embed-text 或 bge-m3
  （先在 Ollama 拉取：ollama pull bge-m3）

备选（API 方案）：
  供应商：OpenAI 兼容
  模型：text-embedding-3-small

四、实战一：可视化搭建企业知识库问答

4.1 创建知识库（Knowledge Base）

左侧菜单 → 知识库 → 创建知识库

Step 1：基础设置
  知识库名称：产品文档知识库
  描述：公司产品手册、FAQ、操作指南

Step 2：上传文档
  支持格式：PDF、Word、TXT、Markdown、HTML、CSV
  批量上传：直接拖拽多个文件

Step 3：分段设置
  分段方式：自动（推荐）/ 自定义
  分段长度：500 tokens（默认，适合大多数场景）
  分段重叠：50 tokens
  
Step 4：选择 Embedding 模型
  选择之前配置的 bge-m3 或 text-embedding-3-small

Step 5：点击"保存并处理"
  系统自动：分段 → 向量化 → 存入向量库

4.2 创建知识库问答应用

应用 → 创建应用 → 聊天助手

设置 → 上下文 → 添加知识库 → 选择"产品文档知识库"

Prompt 设置：
  角色：你是一个专业的产品支持助手
  任务：基于提供的产品文档回答用户问题
  约束：
    - 只回答文档中包含的内容
    - 如果文档中没有相关信息，明确说明"暂无相关资料"
    - 不要猜测或编造信息
    - 引用时注明来源文档名称

高级设置：
  引用与归因：开启（用户可查看答案来源）
  引用数量：5（检索 Top-5 相关段落）
  相似度阈值：0.7

4.3 知识库质量优化技巧

【优化检索质量】

1. 测试一批问题，查看"引用"标签
   → 如果引用的文档段落不相关，调低相似度阈值或换 Embedding 模型

2. 设置问题优化（Query Rewriting）
   → 开启后，用户的模糊问题会被 AI 改写为更精确的检索语句
   → 适合口语化提问场景

3. 多路召回
   → 同时开启向量检索 + 全文检索（BM25）
   → 对专有名词、型号编码效果显著提升

4. 父子分段（Parent-Child Chunking）
   → 子段用于精确检索，父段提供完整上下文
   → 适合长文档

五、实战二：多步骤 AI 工作流（Chatflow vs Workflow）

5.1 两种工作流的区别

5.2 工作流实战：简历筛选自动化

Workflow 节点设计：

[开始] → 接收输入：
  - 岗位要求（文本）
  - 简历内容（文本）

[LLM节点1：技能提取] →
  Prompt：从简历中提取候选人的技能列表、工作年限、教育背景
  模型：deepseek-v4-flash（便宜快速）

[LLM节点2：匹配评分] →
  Prompt：对比岗位要求和候选人信息，给出匹配评分（1-10）和理由
  输入：来自节点1的提取结果 + 岗位要求
  模型：deepseek-v4-flash

[条件节点：评分判断] →
  条件1：评分 >= 8 → 推荐面试
  条件2：评分 5-7 → 需人工复核
  条件3：评分 < 5 → 婉拒

[LLM节点3：生成邮件] →
  根据不同条件生成对应的回复邮件

[结束] → 输出：评分、推荐状态、回复邮件

实际操作（可视化拖拽，无需写代码）：

1. 点击 "+" 添加节点 → 选择"LLM"
2. 填写节点名称、选择模型、编写 Prompt
3. 在 Prompt 中用 {{变量名}} 引用上游节点输出
4. 添加条件节点，设置判断规则（可视化配置）
5. 连接各节点的箭头
6. 点击"运行"测试

六、API 发布与集成到 Java / Python 系统

6.1 发布为 API

应用详情 → API 访问 → 查看 API Key 和接口文档

Base URL：http://your-dify-server/v1
认证方式：Bearer Token（API Key）

6.2 Java 集成示例

// DifyClient.java
@Service
public class DifyClient {

    private static final String DIFY_BASE_URL = "https://your-dify-server/v1";
    private static final String API_KEY = System.getenv("DIFY_API_KEY");

    private final OkHttpClient http = new OkHttpClient.Builder()
            .connectTimeout(30, TimeUnit.SECONDS)
            .readTimeout(120, TimeUnit.SECONDS)
            .build();

    /**
     * 调用 Dify 知识库问答（非流式）
     */
    public String chat(String conversationId, String userMessage) throws Exception {
        JSONObject body = new JSONObject()
                .put("inputs", new JSONObject())
                .put("query", userMessage)
                .put("response_mode", "blocking")     // blocking 或 streaming
                .put("conversation_id", conversationId == null ? "" : conversationId)
                .put("user", "java-client");

        Request request = new Request.Builder()
                .url(DIFY_BASE_URL + "/chat-messages")
                .addHeader("Authorization", "Bearer " + API_KEY)
                .addHeader("Content-Type", "application/json")
                .post(RequestBody.create(body.toString(), MediaType.parse("application/json")))
                .build();

        try (Response resp = http.newCall(request).execute()) {
            JSONObject result = new JSONObject(resp.body().string());
            return result.getString("answer");
        }
    }

    /**
     * 调用 Dify Workflow（批量处理）
     */
    public Map<String, Object> runWorkflow(Map<String, String> inputs) throws Exception {
        JSONObject body = new JSONObject()
                .put("inputs", new JSONObject(inputs))
                .put("response_mode", "blocking")
                .put("user", "java-client");

        Request request = new Request.Builder()
                .url(DIFY_BASE_URL + "/workflows/run")
                .addHeader("Authorization", "Bearer " + API_KEY)
                .addHeader("Content-Type", "application/json")
                .post(RequestBody.create(body.toString(), MediaType.parse("application/json")))
                .build();

        try (Response resp = http.newCall(request).execute()) {
            JSONObject result = new JSONObject(resp.body().string());
            JSONObject outputs = result.getJSONObject("data").getJSONObject("outputs");
            return outputs.toMap();
        }
    }
}

// 使用示例
@RestController
@RequiredArgsConstructor
public class KnowledgeController {

    private final DifyClient difyClient;
    private final Map<String, String> sessionConversations = new ConcurrentHashMap<>();

    @PostMapping("/ask")
    public Map<String, String> ask(@RequestBody Map<String, String> req,
                                    HttpSession session) throws Exception {
        String conversationId = sessionConversations.get(session.getId());
        String answer = difyClient.chat(conversationId, req.get("question"));
        return Map.of("answer", answer);
    }
}

6.3 Python 集成示例

# dify_client.py
import os
import requests


class DifyClient:
    def __init__(self, base_url: str, api_key: str):
        self.base_url = base_url.rstrip("/") + "/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

    def chat(self, message: str, conversation_id: str = "", user: str = "default") -> dict:
        """知识库问答（非流式）"""
        resp = requests.post(
            f"{self.base_url}/chat-messages",
            headers=self.headers,
            json={
                "inputs": {},
                "query": message,
                "response_mode": "blocking",
                "conversation_id": conversation_id,
                "user": user
            },
            timeout=120
        )
        resp.raise_for_status()
        data = resp.json()
        return {
            "answer": data["answer"],
            "conversation_id": data["conversation_id"],
            "sources": [m.get("segment", {}).get("content", "")
                       for m in data.get("metadata", {}).get("retriever_resources", [])]
        }

    def run_workflow(self, inputs: dict, user: str = "default") -> dict:
        """执行工作流"""
        resp = requests.post(
            f"{self.base_url}/workflows/run",
            headers=self.headers,
            json={"inputs": inputs, "response_mode": "blocking", "user": user},
            timeout=300
        )
        resp.raise_for_status()
        return resp.json()["data"]["outputs"]


# 使用示例
if __name__ == "__main__":
    dify = DifyClient(
        base_url="http://your-dify-server",
        api_key=os.getenv("DIFY_API_KEY")
    )

    # 知识库问答
    result = dify.chat("产品的退款政策是什么？")
    print("答案：", result["answer"])
    print("来源：", result["sources"][:1])

    # 工作流（简历筛选）
    screening = dify.run_workflow({
        "job_description": "需要 Java 3年以上经验，熟悉 Spring Boot",
        "resume": "张三，Java 工程师，5年经验..."
    })
    print("筛选结果：", screening)

七、Dify 的能力上限：什么场景必须自研

总结

Dify 是目前开源 AI 平台中最成熟的选择，选型建议：

• 标准 RAG / 工作流 / 多模型管理 → 直接用 Dify，2小时上线
• 需要与现有 Java/Python 系统集成 → Dify 提供 API，接入简单
• 追求高度定制 → 用 Dify 快速验证，再考虑自研

月均维护成本：服务器 ¥200-500 + API 费用（按量）

关注博主，下一篇：《大模型 Function Calling 深度实战》

标签：Dify Dify教程 Dify部署 AI应用平台 低代码AI RAG DeepSeek接入 企业AI开发