DeepSeek V3/R1 (MaaS商用推理) → Flexus X实例 → Dify平台 → AI知识库 → 企业生产可用

┌─────────────────────────────────────────────────────┐
│                    用户终端                           │
│          (Web / API / 微信 / 钉钉)                    │
└────────────────────┬────────────────────────────────┘
                     │ HTTPS
                     ▼
┌─────────────────────────────────────────────────────┐
│              Dify 应用开发平台                        │
│  ┌──────────────────────────────────────────────┐   │
│  │  RAG Pipeline: 文档解析→切分→向量化→检索      │   │
│  │  Agent: 意图识别→工具调用→多轮对话            │   │
│  │  LLM节点: Prompt模板→模型调用→后处理          │   │
│  └──────────────────────────────────────────────┘   │
└────────────────────┬────────────────────────────────┘
                     │ API
          ┌──────────┼──────────┐
          ▼          ▼          ▼
    DeepSeek     Embedding    Flexus X
    V3/R1        Model        (向量数据库/
    (MaaS)       (MaaS)       存储服务)

# API配置示例
import openai

# DeepSeek V3 - 适合通用对话和内容生成
V3_ENDPOINT = "https://maas-deepseek-v3.apigw.huawei.com/v1"
V3_API_KEY = "your-api-key-here"

# DeepSeek R1 - 适合复杂推理任务
R1_ENDPOINT = "https://maas-deepseek-r1.apigw.huawei.com/v1"
R1_API_KEY = "your-api-key-here"

from openai import OpenAI

client = OpenAI(
    api_key=R1_API_KEY,
    base_url=R1_ENDPOINT
)

response = client.chat.completions.create(
    model="deepseek-r1",
    messages=[
        {"role": "system", "content": "你是一个资深的Python技术专家"},
        {"role": "user", "content": "请详细解释Python中的装饰器模式，\
         包括functools.wraps的作用，并给出一个带参数的装饰器示例"}
    ],
    temperature=0.6,
    max_tokens=2048
)

print(response.choices[0].message.content)

# 1. 安装 Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# 2. 安装 Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

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

# 4. 复制环境变量配置
cp .env.example .env

# 5. 编辑 .env，配置 DeepSeek API
# SECRET_KEY 需要随机生成
# 执行: openssl rand -base64 42
vi .env

# 安全密钥（必须修改）
SECRET_KEY=your-random-64-char-secret

# 初始化管理员邮箱和密码
INITIAL_ADMIN_EMAIL=admin@example.com
INITIAL_ADMIN_PASSWORD=your-secure-password

# PostgreSQL 配置
DB_USERNAME=postgres
DB_PASSWORD=dify_secure_pass
DB_DATABASE=dify

# Redis 配置
REDIS_PASSWORD=dify_redis_pass

# 存储后端（生产环境推荐 S3）
STORAGE_TYPE=local
# STORAGE_TYPE=s3
# S3_BUCKET_NAME=dify-files
# AWS_ACCESS_KEY_ID=xxx
# AWS_SECRET_ACCESS_KEY=xxx
# S3_ENDPOINT=https://obs.cn-east-3.myhuaweicloud.com

# 6. 启动所有服务
docker-compose up -d

# 7. 验证服务状态
docker-compose ps

# 输出应该类似：
#      Name                    Command               State           Ports
# --------------------------------------------------------------------------------
# dify-api          /bin/bash /entrypoint.sh          Up      5001/tcp
# dify-web          /bin/bash /entrypoint.sh          Up      0.0.0.0:3000->3000/tcp
# dify-worker       /bin/bash /entrypoint.sh          Up      5001/tcp
# db                docker-entrypoint.sh postgres     Up      5432/tcp
# redis             docker-entrypoint.sh sh ...       Up      6379/tcp
# weaviate          /bin/weaviate --host 0.0.0.0      Up      8080/tcp, 50051/tcp

模型类型: LLM
名称: DeepSeek-R1
API端点: https://maas-deepseek-r1.apigw.huawei.com/v1
API密钥: your-api-key
模型名: deepseek-r1
上下文长度: 8192（最大支持128K）

模型类型: Embedding
名称: DeepSeek-Embedding (或使用其他兼容模型)
API端点: https://maas-deepseek-v3.apigw.huawei.com/v1
API密钥: your-api-key

# 检查端口占用
sudo lsof -i :3000
sudo lsof -i :5432

# 修改 docker-compose.yml 中的端口映射
# 例如：将 5432 映射到宿主机 5433

# Dify 推荐至少 4GB 内存
# 检查内存使用
free -h

# 如果内存不足，可以限制部分服务
# 修改 docker-compose.yml，添加deploy.resources.limits

# 检查是否缺少必要的内核参数
sudo sysctl -w vm.max_map_count=262144

# 永久生效
echo "vm.max_map_count=262144" | sudo tee -a /etc/sysctl.conf

# 文档分段策略配置
分段方式: 自定义（按段落分隔，额外使用分隔符）
分隔符: ["\n\n", "\n", "。", "!", "?"]
分段最大长度: 500 tokens
分段重叠: 50 tokens  # 避免上下文断裂
检索召回数: 3        # 每次检索返回Top-3相关片段

检索策略: 混合检索
  向量权重: 0.7    # 语义相似度占比70%
  关键词权重: 0.3  # 精确匹配占比30%

rerank模式: 启用   # 使用rerank模型对召回结果重排序
rerank模型: 使用Dify内置的rerank模型

系统提示词:
  你是一个专业的技术文档助手。请基于以下参考信息回答问题。

  ## 回答要求
  1. 优先使用参考信息中的内容回答
  2. 如果参考信息不足以完整回答问题，请清晰说明局限性
  3. 涉及代码时，标注版本号和依赖关系
  4. 当多条信息存在冲突时，指出并说明原因
  5. 如果问题与参考信息无关，请拒绝回答

  ## 参考信息
  {{#context#}}

  ## 对话历史
  {{#histories#}}

  ## 当前问题
  {{#query#}}

变量定义:
  context: 知识库检索结果（系统自动填充）
  histories: 多轮对话历史（可选）
  query: 用户当前提问

根据项目文档，该项目支持以下认证方式：

1. **API Key认证**（推荐）：
   - 在请求头中添加 `Authorization: Bearer <your_api_key>`
   - 适用于服务端到服务端的通信场景

2. **OAuth 2.0 授权码模式**：
   - 支持标准的 Authorization Code Flow
   - 配置步骤：
     a. 在控制台创建 OAuth 应用
     b. 设置回调 URL
     c. 通过 `/oauth/authorize` 获取授权码
     d. 通过 `/oauth/token` 换取 access_token
   - 适用于需要用户授权的Web应用

注意：OAuth 2.0 需要额外配置 Client ID 和 Client Secret，
具体配置文档请参考项目的 `docs/auth.md`。

import requests
import json

DIFY_URL = "http://your-dify-instance:3000"
API_KEY = "your-dify-api-key"

def batch_import_documents(dataset_id, documents):
    """
    批量导入文档到知识库
    """
    for doc in documents:
        payload = {
            "data_source_type": "upload_file",
            "indexing_technique": "high_quality",  # 高质量索引
            "doc_form": "text_model",
            "doc_language": "Chinese",
            "doc_type": "technical_doc",
            "process_rule": {
                "mode": "custom",
                "rules": {
                    "pre_processing_rules": [
                        {"id": "remove_extra_spaces", "enabled": True},
                        {"id": "remove_urls_emails", "enabled": False}
                    ],
                    "segmentation": {
                        "separator": "\n\n",
                        "max_tokens": 500,
                        "chunk_overlap": 50
                    }
                }
            }
        }

        # 上传文件并创建索引
        with open(doc["file_path"], "rb") as f:
            files = {"file": f}
            resp = requests.post(
                f"{DIFY_URL}/v1/datasets/{dataset_id}/document/create-by-file",
                headers={"Authorization": f"Bearer {API_KEY}"},
                data=payload,
                files=files
            )

        result = resp.json()
        print(f"文档 {doc['name']} 导入{'成功' if resp.ok else '失败'}: {result}")

# Dify 工作流中配置缓存
缓存类型: Redis
缓存策略: 
  精确匹配: 开启  # 完全相同的问题命中缓存
  语义匹配: 开启  # 相似问题（0.95相似度以上）命中缓存
缓存TTL: 3600秒  # 1小时后自动过期

# 在 Flexus X 实例上配置 Nginx 反代和限流
upstream dify_api {
    server 127.0.0.1:5001;
    keepalive 64;
}

# 限流配置
limit_req_zone $binary_remote_addr zone=dify_limit:10m rate=10r/s;
limit_conn_zone $binary_remote_addr zone=addr_limit:10m;

server {
    listen 443 ssl;
    server_name dify.example.com;

    location / {
        limit_req zone=dify_limit burst=20 nodelay;
        limit_conn addr_limit 5;
        proxy_pass http://dify_api;
    }
}

# docker-compose 中优化 Weaviate 配置
services:
  weaviate:
    image: semitechnologies/weaviate:1.25.1
    environment:
      # 利用 Flexus X 的高IOPS
      DISK_USE_ON_QUERY: 95
      # 合理分配内存
      MEMORY_LIMIT: 4096MB
      # 优化索引构建
      HNSW_EF_CONSTRUCTION: 128
      HNSW_EF: -1
      # 向量维度（与 Embedding 模型对齐）
      DEFAULT_VECTORIZER_MODULE: text2vec-contextionary

# 成本监控脚本示例
import time
from collections import deque

class CostTracker:
    def __init__(self, budget_daily=50):
        self.budget_daily = budget_daily  # 日预算（元）
        self.records = deque(maxlen=10000)

    def record_call(self, model, tokens_in, tokens_out):
        """记录一次LLM调用"""
        # DeepSeek 商用参考价格（请以官网最新为准）
        PRICES = {
            "deepseek-v3": {"in": 0.002, "out": 0.008},   # 元/1K tokens
            "deepseek-r1": {"in": 0.004, "out": 0.016},
        }
        price = PRICES.get(model, PRICES["deepseek-v3"])
        cost = (tokens_in * price["in"] + tokens_out * price["out"]) / 1000

        self.records.append({
            "time": time.time(),
            "model": model,
            "tokens_in": tokens_in,
            "tokens_out": tokens_out,
            "cost": cost
        })

    def daily_cost(self):
        """今日累计费用"""
        today_start = time.time() - 86400
        return sum(r["cost"] for r in self.records if r["time"] > today_start)

    def check_budget(self):
        """检查预算是否超限"""
        daily = self.daily_cost()
        return {
            "daily_cost": round(daily, 4),
            "budget": self.budget_daily,
            "remaining": round(self.budget_daily - daily, 4),
            "over_budget": daily > self.budget_daily
        }

# 使用华为云 CCE 部署 Dify 高可用版
# 该方案会自动部署：
# - 2个API Pod（互备）
# - 2个Worker Pod（互备）
# - PostgreSQL 主从
# - Redis 主从
# - Weaviate 多节点

# 部署命令（在华为云控制台操作）
# 访问 https://console.huaweicloud.com/cce
# 创建集群 → 部署 Dify Helm Chart

工具1: 服务器状态查询
  API: GET /api/server/status
  参数: server_id (string)
  描述: 查询指定服务器的CPU、内存、磁盘状态

工具2: 日志检索
  API: POST /api/logs/search
  参数: keyword, time_range, level
  描述: 按关键词和时间范围检索日志

工具3: 知识库检索
  类型: Dify内置知识库工具
  描述: 查询运维知识库中的文档

用户提问: "生产环境数据库响应变慢，怎么排查？"

Agent执行流程:
1. 意图识别 → "数据库性能问题排查"
2. 调用工具1 → 查询数据库服务器状态（CPU 85%，内存70%，IO等待30%）
3. 调用知识库 → 检索"数据库慢查询排查"
4. 调用工具2 → 检索MySQL慢查询日志
5. 综合分析 → 
   - 发现大量全表扫描的慢查询
   - 建议添加索引
   - 给出具体SQL优化建议
6. 汇总回答 → 给出排查报告和优化方案

cd /path/to/dify/docker
docker-compose pull
docker-compose up -d --force-recreate
docker system prune -f  # 清理旧镜像