Dify应用发布后API调用监控与报警配置完整指南

大家好，我是 HolySheep AI 的技术作者。很多开发者在将 Dify 应用发布上线后，常常面临一个棘手的问题：如何实时掌握 API 调用情况？当调用量异常或出现错误时，能否第一时间收到通知？本文将手把手教你在 Dify 平台上配置 API 监控与报警功能，即使你完全没有相关经验，也能轻松上手。

一、为什么需要API监控与报警？

我曾经在一次重要项目上线时，因为没有配置监控，导致凌晨 API 调用失败整整2小时才被发现。那次经历让我深刻认识到 API 监控的重要性。配置监控与报警后，你可以：

实时了解 API 调用量、响应时间和成功率
及时发现异常流量或攻击行为
在服务异常时第一时间收到通知
通过数据分析优化应用性能

二、前置准备：获取 HolySheep API Key

在开始配置之前，你需要拥有一个支持 Dify 的 API 服务。我推荐使用立即注册 HolySheep AI，这家服务商有以下核心优势：

汇率优势：¥1=$1 无损兑换（官方汇率为 ¥7.3=$1），节省超过 85% 成本
支付便捷：支持微信、支付宝直接充值
极速响应：国内直连延迟低于 50ms
新手友好：注册即送免费调用额度
价格实惠：2026年主流模型价格透明，如 DeepSeek V3.2 仅 $0.42/MToken

注册完成后，在控制台「API Keys」页面创建新的密钥，将密钥保存好（格式示例：YOUR_HOLYSHEEP_API_KEY）。

三、在Dify中发布应用并获取API

步骤1：进入你的应用，点击右上角「发布」按钮，选择「仅API接口」模式。

步骤2：发布成功后，点击「调用API」查看接口地址，默认格式为 https://api.holysheep.ai/v1/chat/completions（这里替换为你实际使用的服务地址）。

步骤3：在请求头中添加认证信息：

Headers 配置示例：
Content-Type: application/json
Authorization: Bearer YOUR_HOLYSHEEP_API_KEY

步骤4：发起一次测试请求，确认 API 可以正常调用。

四、配置API调用监控

4.1 使用 HolySheep 控制台监控

HolySheep AI 提供了完善的用量监控功能。登录后进入「用量统计」页面，你可以看到：

今日/本周/本月调用次数
Token 消耗明细（input/output 分开统计）
平均响应延迟
各模型的调用占比

我个人的使用体验是，HolySheep 的控制台响应速度非常快，数据刷新延迟小于1秒，这对需要实时监控的开发场景非常有帮助。

4.2 通过代码集成自定义监控

如果你需要将监控数据接入自己的系统，可以使用以下 Python 代码实现：

import requests
import time
from datetime import datetime

class DifyMonitor:
    def __init__(self, api_key, base_url="https://api.holysheep.ai/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.metrics = {
            "total_calls": 0,
            "failed_calls": 0,
            "total_latency": 0,
            "errors": []
        }
    
    def call_api(self, app_id, message):
        """调用Dify API并记录监控数据"""
        start_time = time.time()
        self.metrics["total_calls"] += 1
        
        try:
            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers={
                    "Authorization": f"Bearer {self.api_key}",
                    "Content-Type": "application/json"
                },
                json={
                    "model": "dify-app",
                    "messages": [{"role": "user", "content": message}],
                    "extra_headers": {"X-App-ID": app_id}
                },
                timeout=30
            )
            
            latency = (time.time() - start_time) * 1000  # 毫秒
            self.metrics["total_latency"] += latency
            
            if response.status_code != 200:
                self.metrics["failed_calls"] += 1
                self.metrics["errors"].append({
                    "time": datetime.now().isoformat(),
                    "status": response.status_code,
                    "message": response.text
                })
                raise Exception(f"API调用失败: {response.status_code}")
            
            return response.json()
            
        except Exception as e:
            self.metrics["failed_calls"] += 1
            self.metrics["errors"].append({
                "time": datetime.now().isoformat(),
                "error": str(e)
            })
            raise
    
    def get_stats(self):
        """获取监控统计"""
        avg_latency = (
            self.metrics["total_latency"] / self.metrics["total_calls"] 
            if self.metrics["total_calls"] > 0 else 0
        )
        success_rate = (
            (self.metrics["total_calls"] - self.metrics["failed_calls"]) 
            / self.metrics["total_calls"] * 100
            if self.metrics["total_calls"] > 0 else 0
        )
        
        return {
            "总调用次数": self.metrics["total_calls"],
            "失败次数": self.metrics["failed_calls"],
            "成功率": f"{success_rate:.2f}%",
            "平均延迟": f"{avg_latency:.2f}ms",
            "最近错误": self.metrics["errors"][-5:]  # 最近5条错误
        }

使用示例
monitor = DifyMonitor("YOUR_HOLYSHEEP_API_KEY")

try:
    result = monitor.call_api("your-app-id", "你好，请介绍一下自己")
    print("调用成功:", result)
except Exception as e:
    print("调用失败:", str(e))

打印统计
print("监控统计:", monitor.get_stats())

五、配置邮件报警

当 API 调用出现异常时，我们希望第一时间收到通知。下面介绍如何配置基于邮件的报警系统：

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import schedule
import time

class AlertManager:
    def __init__(self, smtp_server, smtp_port, sender_email, sender_password, recipient_emails):
        self.smtp_server = smtp_server
        self.smtp_port = smtp_port
        self.sender_email = sender_email
        self.sender_password = sender_password
        self.recipient_emails = recipient_emails
        self.last_alert_time = {}  # 避免重复报警
    
    def send_alert(self, alert_type, message, severity="warning"):
        """发送报警邮件"""
        now = time.time()
        
        # 5分钟内相同类型的报警不重复发送
        if alert_type in self.last_alert_time:
            if now - self.last_alert_time[alert_type] < 300:
                print(f"跳过重复报警: {alert_type}")
                return
        
        self.last_alert_time[alert_type] = now
        
        subject = f"🚨 [{severity.upper()}] Dify API {alert_type} 报警"
        body = f"""
        API 报警通知
        报警类型：{alert_type}
        严重级别：{severity}
        发生时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
        详细信息：
        {message}
        
        此邮件由 Dify 监控报警系统自动发送
        """
        
        msg = MIMEMultipart("alternative")
        msg["Subject"] = subject
        msg["From"] = self.sender_email
        msg["To"] = ", ".join(self.recipient_emails)
        msg.attach(MIMEText(body, "html"))
        
        try:
            with smtplib.SMTP_SSL(self.smtp_server, self.smtp_port) as server:
                server.login(self.sender_email, self.sender_password)
                server.sendmail(self.sender_email, self.recipient_emails, msg.as_string())
                print(f"报警邮件发送成功: {alert_type}")
        except Exception as e:
            print(f"邮件发送失败: {str(e)}")
    
    def check_and_alert(self, monitor):
        """检查监控数据并触发报警"""
        stats = monitor.get_stats()
        success_rate = float(stats["成功率"].replace("%", ""))
        avg_latency = float(stats["平均延迟"].replace("ms", ""))
        
        # 条件1：成功率低于95%
        if success_rate < 95:
            self.send_alert(
                "成功率异常",
                f"当前成功率: {stats['成功率']}\n总调用: {stats['总调用次数']}\n失败: {stats['失败次数']}",
                "critical"
            )
        
        # 条件2：平均延迟超过2秒
        if avg_latency > 2000:
            self.send_alert(
                "延迟过高",
                f"当前平均延迟: {stats['平均延迟']}\n建议检查网络或服务商状态",
                "warning"
            )
        
        # 条件3：有新的错误记录
        recent_errors = stats.get("最近错误", [])
        if recent_errors:
            error_summary = "\n".join([str(e) for e in recent_errors])
            self.send_alert(
                "API错误",
                f"最近错误记录:\n{error_summary}",
                "error"
            )

使用示例
alert_manager = AlertManager(
    smtp_server="smtp.gmail.com",
    smtp_port=465,
    sender_email="[email protected]",
    sender_password="your-app-password",  # 使用应用专用密码
    recipient_emails=["[email protected]", "[email protected]"]
)

每分钟检查一次
schedule.every(1).minutes.do(lambda: alert_manager.check_and_alert(monitor))

while True:
    schedule.run_pending()
    time.sleep(1)

六、配置钉钉/企业微信Webhook报警

对于团队协作场景，我更推荐使用钉钉或企业微信的 Webhook 进行报警通知，这种方式比邮件更及时：

import json
import requests

class WebhookAlerter:
    def __init__(self, webhook_url, alert_level="warning"):
        self.webhook_url = webhook_url
        self.alert_level = alert_level
    
    def send_dingtalk_alert(self, title, content, is_at_all=False):
        """发送钉钉群消息"""
        message = {
            "msgtype": "markdown",
            "markdown": {
                "title": title,
                "text": f"## 🚨 {title}\n\n{content}\n\n> 来源: Dify API 监控系统"
            },
            "at": {
                "isAtAll": is_at_all
            }
        }
        
        response = requests.post(self.webhook_url, json=message)
        result = response.json()
        
        if result.get("errcode") == 0:
            print(f"钉钉报警发送成功: {title}")
        else:
            print(f"钉钉报警发送失败: {result.get('errmsg')}")
        
        return result
    
    def send_wecom_alert(self, content):
        """发送企业微信群消息"""
        message = {
            "msgtype": "text",
            "text": {
                "content": f"🚨 Dify API 报警\n\n{content}"
            }
        }
        
        response = requests.post(self.webhook_url, json=message)
        result = response.json()
        
        if result.get("errcode") == 0:
            print("企业微信报警发送成功")
        else:
            print(f"企业微信报警发送失败: {result}")
        
        return result

使用示例 - 钉钉
dingtalk = WebhookAlerter("https://oapi.dingtalk.com/robot/send?access_token=YOUR_TOKEN")
dingtalk.send_dingtalk_alert(
    "API成功率低于阈值",
    "**详细信息：**\n- 当前成功率: 92%\n- 阈值: 95%\n- 请及时检查！",
    is_at_all=True
)

使用示例 - 企业微信
wecom = WebhookAlerter("https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=YOUR_KEY")
wecom.send_wecom_alert("检测到API调用延迟超过3秒，请检查服务状态")

七、综合监控报警系统完整示例

将上述所有功能整合为一个完整的监控系统：

import requests
import time
import json
from datetime import datetime
from threading import Thread

class DifyAPIMonitorSystem:
    """Dify API 综合监控报警系统"""
    
    def __init__(self, api_key, holy_api_base="https://api.holysheep.ai/v1"):
        self.api_key = api_key
        self.api_base = holy_api_base
        self.stats = {
            "requests": 0,
            "failures": 0,
            "latencies": [],
            "last_check": None
        }
        self.alert_threshold = {
            "success_rate": 95,      # 成功率阈值(%)
            "max_latency": 3000,      # 最大延迟阈值(ms)
            "max_error_count": 10,    # 最大错误次数
            "check_interval": 60     # 检查间隔(秒)
        }
        self.alert_callbacks = []
    
    def add_alert_callback(self, callback):
        """添加报警回调函数"""
        self.alert_callbacks.append(callback)
    
    def _trigger_alert(self, alert_type, message, severity="warning"):
        """触发所有注册的报警回调"""
        for callback in self.alert_callbacks:
            try:
                callback(alert_type, message, severity)
            except Exception as e:
                print(f"报警回调执行失败: {str(e)}")
    
    def make_request(self, app_id, messages, context_id=None):
        """发起API请求并记录指标"""
        start_time = time.time()
        self.stats["requests"] += 1
        
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": "dify-app",
            "messages": messages,
            "extra_headers": {"X-App-ID": app_id}
        }
        
        if context_id:
            payload["extra_headers"]["X-Context-ID"] = context_id
        
        try:
            response = requests.post(
                f"{self.api_base}/chat/completions",
                headers=headers,
                json=payload,
                timeout=30
            )
            
            latency = (time.time() - start_time) * 1000
            self.stats["latencies"].append(latency)
            
            # 保持最近100条延迟记录
            if len(self.stats["latencies"]) > 100:
                self.stats["latencies"] = self.stats["latencies"][-100:]
            
            if response.status_code != 200:
                self.stats["failures"] += 1
                error_msg = f"HTTP {response.status_code}: {response.text[:200]}"
                self._trigger_alert("request_error", error_msg, "error")
                raise Exception(error_msg)
            
            return response.json()
            
        except requests.exceptions.Timeout:
            self.stats["failures"] += 1
            self._trigger_alert("timeout", "请求超时(30秒)", "critical")
            raise
        except requests.exceptions.ConnectionError as e:
            self.stats["failures"] += 1
            self._trigger_alert("connection_error", f"连接失败: {str(e)}", "critical")
            raise
    
    def get_health_report(self):
        """生成健康报告"""
        total = self.stats["requests"]
        failures = self.stats["failures"]
        
        success_rate = ((total - failures) / total * 100) if total > 0 else 0
        avg_latency = sum(self.stats["latencies"]) / len(self.stats["latencies"]) if self.stats["latencies"] else 0
        
        return {
            "timestamp": datetime.now().isoformat(),
            "total_requests": total,
            "failures": failures,
            "success_rate": f"{success_rate:.2f}%",
            "avg_latency_ms": f"{avg_latency:.2f}",
            "max_latency_ms": f"{max(self.stats['latencies']):.2f}" if self.stats["latencies"] else "0",
            "health_status": "healthy" if success_rate >= self.alert_threshold["success_rate"] else "unhealthy"
        }
    
    def start_monitoring(self):
        """启动后台监控"""
        def monitor_loop():
            while True:
                time.sleep(self.alert_threshold["check_interval"])
                self.stats["last_check"] = datetime.now().isoformat()
                
                report = self.get_health_report()
                success_rate = float(report["success_rate"].replace("%", ""))
                avg_latency = float(report["avg_latency_ms"])
                
                if success_rate < self.alert_threshold["success_rate"]:
                    self._trigger_alert(
                        "success_rate_low",
                        f"成功率: {report['success_rate']}, 低于阈值: {self.alert_threshold['success_rate']}%",
                        "critical"
                    )
                
                if avg_latency > self.alert_threshold["max_latency"]:
                    self._trigger_alert(
                        "latency_high",
                        f"平均延迟: {report['avg_latency_ms']}ms, 超过阈值: {self.alert_threshold['max_latency']}ms",
                        "warning"
                    )
        
        thread = Thread(target=monitor_loop, daemon=True)
        thread.start()
        return self

==================== 使用示例 ====================

1. 初始化监控系统
monitor = DifyAPIMonitorSystem(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    holy_api_base="https://api.holysheep.ai/v1"
)

2. 注册报警回调（钉钉示例）
def dingtalk_alert(alert_type, message, severity):
    webhook_url = "https://oapi.dingtalk.com/robot/send?access_token=YOUR_TOKEN"
    title = f"Dify API {alert_type}"
    payload = {
        "msgtype": "markdown",
        "markdown": {
            "title": title,
            "text": f"## 🚨 [{severity.upper()}] {title}\n\n{message}"
        }
    }
    requests.post(webhook_url, json=payload)

monitor.add_alert_callback(dingtalk_alert)

3. 启动监控
monitor.start_monitoring()

4. 发起API请求
try:
    result = monitor.make_request(
        app_id="your-dify-app-id",
        messages=[{"role": "user", "content": "测试消息"}]
    )
    print("请求成功:", result)
except Exception as e:
    print("请求失败:", str(e))

5. 获取健康报告
print("健康报告:", json.dumps(monitor.get_health_report(), indent=2, ensure_ascii=False))

常见报错排查

错误1：认证失败 (401 Unauthorized)

问题描述：调用 API 时返回 401 错误，提示认证失败。

常见原因：

API Key 填写错误或包含多余空格
使用了错误的 Key 格式（如混淆了不同服务商的 Key）
Key 已过期或被禁用

解决方案：

# 正确配置方式
import os

方式1: 直接赋值（注意不要有多余空格）
api_key = "YOUR_HOLYSHEEP_API_KEY"  # 替换为你的实际Key

方式2: 从环境变量读取（推荐，更安全）
api_key = os.environ.get("HOLYSHEEP_API_KEY")
if not api_key:
    raise ValueError("未设置 HOLYSHEEP_API_KEY 环境变量")

验证Key格式（HolySheep Key 通常以 sk- 开头）
if not api_key.startswith("sk-"):
    print("警告: API Key 格式可能不正确")

headers = {
    "Authorization": f"Bearer {api_key.strip()}",  # 使用 strip() 去除首尾空格
    "Content-Type": "application/json"
}

错误2：连接超时 (Connection Timeout)

问题描述：请求长时间无响应，最终抛出连接超时异常。

常见原因：

网络问题，特别是跨地区访问
API 服务端负载过高
请求体过大导致处理时间长

解决方案：

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

配置重试策略
session = requests.Session()
retry_strategy = Retry(
    total=3,
    backoff_factor=1,  # 重试间隔: 1s, 2s, 4s
    status_forcelist=[429, 500, 502, 503, 504],
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("https://", adapter)

设置合理的超时时间
try:
    response = session.post(
        "https://api.holysheep.ai/v1/chat/completions",
        headers={"Authorization": f"Bearer {api_key}"},
        json={"model": "gpt-4", "messages": [{"role": "user", "content": "你好"}]},
        timeout=(5, 30)  # (连接超时, 读取超时) 单位：秒
    )
    response.raise_for_status()
except requests.exceptions.Timeout:
    print("请求超时，请检查网络连接或联系 HolySheep 客服")
except requests.exceptions.ConnectionError as e:
    print(f"连接错误: {str(e)}")
    # 国内用户建议检查是否需要配置代理

错误3：Token 额度不足 (Rate Limit / Quota Exceeded)

问题描述：返回 429 错误或提示 Quota Exceeded，API 无法正常调用。

常见原因：

当月免费额度已用完
触发了频率限制（QPS 过高）
账户余额不足

解决方案：

import time
import requests

def call_with_rate_limit_handling(api_key, payload, max_retries=5):
    """带频率限制处理的 API 调用"""
    
    for attempt in range(max_retries):
        try:
            response = requests.post(
                "https://api.holysheep.ai/v1/chat/completions",
                headers={
                    "Authorization": f"Bearer {api_key}",
                    "Content-Type": "application/json"
                },
                json=payload,
                timeout=30
            )
            
            if response.status_code == 429:
                # 频率限制，等待后重试
                retry_after = int(response.headers.get("Retry-After", 60))
                print(f"触发频率限制，等待 {retry_after} 秒后重试...")
                time.sleep(retry_after)
                continue
            
            if response.status_code == 400:
                error_data = response.json()
                if "quota" in str(error_data).lower():
                    print("⚠️ 额度不足，请前往 https://www.holysheep.ai/register 充值")
                    # 可选：自动触发报警通知
                    # send_alert("额度不足", "API调用额度已用完")
                raise Exception(f"请求错误: {error_data}")
            
            response.raise_for_status()
            return response.json()
            
        except requests.exceptions.RequestException as e:
            if attempt == max_retries - 1:
                raise Exception(f"重试 {max_retries} 次后仍失败: {str(e)}")
            wait_time = 2 ** attempt
            print(f"第 {attempt + 1} 次尝试失败，{wait_time}秒后重试...")
            time.sleep(wait_time)

使用示例
result = call_with_rate_limit_handling(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    payload={
        "model": "gpt-4",
        "messages": [{"role": "user", "content": "你好"}]
    }
)
print("调用成功:", result)

错误4：应用ID无效 (Invalid App ID)

问题描述：返回错误提示应用不存在或 App ID 无效。

常见原因：

Dify 应用未正确发布
App ID 填写错误
调用了其他环境的应用（如测试环境调用了生产环境）

解决方案：

# 检查 Dify 应用配置
import requests

def verify_dify_app(api_key, base_url, app_id):
    """验证 Dify 应用是否可用"""
    
    # 1. 检查应用是否存在
    try:
        response = requests.get(
            f"{base_url}/apps/{app_id}/info",
            headers={"Authorization": f"Bearer {api_key}"},
            timeout=10
        )
        
        if response.status_code == 404:
            print(f"❌ 应用不存在: {app_id}")
            print("请检查：")
            print("  1. 应用是否已在 Dify 中发布")
            print("  2. App ID 是否正确")
            print("  3. API Key 是否有权访问该应用")
            return False
        
        if response.status_code != 200:
            print(f"API 返回异常: {response.status_code}")
            return False
            
        print(f"✅ 应用验证成功: {response.json()}")
        return True
        
    except Exception as e:
        print(f"验证失败: {str(e)}")
        return False

使用验证函数
verify_dify_app(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1",
    app_id="your-app-id-here"
)

八、最佳实践建议

根据我的实际项目经验，总结以下监控报警配置的最佳实践：

分层报警策略：Warning 级别通知到群聊，Critical 级别电话+短信双通道
阈值动态调整：根据业务高峰期和低谷期设置不同的阈值，避免误报
值班机制：设置工作日和非工作日不同的通知对象
历史数据分析：定期分析报警记录，优化监控策略
演练机制：定期测试报警通道是否畅通

总结

本文详细介绍了 Dify 应用发布后如何配置 API 调用监控与报警系统。通过 HolySheep AI 提供的稳定 API 服务（支持微信/支付宝充值、¥1=$1 无损汇率、国内直连 <50ms 延迟），再配合本文提供的监控代码，你可以轻松实现：

实时掌握 API 调用量和响应时间
成功率低于阈值时自动报警
延迟异常时第一时间通知
历史数据统计分析

完整的监控报警系统虽然初期配置稍复杂，但一旦建立起来，将大大提升系统的可靠性，让你不再担心深夜接到用户投诉电话。

如果你还没有 API 服务商账号，强烈推荐立即注册 HolySheep AI，新用户注册即送免费额度，价格透明（DeepSeek V3.2 仅 $0.42/MToken），支持国内主流支付方式，是国内开发者的不错选择。

👉 免费注册 HolySheep AI，获取首月赠额度

Dify应用发布后API调用监控与报警配置完整指南

一、为什么需要API监控与报警？

二、前置准备：获取 HolySheep API Key

三、在Dify中发布应用并获取API

四、配置API调用监控

4.1 使用 HolySheep 控制台监控

4.2 通过代码集成自定义监控

使用示例

打印统计

五、配置邮件报警

API 报警通知

使用示例

每分钟检查一次

六、配置钉钉/企业微信Webhook报警

使用示例 - 钉钉

使用示例 - 企业微信

七、综合监控报警系统完整示例

==================== 使用示例 ====================

1. 初始化监控系统

2. 注册报警回调（钉钉示例）

3. 启动监控

4. 发起API请求

5. 获取健康报告

常见报错排查

错误1：认证失败 (401 Unauthorized)

方式1: 直接赋值（注意不要有多余空格）

方式2: 从环境变量读取（推荐，更安全）

验证Key格式（HolySheep Key 通常以 sk- 开头）

错误2：连接超时 (Connection Timeout)

配置重试策略

设置合理的超时时间

错误3：Token 额度不足 (Rate Limit / Quota Exceeded)

使用示例

错误4：应用ID无效 (Invalid App ID)

使用验证函数

八、最佳实践建议

总结

相关资源

相关文章

一、为什么需要API监控与报警？

二、前置准备：获取 HolySheep API Key

三、在Dify中发布应用并获取API

四、配置API调用监控

4.1 使用 HolySheep 控制台监控

4.2 通过代码集成自定义监控

使用示例

打印统计

五、配置邮件报警

API 报警通知

使用示例

每分钟检查一次

六、配置钉钉/企业微信Webhook报警

使用示例 - 钉钉

使用示例 - 企业微信

七、综合监控报警系统完整示例

==================== 使用示例 ====================

1. 初始化监控系统

2. 注册报警回调（钉钉示例）

3. 启动监控

4. 发起API请求

5. 获取健康报告

常见报错排查

错误1：认证失败 (401 Unauthorized)

方式1: 直接赋值（注意不要有多余空格）

方式2: 从环境变量读取（推荐，更安全）

验证Key格式（HolySheep Key 通常以 sk- 开头）

错误2：连接超时 (Connection Timeout)

配置重试策略

设置合理的超时时间

错误3：Token 额度不足 (Rate Limit / Quota Exceeded)

使用示例

错误4：应用ID无效 (Invalid App ID)

使用验证函数

八、最佳实践建议

总结

相关资源

相关文章

🔥 推荐使用 HolySheep AI