Dify文本处理服务：从理论到实践

最新推荐文章于 2025-11-06 14:12:13 发布

原创最新推荐文章于 2025-11-06 14:12:13 发布 · 903 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#Dify # 文本处理 #AI应用 # 自然语言处理

部署运行你感兴趣的模型镜像

摘要

本文将详细介绍Dify文本处理服务的使用方法、技术细节以及最佳实践。Dify是一个强大的文本处理平台，支持多种自然语言处理任务，如文本生成、文本分类、情感分析等。通过本文，您将了解如何使用Dify进行文本处理，如何优化性能，以及如何在实际项目中应用。文章将通过实践示例、架构图、流程图等多种形式，帮助您更好地理解和应用Dify。本文面向中国开发者，特别是AI应用开发者，内容包括完整的代码示例、架构图、流程图、思维导图、甘特图和饼图等，以增强可读性和实用性。

正文

1. Dify简介

Dify是一个基于人工智能的文本处理平台，支持多种自然语言处理任务，如文本生成、文本分类、情感分析等。Dify提供了简单易用的API接口，开发者可以通过这些接口快速集成文本处理功能到自己的应用中。

Dify的核心优势包括：

多功能性：支持多种NLP任务，包括文本生成、分类、摘要等
易用性：提供简洁的API接口，降低集成难度
可扩展性：支持自定义模型和工作流
可视化界面：提供友好的Web界面，便于管理和监控

1.1 Dify架构概览

2. 环境准备

在开始使用Dify之前，需要进行一些环境准备。以下是一些基本步骤：

2.1 安装Python

Dify的API接口可以通过Python脚本调用。确保您已经安装了Python 3.6或更高版本。可以通过以下命令安装Python：

# Ubuntu/Debian系统
sudo apt-get update
sudo apt-get install python3 python3-pip

# CentOS/RHEL系统
sudo yum install python3 python3-pip

# macOS系统（使用Homebrew）
brew install python3

2.2 安装依赖库

Dify的Python SDK可以通过pip安装：

pip install dify-sdk

如果需要使用更多功能，还可以安装额外的依赖：

pip install requests
pip install python-dotenv

3. Dify核心功能详解

3.1 文本生成

Dify的文本生成功能可以根据输入的提示生成相关的文本内容。以下是一个简单的示例：

# -*- coding: utf-8 -*-
"""
Dify文本生成功能示例
该示例演示了如何使用Dify SDK进行文本生成
"""

import os
import json
import logging
from typing import Dict, Any
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class DifyTextGenerator:
    """Dify文本生成器类"""
    
    def __init__(self, api_key: str = None, base_url: str = "https://api.dify.ai/v1"):
        """
        初始化Dify文本生成器
        
        Args:
            api_key (str): Dify API密钥
            base_url (str): Dify API基础URL
        """
        self.api_key = api_key or os.getenv("DIFY_API_KEY")
        if not self.api_key:
            raise ValueError("API密钥未设置，请提供有效的Dify API密钥")
        
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        logger.info("Dify文本生成器初始化完成")
    
    def generate_text(self, prompt: str, **kwargs) -> Dict[str, Any]:
        """
        生成文本内容
        
        Args:
            prompt (str): 输入提示
            **kwargs: 其他参数，如temperature、max_tokens等
            
        Returns:
            Dict[str, Any]: 生成结果
        """
        import requests
        
        try:
            # 构建请求数据
            data = {
                "inputs": {
                    "query": prompt
                },
                "response_mode": "blocking",
                "user": "user-123"
            }
            
            # 添加可选参数
            if "temperature" in kwargs:
                data["parameters"] = {"temperature": kwargs["temperature"]}
            
            # 发送请求
            response = requests.post(
                f"{self.base_url}/completion-messages",
                headers=self.headers,
                json=data,
                timeout=30
            )
            
            # 检查响应状态
            response.raise_for_status()
            
            # 解析响应
            result = response.json()
            logger.info(f"文本生成成功，消耗tokens: {result.get('metadata', {}).get('usage', {})}")
            
            return {
                "success": True,
                "text": result.get("answer", ""),
                "usage": result.get("metadata", {}).get("usage", {}),
                "raw_response": result
            }
            
        except requests.exceptions.RequestException as e:
            logger.error(f"请求Dify API时发生错误: {e}")
            return {
                "success": False,
                "error": str(e),
                "text": ""
            }
        except json.JSONDecodeError as e:
            logger.error(f"解析Dify响应时发生错误: {e}")
            return {
                "success": False,
                "error": "响应格式错误",
                "text": ""
            }
        except Exception as e:
            logger.error(f"生成文本时发生未知错误: {e}")
            return {
                "success": False,
                "error": str(e),
                "text": ""
            }

# 使用示例
if __name__ == "__main__":
    try:
        # 创建Dify文本生成器实例
        generator = DifyTextGenerator()
        
        # 输入提示
        prompt = "请生成一段关于人工智能发展趋势的介绍，要求包含技术发展、应用领域和未来展望。"
        
        # 调用文本生成接口
        result = generator.generate_text(
            prompt, 
            temperature=0.7
        )
        
        # 处理结果
        if result["success"]:
            print("生成的文本:")
            print(result["text"])
            print(f"\n使用情况: {result['usage']}")
        else:
            print(f"生成失败: {result['error']}")
            
    except Exception as e:
        print(f"程序执行出错: {e}")

3.2 文本分类

Dify的文本分类功能可以对输入的文本进行分类。以下是一个示例：

# -*- coding: utf-8 -*-
"""
Dify文本分类功能示例
该示例演示了如何使用Dify SDK进行文本分类
"""

import os
import json
import logging
from typing import Dict, Any, List
from dotenv import load_dotenv
import requests

# 加载环境变量
load_dotenv()

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class DifyTextClassifier:
    """Dify文本分类器类"""
    
    def __init__(self, api_key: str = None, base_url: str = "https://api.dify.ai/v1"):
        """
        初始化Dify文本分类器
        
        Args:
            api_key (str): Dify API密钥
            base_url (str): Dify API基础URL
        """
        self.api_key = api_key or os.getenv("DIFY_API_KEY")
        if not self.api_key:
            raise ValueError("API密钥未设置，请提供有效的Dify API密钥")
        
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        logger.info("Dify文本分类器初始化完成")
    
    def classify_text(self, text: str, categories: List[str] = None) -> Dict[str, Any]:
        """
        对文本进行分类
        
        Args:
            text (str): 待分类的文本
            categories (List[str]): 可选的分类标签列表
            
        Returns:
            Dict[str, Any]: 分类结果
        """
        try:
            # 构建请求数据
            data = {
                "inputs": {
                    "text": text
                },
                "response_mode": "blocking",
                "user": "user-123"
            }
            
            # 如果提供了分类标签，则添加到输入中
            if categories:
                data["inputs"]["categories"] = ", ".join(categories)
            
            # 发送请求
            response = requests.post(
                f"{self.base_url}/completion-messages",
                headers=self.headers,
                json=data,
                timeout=30
            )
            
            # 检查响应状态
            response.raise_for_status()
            
            # 解析响应
            result = response.json()
            logger.info("文本分类完成")
            
            return {
                "success": True,
                "category": result.get("answer", ""),
                "raw_response": result
            }
            
        except requests.exceptions.RequestException as e:
            logger.error(f"请求Dify API时发生错误: {e}")
            return {
                "success": False,
                "error": str(e),
                "category": ""
            }
        except json.JSONDecodeError as e:
            logger.error(f"解析Dify响应时发生错误: {e}")
            return {
                "success": False,
                "error": "响应格式错误",
                "category": ""
            }
        except Exception as e:
            logger.error(f"文本分类时发生未知错误: {e}")
            return {
                "success": False,
                "error": str(e),
                "category": ""
            }

# 使用示例
if __name__ == "__main__":
    try:
        # 创建Dify文本分类器实例
        classifier = DifyTextClassifier()
        
        # 输入文本
        text = "这是一篇关于人工智能的文章，介绍了机器学习和深度学习的最新进展。"
        
        # 定义分类标签
        categories = ["科技", "娱乐", "体育", "财经", "教育"]
        
        # 调用文本分类接口
        result = classifier.classify_text(text, categories)
        
        # 处理结果
        if result["success"]:
            print(f"分类结果: {result['category']}")
        else:
            print(f"分类失败: {result['error']}")
            
    except Exception as e:
        print(f"程序执行出错: {e}")

3.3 情感分析

Dify还可以用于情感分析，判断文本的情感倾向：

# -*- coding: utf-8 -*-
"""
Dify情感分析功能示例
该示例演示了如何使用Dify SDK进行情感分析
"""

import os
import json
import logging
from typing import Dict, Any
from dotenv import load_dotenv
import requests

# 加载环境变量
load_dotenv()

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class DifySentimentAnalyzer:
    """Dify情感分析器类"""
    
    def __init__(self, api_key: str = None, base_url: str = "https://api.dify.ai/v1"):
        """
        初始化Dify情感分析器
        
        Args:
            api_key (str): Dify API密钥
            base_url (str): Dify API基础URL
        """
        self.api_key = api_key or os.getenv("DIFY_API_KEY")
        if not self.api_key:
            raise ValueError("API密钥未设置，请提供有效的Dify API密钥")
        
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        logger.info("Dify情感分析器初始化完成")
    
    def analyze_sentiment(self, text: str) -> Dict[str, Any]:
        """
        分析文本情感
        
        Args:
            text (str): 待分析的文本
            
        Returns:
            Dict[str, Any]: 情感分析结果
        """
        try:
            # 构建请求数据
            data = {
                "inputs": {
                    "text": text
                },
                "response_mode": "blocking",
                "user": "user-123"
            }
            
            # 发送请求
            response = requests.post(
                f"{self.base_url}/completion-messages",
                headers=self.headers,
                json=data,
                timeout=30
            )
            
            # 检查响应状态
            response.raise_for_status()
            
            # 解析响应
            result = response.json()
            logger.info("情感分析完成")
            
            return {
                "success": True,
                "sentiment": result.get("answer", ""),
                "confidence": result.get("metadata", {}).get("usage", {}),
                "raw_response": result
            }
            
        except requests.exceptions.RequestException as e:
            logger.error(f"请求Dify API时发生错误: {e}")
            return {
                "success": False,
                "error": str(e),
                "sentiment": ""
            }
        except json.JSONDecodeError as e:
            logger.error(f"解析Dify响应时发生错误: {e}")
            return {
                "success": False,
                "error": "响应格式错误",
                "sentiment": ""
            }
        except Exception as e:
            logger.error(f"情感分析时发生未知错误: {e}")
            return {
                "success": False,
                "error": str(e),
                "sentiment": ""
            }

# 使用示例
if __name__ == "__main__":
    try:
        # 创建Dify情感分析器实例
        analyzer = DifySentimentAnalyzer()
        
        # 输入文本
        text = "这款产品真是太棒了！使用体验非常好，强烈推荐给大家。"
        
        # 调用情感分析接口
        result = analyzer.analyze_sentiment(text)
        
        # 处理结果
        if result["success"]:
            print(f"情感分析结果: {result['sentiment']}")
        else:
            print(f"情感分析失败: {result['error']}")
            
    except Exception as e:
        print(f"程序执行出错: {e}")

4. 性能优化

在实际应用中，性能优化是非常重要的。以下是一些优化建议：

4.1 减少输入标记数量

输入的标记数量越多，处理时间越长。可以通过优化输入提示，减少不必要的标记数量。

# -*- coding: utf-8 -*-
"""
Dify性能优化示例
该示例演示了如何优化Dify API调用性能
"""

import time
import functools
from typing import Any, Callable

def optimize_prompt(prompt: str, max_length: int = 500) -> str:
    """
    优化提示文本，控制长度
    
    Args:
        prompt (str): 原始提示文本
        max_length (int): 最大长度限制
        
    Returns:
        str: 优化后的提示文本
    """
    if len(prompt) <= max_length:
        return prompt
    
    # 截取关键部分
    return prompt[:max_length] + "..."

def retry_on_failure(max_retries: int = 3, delay: float = 1.0):
    """
    重试装饰器，用于处理临时性错误
    
    Args:
        max_retries (int): 最大重试次数
        delay (float): 重试间隔时间（秒）
    """
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            last_exception = None
            
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_exception = e
                    if attempt < max_retries - 1:
                        time.sleep(delay * (2 ** attempt))  # 指数退避
                        continue
                    else:
                        raise last_exception
            
            return None
        return wrapper
    return decorator

# 使用示例
if __name__ == "__main__":
    # 优化提示文本示例
    long_prompt = "这是一个非常长的提示文本，包含了很多不必要的信息。" * 20
    optimized_prompt = optimize_prompt(long_prompt, 100)
    print(f"原始提示长度: {len(long_prompt)}")
    print(f"优化后提示长度: {len(optimized_prompt)}")
    print(f"优化后提示: {optimized_prompt}")

4.2 使用缓存

对于重复的输入提示，可以使用缓存来减少重复计算。

# -*- coding: utf-8 -*-
"""
Dify缓存机制示例
该示例演示了如何使用缓存优化Dify API调用
"""

import hashlib
import json
import time
from typing import Dict, Any, Optional
from functools import lru_cache

class DifyCache:
    """Dify缓存类"""
    
    def __init__(self, max_size: int = 1000, ttl: int = 3600):
        """
        初始化缓存
        
        Args:
            max_size (int): 最大缓存条目数
            ttl (int): 缓存过期时间（秒）
        """
        self.cache: Dict[str, Dict[str, Any]] = {}
        self.max_size = max_size
        self.ttl = ttl
    
    def _generate_key(self, prompt: str, params: Dict[str, Any]) -> str:
        """
        生成缓存键
        
        Args:
            prompt (str): 提示文本
            params (Dict[str, Any]): 参数字典
            
        Returns:
            str: 缓存键
        """
        key_data = {
            "prompt": prompt,
            "params": params
        }
        key_string = json.dumps(key_data, sort_keys=True)
        return hashlib.md5(key_string.encode()).hexdigest()
    
    def get(self, prompt: str, params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
        """
        从缓存获取数据
        
        Args:
            prompt (str): 提示文本
            params (Dict[str, Any]): 参数字典
            
        Returns:
            Optional[Dict[str, Any]]: 缓存数据或None
        """
        key = self._generate_key(prompt, params)
        if key in self.cache:
            entry = self.cache[key]
            # 检查是否过期
            if time.time() - entry["timestamp"] < self.ttl:
                return entry["data"]
            else:
                # 删除过期条目
                del self.cache[key]
        return None
    
    def set(self, prompt: str, params: Dict[str, Any], data: Dict[str, Any]) -> None:
        """
        设置缓存数据
        
        Args:
            prompt (str): 提示文本
            params (Dict[str, Any]): 参数字典
            data (Dict[str, Any]): 要缓存的数据
        """
        # 如果缓存已满，删除最旧的条目
        if len(self.cache) >= self.max_size:
            oldest_key = next(iter(self.cache))
            del self.cache[oldest_key]
        
        key = self._generate_key(prompt, params)
        self.cache[key] = {
            "data": data,
            "timestamp": time.time()
        }

# 全局缓存实例
dify_cache = DifyCache()

@lru_cache(maxsize=128)
def cached_text_generation(prompt: str, temperature: float = 0.7) -> str:
    """
    使用LRU缓存的文本生成函数
    
    Args:
        prompt (str): 提示文本
        temperature (float): 温度参数
        
    Returns:
        str: 生成的文本
    """
    # 这里应该是实际的Dify API调用
    # 为了示例，我们返回模拟结果
    return f"基于提示'{prompt}'生成的文本（温度: {temperature}）"

# 使用示例
if __name__ == "__main__":
    # 测试缓存功能
    prompt = "人工智能的发展趋势"
    
    # 第一次调用
    start_time = time.time()
    result1 = cached_text_generation(prompt, 0.7)
    end_time = time.time()
    print(f"第一次调用耗时: {end_time - start_time:.4f}秒")
    print(f"结果: {result1}")
    
    # 第二次调用（应该从缓存获取）
    start_time = time.time()
    result2 = cached_text_generation(prompt, 0.7)
    end_time = time.time()
    print(f"第二次调用耗时: {end_time - start_time:.4f}秒")
    print(f"结果: {result2}")
    
    # 测试自定义缓存
    params = {"temperature": 0.7, "max_tokens": 100}
    cache_data = {"text": "缓存的生成结果", "usage": {"tokens": 50}}
    
    # 设置缓存
    dify_cache.set(prompt, params, cache_data)
    
    # 获取缓存
    cached_result = dify_cache.get(prompt, params)
    print(f"自定义缓存结果: {cached_result}")

5. 实践案例

以下是一个实际应用场景的案例：

5.1 案例背景

假设您正在开发一个智能客服系统，需要对用户的输入进行分类，并生成相应的回答。

5.2 实现步骤

用户输入分类：使用Dify的文本分类功能对用户的输入进行分类。
生成回答：根据分类结果，使用Dify的文本生成功能生成回答。

# -*- coding: utf-8 -*-
"""
Dify智能客服系统示例
该示例演示了如何构建一个完整的智能客服系统
"""

import os
import json
import time
import logging
from typing import Dict, Any, List
from enum import Enum
from dataclasses import dataclass
from dotenv import load_dotenv
import requests

# 加载环境变量
load_dotenv()

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class IntentType(Enum):
    """意图类型枚举"""
    PRODUCT_INQUIRY = "产品咨询"
    TECHNICAL_SUPPORT = "技术支持"
    ORDER_QUERY = "订单查询"
    COMPLAINT = "投诉建议"
    OTHER = "其他"

@dataclass
class UserMessage:
    """用户消息数据类"""
    user_id: str
    message: str
    timestamp: float

@dataclass
class BotResponse:
    """机器人响应数据类"""
    intent: str
    response: str
    confidence: float
    processing_time: float

class DifyCustomerServiceBot:
    """Dify智能客服机器人"""
    
    def __init__(self, api_key: str = None, base_url: str = "https://api.dify.ai/v1"):
        """
        初始化智能客服机器人
        
        Args:
            api_key (str): Dify API密钥
            base_url (str): Dify API基础URL
        """
        self.api_key = api_key or os.getenv("DIFY_API_KEY")
        if not self.api_key:
            raise ValueError("API密钥未设置，请提供有效的Dify API密钥")
        
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        # 定义意图分类标签
        self.intent_labels = [
            IntentType.PRODUCT_INQUIRY.value,
            IntentType.TECHNICAL_SUPPORT.value,
            IntentType.ORDER_QUERY.value,
            IntentType.COMPLAINT.value,
            IntentType.OTHER.value
        ]
        
        logger.info("Dify智能客服机器人初始化完成")
    
    def classify_intent(self, message: str) -> Dict[str, Any]:
        """
        分类用户意图
        
        Args:
            message (str): 用户消息
            
        Returns:
            Dict[str, Any]: 意图分类结果
        """
        start_time = time.time()
        
        try:
            # 构建请求数据
            data = {
                "inputs": {
                    "text": message,
                    "categories": ", ".join(self.intent_labels)
                },
                "response_mode": "blocking",
                "user": "customer-service-bot"
            }
            
            # 发送请求
            response = requests.post(
                f"{self.base_url}/completion-messages",
                headers=self.headers,
                json=data,
                timeout=30
            )
            
            # 检查响应状态
            response.raise_for_status()
            
            # 解析响应
            result = response.json()
            
            processing_time = time.time() - start_time
            logger.info(f"意图分类完成，耗时: {processing_time:.2f}秒")
            
            return {
                "success": True,
                "intent": result.get("answer", IntentType.OTHER.value),
                "confidence": 0.95,  # 模拟置信度
                "processing_time": processing_time,
                "raw_response": result
            }
            
        except Exception as e:
            processing_time = time.time() - start_time
            logger.error(f"意图分类失败: {e}")
            return {
                "success": False,
                "intent": IntentType.OTHER.value,
                "confidence": 0.0,
                "processing_time": processing_time,
                "error": str(e)
            }
    
    def generate_response(self, message: str, intent: str) -> Dict[str, Any]:
        """
        生成回复内容
        
        Args:
            message (str): 用户消息
            intent (str): 识别的意图
            
        Returns:
            Dict[str, Any]: 生成的回复
        """
        start_time = time.time()
        
        try:
            # 根据不同意图构建不同的提示
            intent_prompts = {
                IntentType.PRODUCT_INQUIRY.value: f"用户询问产品相关信息：{message}。请提供详细且友好的产品介绍。",
                IntentType.TECHNICAL_SUPPORT.value: f"用户需要技术支持：{message}。请提供专业且易懂的技术解决方案。",
                IntentType.ORDER_QUERY.value: f"用户查询订单状态：{message}。请提供清晰的订单信息查询指引。",
                IntentType.COMPLAINT.value: f"用户提出投诉建议：{message}。请表达歉意并提供积极的解决方案。",
                IntentType.OTHER.value: f"用户消息：{message}。请提供通用且友好的回复。"
            }
            
            prompt = intent_prompts.get(intent, intent_prompts[IntentType.OTHER.value])
            
            # 构建请求数据
            data = {
                "inputs": {
                    "query": prompt
                },
                "response_mode": "blocking",
                "user": "customer-service-bot"
            }
            
            # 发送请求
            response = requests.post(
                f"{self.base_url}/completion-messages",
                headers=self.headers,
                json=data,
                timeout=30
            )
            
            # 检查响应状态
            response.raise_for_status()
            
            # 解析响应
            result = response.json()
            
            processing_time = time.time() - start_time
            logger.info(f"回复生成完成，耗时: {processing_time:.2f}秒")
            
            return {
                "success": True,
                "response": result.get("answer", "抱歉，我无法生成回复。"),
                "processing_time": processing_time,
                "usage": result.get("metadata", {}).get("usage", {}),
                "raw_response": result
            }
            
        except Exception as e:
            processing_time = time.time() - start_time
            logger.error(f"回复生成失败: {e}")
            return {
                "success": False,
                "response": "抱歉，我现在无法回答您的问题，请稍后再试。",
                "processing_time": processing_time,
                "error": str(e)
            }
    
    def process_message(self, user_message: UserMessage) -> BotResponse:
        """
        处理用户消息
        
        Args:
            user_message (UserMessage): 用户消息对象
            
        Returns:
            BotResponse: 机器人响应对象
        """
        logger.info(f"处理用户消息: {user_message.message}")
        
        # 1. 意图分类
        intent_result = self.classify_intent(user_message.message)
        if not intent_result["success"]:
            return BotResponse(
                intent=IntentType.OTHER.value,
                response="抱歉，我无法理解您的问题，请重新表述。",
                confidence=0.0,
                processing_time=intent_result["processing_time"]
            )
        
        intent = intent_result["intent"]
        confidence = intent_result["confidence"]
        
        # 2. 生成回复
        response_result = self.generate_response(user_message.message, intent)
        if not response_result["success"]:
            return BotResponse(
                intent=intent,
                response="抱歉，我现在无法回答您的问题，请稍后再试。",
                confidence=confidence,
                processing_time=intent_result["processing_time"] + response_result["processing_time"]
            )
        
        return BotResponse(
            intent=intent,
            response=response_result["response"],
            confidence=confidence,
            processing_time=intent_result["processing_time"] + response_result["processing_time"]
        )

# 使用示例
if __name__ == "__main__":
    try:
        # 创建智能客服机器人实例
        bot = DifyCustomerServiceBot()
        
        # 模拟用户消息
        test_messages = [
            UserMessage("user_001", "你们的产品有哪些特色功能？", time.time()),
            UserMessage("user_002", "我的订单号123456789状态是什么？", time.time()),
            UserMessage("user_003", "软件安装后无法启动怎么办？", time.time()),
            UserMessage("user_004", "我对你们的服务很不满意", time.time())
        ]
        
        # 处理每条消息
        for msg in test_messages:
            print(f"\n{'='*50}")
            print(f"用户消息: {msg.message}")
            
            response = bot.process_message(msg)
            
            print(f"识别意图: {response.intent}")
            print(f"置信度: {response.confidence:.2f}")
            print(f"处理时间: {response.processing_time:.2f}秒")
            print(f"机器人回复: {response.response}")
            
    except Exception as e:
        print(f"程序执行出错: {e}")

6. 注意事项

在使用Dify时，需要注意以下几点：

6.1 API密钥安全

确保您的API密钥是安全的，不要泄露给他人。

# -*- coding: utf-8 -*-
"""
Dify API密钥安全管理示例
该示例演示了如何安全地管理API密钥
"""

import os
import logging
from typing import Optional
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class DifyAPIKeyManager:
    """Dify API密钥管理器"""
    
    def __init__(self):
        """初始化密钥管理器"""
        self._api_key: Optional[str] = None
        self._load_api_key()
    
    def _load_api_key(self) -> None:
        """从环境变量加载API密钥"""
        self._api_key = os.getenv("DIFY_API_KEY")
        if not self._api_key:
            logger.warning("未找到DIFY_API_KEY环境变量")
            # 可以从其他安全位置加载，如密钥管理服务
            # self._api_key = self._load_from_vault()
    
    def get_api_key(self) -> Optional[str]:
        """
        获取API密钥
        
        Returns:
            Optional[str]: API密钥或None
        """
        return self._api_key
    
    def validate_api_key(self) -> bool:
        """
        验证API密钥有效性
        
        Returns:
            bool: 密钥是否有效
        """
        if not self._api_key:
            return False
        
        # 这里应该实现实际的密钥验证逻辑
        # 例如调用Dify的验证接口
        return len(self._api_key) > 10  # 简单的长度检查
    
    def rotate_api_key(self) -> bool:
        """
        轮换API密钥
        
        Returns:
            bool: 轮换是否成功
        """
        # 这里应该实现实际的密钥轮换逻辑
        # 例如调用密钥管理服务生成新密钥
        logger.info("API密钥轮换功能需要根据具体环境实现")
        return True

# 使用示例
if __name__ == "__main__":
    # 创建密钥管理器
    key_manager = DifyAPIKeyManager()
    
    # 获取API密钥
    api_key = key_manager.get_api_key()
    if api_key:
        print("API密钥加载成功")
        # 掩盖密钥显示
        masked_key = api_key[:4] + "*" * (len(api_key) - 8) + api_key[-4:]
        print(f"API密钥: {masked_key}")
    else:
        print("API密钥加载失败")
    
    # 验证API密钥
    is_valid = key_manager.validate_api_key()
    print(f"API密钥有效性: {is_valid}")

6.2 输入限制

注意Dify的输入限制，避免输入过长的文本。

# -*- coding: utf-8 -*-
"""
Dify输入限制处理示例
该示例演示了如何处理输入长度限制
"""

import logging
from typing import Tuple

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class DifyInputHandler:
    """Dify输入处理器"""
    
    def __init__(self, max_input_length: int = 2000):
        """
        初始化输入处理器
        
        Args:
            max_input_length (int): 最大输入长度
        """
        self.max_input_length = max_input_length
    
    def validate_input(self, text: str) -> Tuple[bool, str]:
        """
        验证输入文本
        
        Args:
            text (str): 输入文本
            
        Returns:
            Tuple[bool, str]: (是否有效, 错误信息或处理后的文本)
        """
        if not text:
            return False, "输入文本不能为空"
        
        if len(text) > self.max_input_length:
            logger.warning(f"输入文本过长: {len(text)} 字符，超过限制 {self.max_input_length} 字符")
            # 可以选择截断或拒绝
            return True, self._truncate_text(text)
        
        return True, text
    
    def _truncate_text(self, text: str) -> str:
        """
        截断文本到最大长度
        
        Args:
            text (str): 原始文本
            
        Returns:
            str: 截断后的文本
        """
        # 保留关键部分，添加截断提示
        truncated = text[:self.max_input_length - 10] + "...[已截断]"
        logger.info(f"文本已截断至 {len(truncated)} 字符")
        return truncated
    
    def preprocess_text(self, text: str) -> str:
        """
        预处理文本
        
        Args:
            text (str): 原始文本
            
        Returns:
            str: 预处理后的文本
        """
        # 移除多余的空白字符
        text = " ".join(text.split())
        
        # 移除特殊字符（根据需要）
        # text = re.sub(r'[^\w\s\u4e00-\u9fff]', '', text)
        
        return text

# 使用示例
if __name__ == "__main__":
    # 创建输入处理器
    handler = DifyInputHandler(max_input_length=100)
    
    # 测试不同长度的输入
    test_texts = [
        "这是一个较短的输入文本。",
        "这是一个非常长的输入文本，" * 20 + "用于测试输入长度限制处理功能。",
        ""
    ]
    
    for i, text in enumerate(test_texts, 1):
        print(f"\n测试文本 {i}:")
        print(f"原始长度: {len(text)} 字符")
        
        is_valid, processed_text = handler.validate_input(text)
        
        if is_valid:
            print(f"处理后: {processed_text}")
            print(f"处理后长度: {len(processed_text)} 字符")
        else:
            print(f"验证失败: {processed_text}")

6.3 费用管理

虽然示例中的费用字段值为0，但在实际使用中，Dify可能会收取费用。请提前了解费用政策。

# -*- coding: utf-8 -*-
"""
Dify费用管理示例
该示例演示了如何监控和管理API使用费用
"""

import json
import logging
from typing import Dict, Any
from dataclasses import dataclass, asdict
from datetime import datetime

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@dataclass
class UsageRecord:
    """使用记录数据类"""
    timestamp: str
    tokens_input: int
    tokens_output: int
    total_tokens: int
    cost: float
    operation: str

class DifyUsageTracker:
    """Dify使用量跟踪器"""
    
    def __init__(self, daily_budget: float = 10.0):
        """
        初始化使用量跟踪器
        
        Args:
            daily_budget (float): 每日预算（美元）
        """
        self.daily_budget = daily_budget
        self.daily_usage: Dict[str, Any] = {
            "tokens_input": 0,
            "tokens_output": 0,
            "total_tokens": 0,
            "cost": 0.0,
            "requests": 0
        }
        self.usage_history: list = []
        self.cost_per_1k_tokens = 0.002  # 假设价格，需要根据实际定价调整
    
    def record_usage(self, usage_data: Dict[str, Any], operation: str = "unknown") -> None:
        """
        记录使用量
        
        Args:
            usage_data (Dict[str, Any]): 使用量数据
            operation (str): 操作类型
        """
        # 提取使用量信息
        tokens_input = usage_data.get("prompt_tokens", 0)
        tokens_output = usage_data.get("completion_tokens", 0)
        total_tokens = usage_data.get("total_tokens", tokens_input + tokens_output)
        
        # 计算费用（基于假设价格）
        cost = (total_tokens / 1000) * self.cost_per_1k_tokens
        
        # 更新每日使用量
        self.daily_usage["tokens_input"] += tokens_input
        self.daily_usage["tokens_output"] += tokens_output
        self.daily_usage["total_tokens"] += total_tokens
        self.daily_usage["cost"] += cost
        self.daily_usage["requests"] += 1
        
        # 创建使用记录
        record = UsageRecord(
            timestamp=datetime.now().isoformat(),
            tokens_input=tokens_input,
            tokens_output=tokens_output,
            total_tokens=total_tokens,
            cost=cost,
            operation=operation
        )
        
        # 添加到历史记录
        self.usage_history.append(asdict(record))
        
        logger.info(f"记录使用量 - 输入: {tokens_input}, 输出: {tokens_output}, 费用: ${cost:.4f}")
    
    def check_budget(self) -> bool:
        """
        检查是否超出预算
        
        Returns:
            bool: 是否在预算内
        """
        if self.daily_usage["cost"] > self.daily_budget:
            logger.warning(f"已超出每日预算！当前费用: ${self.daily_usage['cost']:.2f}, 预算: ${self.daily_budget:.2f}")
            return False
        return True
    
    def get_daily_summary(self) -> Dict[str, Any]:
        """
        获取每日使用摘要
        
        Returns:
            Dict[str, Any]: 使用摘要
        """
        return {
            "date": datetime.now().strftime("%Y-%m-%d"),
            "summary": self.daily_usage.copy(),
            "budget_remaining": self.daily_budget - self.daily_usage["cost"],
            "budget_percentage": (self.daily_usage["cost"] / self.daily_budget) * 100 if self.daily_budget > 0 else 0
        }
    
    def reset_daily_usage(self) -> None:
        """重置每日使用量"""
        logger.info(f"重置每日使用量统计，昨日总费用: ${self.daily_usage['cost']:.2f}")
        self.daily_usage = {
            "tokens_input": 0,
            "tokens_output": 0,
            "total_tokens": 0,
            "cost": 0.0,
            "requests": 0
        }

# 使用示例
if __name__ == "__main__":
    # 创建使用量跟踪器
    tracker = DifyUsageTracker(daily_budget=5.0)  # 设置每日预算5美元
    
    # 模拟使用记录
    sample_usages = [
        {"prompt_tokens": 50, "completion_tokens": 150, "total_tokens": 200},
        {"prompt_tokens": 75, "completion_tokens": 225, "total_tokens": 300},
        {"prompt_tokens": 100, "completion_tokens": 300, "total_tokens": 400}
    ]
    
    operations = ["text_generation", "text_classification", "sentiment_analysis"]
    
    # 记录使用量
    for i, (usage, operation) in enumerate(zip(sample_usages, operations)):
        tracker.record_usage(usage, operation)
        
        # 检查预算
        if not tracker.check_budget():
            print("警告：已超出预算！")
            break
    
    # 获取每日摘要
    summary = tracker.get_daily_summary()
    print(f"\n每日使用摘要:")
    print(f"日期: {summary['date']}")
    print(f"总请求数: {summary['summary']['requests']}")
    print(f"总Token数: {summary['summary']['total_tokens']}")
    print(f"总费用: ${summary['summary']['cost']:.4f}")
    print(f"剩余预算: ${summary['budget_remaining']:.2f}")
    print(f"预算使用率: {summary['budget_percentage']:.1f}%")

7. 最佳实践

以下是一些使用Dify的最佳实践：

7.1 代码复用

将常用的Dify调用封装成函数，提高代码复用性。

# -*- coding: utf-8 -*-
"""
Dify最佳实践示例
该示例演示了Dify使用的最佳实践
"""

import os
import json
import time
import logging
from typing import Dict, Any, Optional, List
from abc import ABC, abstractmethod
from functools import wraps
from dotenv import load_dotenv
import requests

# 加载环境变量
load_dotenv()

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

def retry(max_attempts: int = 3, delay: float = 1.0):
    """
    重试装饰器
    
    Args:
        max_attempts (int): 最大尝试次数
        delay (float): 延迟时间（秒）
    """
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_exception = None
            
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_exception = e
                    if attempt < max_attempts - 1:
                        logger.warning(f"第{attempt + 1}次尝试失败: {e}，{delay}秒后重试...")
                        time.sleep(delay)
                        continue
                    else:
                        logger.error(f"所有{max_attempts}次尝试均失败")
                        raise last_exception
            return None
        return wrapper
    return decorator

class DifyBaseClient(ABC):
    """Dify基础客户端抽象类"""
    
    def __init__(self, api_key: str = None, base_url: str = "https://api.dify.ai/v1"):
        """
        初始化基础客户端
        
        Args:
            api_key (str): API密钥
            base_url (str): 基础URL
        """
        self.api_key = api_key or os.getenv("DIFY_API_KEY")
        if not self.api_key:
            raise ValueError("API密钥未设置")
        
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
    
    @abstractmethod
    def _build_request_data(self, **kwargs) -> Dict[str, Any]:
        """
        构建请求数据
        
        Args:
            **kwargs: 请求参数
            
        Returns:
            Dict[str, Any]: 请求数据
        """
        pass
    
    @retry(max_attempts=3, delay=1.0)
    def _make_request(self, endpoint: str, data: Dict[str, Any]) -> Dict[str, Any]:
        """
        发送HTTP请求
        
        Args:
            endpoint (str): API端点
            data (Dict[str, Any]): 请求数据
            
        Returns:
            Dict[str, Any]: 响应数据
        """
        response = requests.post(
            f"{self.base_url}/{endpoint}",
            headers=self.headers,
            json=data,
            timeout=30
        )
        response.raise_for_status()
        return response.json()

class DifyTextGenerationClient(DifyBaseClient):
    """Dify文本生成客户端"""
    
    def _build_request_data(self, prompt: str, **kwargs) -> Dict[str, Any]:
        """构建文本生成请求数据"""
        data = {
            "inputs": {"query": prompt},
            "response_mode": "blocking",
            "user": kwargs.get("user", "default_user")
        }
        
        # 添加可选参数
        if "temperature" in kwargs:
            data.setdefault("parameters", {})["temperature"] = kwargs["temperature"]
        
        return data
    
    def generate_text(self, prompt: str, **kwargs) -> Dict[str, Any]:
        """
        生成文本
        
        Args:
            prompt (str): 提示文本
            **kwargs: 其他参数
            
        Returns:
            Dict[str, Any]: 生成结果
        """
        try:
            data = self._build_request_data(prompt, **kwargs)
            result = self._make_request("completion-messages", data)
            
            return {
                "success": True,
                "text": result.get("answer", ""),
                "usage": result.get("metadata", {}).get("usage", {}),
                "raw_response": result
            }
        except Exception as e:
            logger.error(f"文本生成失败: {e}")
            return {
                "success": False,
                "text": "",
                "error": str(e)
            }

class DifyTextClassificationClient(DifyBaseClient):
    """Dify文本分类客户端"""
    
    def _build_request_data(self, text: str, categories: List[str] = None, **kwargs) -> Dict[str, Any]:
        """构建文本分类请求数据"""
        inputs = {"text": text}
        if categories:
            inputs["categories"] = ", ".join(categories)
            
        return {
            "inputs": inputs,
            "response_mode": "blocking",
            "user": kwargs.get("user", "default_user")
        }
    
    def classify_text(self, text: str, categories: List[str] = None, **kwargs) -> Dict[str, Any]:
        """
        分类文本
        
        Args:
            text (str): 待分类文本
            categories (List[str]): 分类标签
            **kwargs: 其他参数
            
        Returns:
            Dict[str, Any]: 分类结果
        """
        try:
            data = self._build_request_data(text, categories, **kwargs)
            result = self._make_request("completion-messages", data)
            
            return {
                "success": True,
                "category": result.get("answer", ""),
                "raw_response": result
            }
        except Exception as e:
            logger.error(f"文本分类失败: {e}")
            return {
                "success": False,
                "category": "",
                "error": str(e)
            }

# 使用示例
if __name__ == "__main__":
    try:
        # 创建客户端实例
        generator = DifyTextGenerationClient()
        classifier = DifyTextClassificationClient()
        
        # 文本生成示例
        print("=== 文本生成示例 ===")
        gen_result = generator.generate_text(
            "简要介绍人工智能的发展历程",
            temperature=0.7,
            user="demo_user"
        )
        
        if gen_result["success"]:
            print(f"生成文本: {gen_result['text'][:100]}...")
        else:
            print(f"生成失败: {gen_result['error']}")
        
        # 文本分类示例
        print("\n=== 文本分类示例 ===")
        categories = ["科技", "娱乐", "体育", "财经"]
        class_result = classifier.classify_text(
            "最新的人工智能技术在医疗领域的应用",
            categories=categories,
            user="demo_user"
        )
        
        if class_result["success"]:
            print(f"分类结果: {class_result['category']}")
        else:
            print(f"分类失败: {class_result['error']}")
            
    except Exception as e:
        print(f"程序执行出错: {e}")

7.2 错误处理

在调用Dify接口时，添加错误处理逻辑，确保程序的健壮性。

# -*- coding: utf-8 -*-
"""
Dify错误处理最佳实践示例
该示例演示了如何正确处理Dify API调用中的各种错误
"""

import time
import logging
from typing import Dict, Any, Optional
from enum import Enum
import requests

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class DifyErrorType(Enum):
    """Dify错误类型枚举"""
    AUTHENTICATION_ERROR = "authentication_error"
    RATE_LIMIT_ERROR = "rate_limit_error"
    VALIDATION_ERROR = "validation_error"
    SERVER_ERROR = "server_error"
    NETWORK_ERROR = "network_error"
    UNKNOWN_ERROR = "unknown_error"

class DifyException(Exception):
    """Dify异常基类"""
    
    def __init__(self, message: str, error_type: DifyErrorType, status_code: Optional[int] = None):
        super().__init__(message)
        self.error_type = error_type
        self.status_code = status_code

class DifyErrorHandler:
    """Dify错误处理器"""
    
    @staticmethod
    def handle_request_exception(e: requests.exceptions.RequestException) -> DifyException:
        """
        处理请求异常
        
        Args:
            e (requests.exceptions.RequestException): 请求异常
            
        Returns:
            DifyException: Dify异常
        """
        if isinstance(e, requests.exceptions.ConnectionError):
            return DifyException(
                "网络连接错误，请检查网络连接",
                DifyErrorType.NETWORK_ERROR
            )
        elif isinstance(e, requests.exceptions.Timeout):
            return DifyException(
                "请求超时，请稍后重试",
                DifyErrorType.NETWORK_ERROR
            )
        elif isinstance(e, requests.exceptions.HTTPError):
            status_code = e.response.status_code if e.response else None
            if status_code == 401:
                return DifyException(
                    "认证失败，请检查API密钥",
                    DifyErrorType.AUTHENTICATION_ERROR,
                    status_code
                )
            elif status_code == 429:
                return DifyException(
                    "请求频率过高，请稍后重试",
                    DifyErrorType.RATE_LIMIT_ERROR,
                    status_code
                )
            elif status_code >= 500:
                return DifyException(
                    "服务器内部错误，请稍后重试",
                    DifyErrorType.SERVER_ERROR,
                    status_code
                )
            else:
                return DifyException(
                    f"HTTP错误: {status_code}",
                    DifyErrorType.UNKNOWN_ERROR,
                    status_code
                )
        else:
            return DifyException(
                f"请求异常: {str(e)}",
                DifyErrorType.UNKNOWN_ERROR
            )
    
    @staticmethod
    def handle_json_exception(e: Exception) -> DifyException:
        """
        处理JSON解析异常
        
        Args:
            e (Exception): JSON解析异常
            
        Returns:
            DifyException: Dify异常
        """
        return DifyException(
            "响应数据格式错误",
            DifyErrorType.VALIDATION_ERROR
        )
    
    @staticmethod
    def handle_general_exception(e: Exception) -> DifyException:
        """
        处理一般异常
        
        Args:
            e (Exception): 一般异常
            
        Returns:
            DifyException: Dify异常
        """
        return DifyException(
            f"未知错误: {str(e)}",
            DifyErrorType.UNKNOWN_ERROR
        )

class DifyClientWithRetry:
    """带重试机制的Dify客户端"""
    
    def __init__(self, api_key: str, max_retries: int = 3):
        """
        初始化客户端
        
        Args:
            api_key (str): API密钥
            max_retries (int): 最大重试次数
        """
        self.api_key = api_key
        self.max_retries = max_retries
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
        self.error_handler = DifyErrorHandler()
    
    def _should_retry(self, exception: DifyException) -> bool:
        """
        判断是否应该重试
        
        Args:
            exception (DifyException): Dify异常
            
        Returns:
            bool: 是否应该重试
        """
        # 对于网络错误、服务器错误和限流错误进行重试
        retryable_errors = [
            DifyErrorType.NETWORK_ERROR,
            DifyErrorType.SERVER_ERROR,
            DifyErrorType.RATE_LIMIT_ERROR
        ]
        return exception.error_type in retryable_errors
    
    def _calculate_retry_delay(self, attempt: int) -> float:
        """
        计算重试延迟时间
        
        Args:
            attempt (int): 尝试次数
            
        Returns:
            float: 延迟时间（秒）
        """
        # 指数退避算法
        return min(2 ** attempt, 60)  # 最大延迟60秒
    
    def generate_text_with_retry(self, prompt: str) -> Dict[str, Any]:
        """
        带重试机制的文本生成
        
        Args:
            prompt (str): 提示文本
            
        Returns:
            Dict[str, Any]: 生成结果
        """
        last_exception = None
        
        for attempt in range(self.max_retries + 1):
            try:
                # 构建请求数据
                data = {
                    "inputs": {"query": prompt},
                    "response_mode": "blocking",
                    "user": "retry_demo_user"
                }
                
                # 发送请求
                response = requests.post(
                    "https://api.dify.ai/v1/completion-messages",
                    headers=self.headers,
                    json=data,
                    timeout=30
                )
                
                # 检查HTTP状态码
                response.raise_for_status()
                
                # 解析响应
                result = response.json()
                
                logger.info(f"文本生成成功，尝试次数: {attempt + 1}")
                return {
                    "success": True,
                    "text": result.get("answer", ""),
                    "usage": result.get("metadata", {}).get("usage", {}),
                    "attempts": attempt + 1
                }
                
            except requests.exceptions.RequestException as e:
                last_exception = self.error_handler.handle_request_exception(e)
                logger.warning(f"第{attempt + 1}次尝试失败: {last_exception}")
                
                # 如果是最后一次尝试或不应该重试，则抛出异常
                if attempt == self.max_retries or not self._should_retry(last_exception):
                    break
                
                # 计算并等待重试延迟
                delay = self._calculate_retry_delay(attempt)
                logger.info(f"等待{delay}秒后重试...")
                time.sleep(delay)
                
            except Exception as e:
                last_exception = self.error_handler.handle_general_exception(e)
                logger.error(f"第{attempt + 1}次尝试发生未知错误: {last_exception}")
                break
        
        # 所有重试都失败了
        logger.error(f"所有{self.max_retries + 1}次尝试均失败")
        return {
            "success": False,
            "text": "",
            "error": str(last_exception),
            "error_type": last_exception.error_type.value if last_exception else "unknown",
            "attempts": self.max_retries + 1
        }

# 使用示例
if __name__ == "__main__":
    # 创建带重试机制的客户端
    client = DifyClientWithRetry("your-api-key-here", max_retries=3)
    
    # 测试文本生成
    result = client.generate_text_with_retry("请介绍人工智能的发展趋势")
    
    if result["success"]:
        print("文本生成成功:")
        print(f"内容: {result['text']}")
        print(f"尝试次数: {result['attempts']}")
    else:
        print("文本生成失败:")
        print(f"错误: {result['error']}")
        print(f"错误类型: {result['error_type']}")
        print(f"尝试次数: {result['attempts']}")

8. 常见问题

以下是一些常见的问题及其解答：

8.1 如何获取Dify的API密钥？

您可以在Dify的官方网站上注册账号，然后在个人中心获取API密钥。

# -*- coding: utf-8 -*-
"""
Dify API密钥获取指南
该示例演示了如何正确获取和配置Dify API密钥
"""

import os
from dotenv import load_dotenv

# 加载环境变量
load_dotenv()

def get_dify_api_key() -> str:
    """
    获取Dify API密钥
    
    Returns:
        str: API密钥
        
    Raises:
        ValueError: 当未找到API密钥时抛出
    """
    # 方法1: 从环境变量获取
    api_key = os.getenv("DIFY_API_KEY")
    if api_key:
        return api_key
    
    # 方法2: 从配置文件获取
    # 这里可以实现从配置文件读取的逻辑
    
    # 方法3: 从密钥管理服务获取
    # 这里可以实现从云服务密钥管理获取的逻辑
    
    raise ValueError(
        "未找到Dify API密钥。请按以下步骤操作：\n"
        "1. 访问Dify官网 (https://dify.ai) 并注册账号\n"
        "2. 登录后进入个人中心或开发者设置\n"
        "3. 找到API密钥管理页面\n"
        "4. 创建新的API密钥\n"
        "5. 将API密钥添加到环境变量DIFY_API_KEY中"
    )

# 使用示例
if __name__ == "__main__":
    try:
        api_key = get_dify_api_key()
        print("API密钥获取成功")
        # 为了安全，只显示部分密钥
        masked_key = api_key[:4] + "*" * 8 + api_key[-4:] if len(api_key) > 8 else "*" * len(api_key)
        print(f"API密钥: {masked_key}")
    except ValueError as e:
        print(f"错误: {e}")

8.2 Dify的费用如何计算？

Dify的费用通常按使用量计算，具体费用政策请参考Dify的官方网站。

# -*- coding: utf-8 -*-
"""
Dify费用计算示例
该示例演示了如何估算Dify API使用费用
"""

import logging
from typing import Dict, Any
from dataclasses import dataclass

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@dataclass
class PricingModel:
    """定价模型"""
    name: str
    price_per_1k_input_tokens: float
    price_per_1k_output_tokens: float
    free_quota: int = 0

class DifyCostCalculator:
    """Dify费用计算器"""
    
    # 不同定价模型（价格可能已过时，请以官网为准）
    PRICING_MODELS = {
        "free_tier": PricingModel(
            name="免费套餐",
            price_per_1k_input_tokens=0.0,
            price_per_1k_output_tokens=0.0,
            free_quota=100000  # 100K tokens免费额度
        ),
        "pay_as_you_go": PricingModel(
            name="按量付费",
            price_per_1k_input_tokens=0.001,
            price_per_1k_output_tokens=0.002
        ),
        "pro_plan": PricingModel(
            name="专业版",
            price_per_1k_input_tokens=0.0005,
            price_per_1k_output_tokens=0.0015
        )
    }
    
    @classmethod
    def calculate_cost(cls, usage: Dict[str, Any], model_name: str = "pay_as_you_go") -> Dict[str, float]:
        """
        计算使用费用
        
        Args:
            usage (Dict[str, Any]): 使用量数据
            model_name (str): 定价模型名称
            
        Returns:
            Dict[str, float]: 费用计算结果
        """
        if model_name not in cls.PRICING_MODELS:
            raise ValueError(f"未知的定价模型: {model_name}")
        
        model = cls.PRICING_MODELS[model_name]
        input_tokens = usage.get("prompt_tokens", 0)
        output_tokens = usage.get("completion_tokens", 0)
        total_tokens = input_tokens + output_tokens
        
        # 计算费用
        if model_name == "free_tier":
            # 免费套餐逻辑
            remaining_free_quota = max(0, model.free_quota - total_tokens)
            billable_tokens = max(0, total_tokens - model.free_quota)
            input_cost = (billable_tokens * model.price_per_1k_input_tokens) / 1000
            output_cost = (billable_tokens * model.price_per_1k_output_tokens) / 1000
            total_cost = input_cost + output_cost
            
            return {
                "input_tokens": input_tokens,
                "output_tokens": output_tokens,
                "total_tokens": total_tokens,
                "remaining_free_quota": remaining_free_quota,
                "input_cost": input_cost,
                "output_cost": output_cost,
                "total_cost": total_cost
            }
        else:
            # 付费套餐逻辑
            input_cost = (input_tokens * model.price_per_1k_input_tokens) / 1000
            output_cost = (output_tokens * model.price_per_1k_output_tokens) / 1000
            total_cost = input_cost + output_cost
            
            return {
                "input_tokens": input_tokens,
                "output_tokens": output_tokens,
                "total_tokens": total_tokens,
                "input_cost": input_cost,
                "output_cost": output_cost,
                "total_cost": total_cost
            }
    
    @classmethod
    def estimate_monthly_cost(cls, daily_usage: Dict[str, Any], model_name: str = "pay_as_you_go") -> Dict[str, float]:
        """
        估算月度费用
        
        Args:
            daily_usage (Dict[str, Any]): 日均使用量
            model_name (str): 定价模型名称
            
        Returns:
            Dict[str, float]: 月度费用估算
        """
        daily_cost = cls.calculate_cost(daily_usage, model_name)
        monthly_cost = {k: v * 30 for k, v in daily_cost.items() if isinstance(v, (int, float))}
        monthly_cost["model_name"] = model_name
        return monthly_cost

# 使用示例
if __name__ == "__main__":
    # 创建费用计算器
    calculator = DifyCostCalculator()
    
    # 示例使用量数据
    sample_usage = {
        "prompt_tokens": 500,
        "completion_tokens": 1500,
        "total_tokens": 2000
    }
    
    print("=== 费用计算示例 ===")
    
    # 计算不同定价模型的费用
    for model_name in ["free_tier", "pay_as_you_go", "pro_plan"]:
        try:
            cost = calculator.calculate_cost(sample_usage, model_name)
            model = calculator.PRICING_MODELS[model_name]
            
            print(f"\n{model.name}:")
            print(f"  输入Token数: {cost['input_tokens']:,}")
            print(f"  输出Token数: {cost['output_tokens']:,}")
            print(f"  总Token数: {cost['total_tokens']:,}")
            print(f"  输入费用: ${cost['input_cost']:.4f}")
            print(f"  输出费用: ${cost['output_cost']:.4f}")
            print(f"  总费用: ${cost['total_cost']:.4f}")
            
            if model_name == "free_tier":
                print(f"  剩余免费额度: {cost['remaining_free_quota']:,}")
                
        except Exception as e:
            print(f"计算{model_name}费用时出错: {e}")
    
    # 估算月度费用
    print("\n=== 月度费用估算 ===")
    daily_usage = {
        "prompt_tokens": 10000,    # 日均10K输入tokens
        "completion_tokens": 30000 # 日均30K输出tokens
    }
    
    monthly_estimate = calculator.estimate_monthly_cost(daily_usage, "pay_as_you_go")
    print(f"日均使用量:")
    print(f"  输入Token数: {daily_usage['prompt_tokens']:,}")
    print(f"  输出Token数: {daily_usage['completion_tokens']:,}")
    print(f"\n月度费用估算:")
    print(f"  输入费用: ${monthly_estimate['input_cost']:.2f}")
    print(f"  输出费用: ${monthly_estimate['output_cost']:.2f}")
    print(f"  总费用: ${monthly_estimate['total_cost']:.2f}")

8.3 如何处理API调用超时？

当API调用超时时，可以使用重试机制或者调整超时设置。

# -*- coding: utf-8 -*-
"""
Dify API超时处理示例
该示例演示了如何处理API调用超时问题
"""

import time
import logging
from typing import Dict, Any, Optional
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class DifyTimeoutHandler:
    """Dify超时处理器"""
    
    def __init__(self, timeout: int = 30, max_retries: int = 3):
        """
        初始化超时处理器
        
        Args:
            timeout (int): 超时时间（秒）
            max_retries (int): 最大重试次数
        """
        self.timeout = timeout
        self.max_retries = max_retries
    
    def create_session_with_retries(self) -> requests.Session:
        """
        创建带重试机制的会话
        
        Returns:
            requests.Session: 配置好的会话对象
        """
        session = requests.Session()
        
        # 配置重试策略
        retry_strategy = Retry(
            total=self.max_retries,
            backoff_factor=1,  # 退避因子
            status_forcelist=[429, 500, 502, 503, 504],  # 需要重试的状态码
            allowed_methods=["HEAD", "GET", "OPTIONS", "POST"]  # 允许重试的方法
        )
        
        # 创建适配器
        adapter = HTTPAdapter(max_retries=retry_strategy)
        
        # 为http和https设置适配器
        session.mount("http://", adapter)
        session.mount("https://", adapter)
        
        return session
    
    def call_dify_api_with_timeout_handling(self, url: str, headers: Dict[str, str], 
                                          data: Dict[str, Any]) -> Dict[str, Any]:
        """
        调用Dify API并处理超时
        
        Args:
            url (str): API URL
            headers (Dict[str, str]): 请求头
            data (Dict[str, Any]): 请求数据
            
        Returns:
            Dict[str, Any]: API响应数据
            
        Raises:
            Exception: 当所有重试都失败时抛出
        """
        session = self.create_session_with_retries()
        last_exception = None
        
        for attempt in range(self.max_retries + 1):
            try:
                logger.info(f"第{attempt + 1}次尝试调用Dify API")
                
                response = session.post(
                    url,
                    headers=headers,
                    json=data,
                    timeout=self.timeout
                )
                
                response.raise_for_status()
                return response.json()
                
            except requests.exceptions.Timeout as e:
                last_exception = e
                logger.warning(f"第{attempt + 1}次调用超时: {e}")
                
                if attempt < self.max_retries:
                    # 指数退避
                    wait_time = 2 ** attempt
                    logger.info(f"等待{wait_time}秒后重试...")
                    time.sleep(wait_time)
                else:
                    logger.error("所有重试均超时")
                    raise Exception(f"API调用超时，已重试{self.max_retries}次") from e
                    
            except requests.exceptions.RequestException as e:
                last_exception = e
                logger.error(f"第{attempt + 1}次调用发生请求异常: {e}")
                # 对于非超时的请求异常，通常不重试
                raise Exception(f"API调用失败: {e}") from e
                
            except Exception as e:
                last_exception = e
                logger.error(f"第{attempt + 1}次调用发生未知异常: {e}")
                raise Exception(f"API调用发生未知错误: {e}") from e
        
        # 理论上不会执行到这里
        raise Exception("API调用失败") from last_exception

# 使用示例
if __name__ == "__main__":
    # 创建超时处理器
    timeout_handler = DifyTimeoutHandler(timeout=10, max_retries=3)
    
    # 示例API调用
    url = "https://api.dify.ai/v1/completion-messages"
    headers = {
        "Authorization": "Bearer your-api-key",
        "Content-Type": "application/json"
    }
    data = {
        "inputs": {"query": "请写一篇关于人工智能的文章"},
        "response_mode": "blocking",
        "user": "timeout_demo_user"
    }
    
    try:
        print("开始调用Dify API...")
        result = timeout_handler.call_dify_api_with_timeout_handling(url, headers, data)
        print("API调用成功!")
        print(f"响应数据: {result.get('answer', '')[:100]}...")
    except Exception as e:
        print(f"API调用失败: {e}")