github/NarratoAI
1
0
Fork 0
mirror of https://github.com/linyqh/NarratoAI.git synced 2025-12-10 09:52:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/main' into pr-199

Browse Source
This commit is contained in:
linyq 2025-10-21 11:40:06 +08:00
commit 75fa931591
31 changed files with 1426 additions and 2097 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@ -31,6 +31,8 @@ NarratoAI 是一个自动化影视解说工具，基于LLM实现文案撰写、
本项目仅供学习和研究使用，不得商用。如需商业授权，请联系作者。
## 最新资讯
- 2025.10.15 发布新版本 0.7.3， 使用 [LiteLLM](https://github.com/BerriAI/litellm) 管理模型供应商
- 2025.09.10 发布新版本 0.7.2， 新增腾讯云tts
- 2025.08.18 发布新版本 0.7.1，支持 **语音克隆** 和 最新大模型
- 2025.05.11 发布新版本 0.6.0，支持 **短剧解说** 和 优化剪辑流程
- 2025.03.06 发布新版本 0.5.2，支持 DeepSeek R1 和 DeepSeek V3 模型进行短剧混剪
@ -44,7 +46,7 @@ NarratoAI 是一个自动化影视解说工具，基于LLM实现文案撰写、
> 1️⃣
> **开发者专属福利：一站式AI平台，注册即送体验金！**
>
> 还在为接入各种AI模型烦恼吗？向您推荐 302.ai，一个企业级的AI资源中心。一次接入，即可调用上百种AI模型，涵盖语言、图像、音视频等，按量付费，极大降低开发成本。
> 还在为接入各种AI模型烦恼吗？向您推荐 302.AI，一个企业级的AI资源中心。一次接入，即可调用上百种AI模型，涵盖语言、图像、音视频等，按量付费，极大降低开发成本。
>
> 通过下方我的专属链接注册，**立获1美元免费体验金**，助您轻松开启AI开发之旅。
>

21
app/config/__init__.py
View File

@ -32,6 +32,26 @@ def __init_logger():
)
return _format
def log_filter(record):
"""过滤不必要的日志消息"""
# 过滤掉模板注册等 DEBUG 级别的噪音日志
ignore_patterns = [
"已注册模板过滤器",
"已注册提示词",
"注册视觉模型提供商",
"注册文本模型提供商",
"LLM服务提供商注册",
"FFmpeg支持的硬件加速器",
"硬件加速测试优先级",
"硬件加速方法",
]
# 如果是 DEBUG 级别且包含过滤模式，则不显示
if record["level"].name == "DEBUG":
return not any(pattern in record["message"] for pattern in ignore_patterns)
return True
logger.remove()
logger.add(
@ -39,6 +59,7 @@ def __init_logger():
level=_lvl,
format=format_record,
colorize=True,
filter=log_filter
)
# logger.add(

16
app/services/llm/__init__.py
View File

@ -21,20 +21,8 @@ from .base import BaseLLMProvider, VisionModelProvider, TextModelProvider
from .validators import OutputValidator, ValidationError
from .exceptions import LLMServiceError, ProviderNotFoundError, ConfigurationError
# 确保提供商在模块导入时被注册
def _ensure_providers_registered():
"""确保所有提供商都已注册"""
try:
# 导入providers模块会自动执行注册
from . import providers
from loguru import logger
logger.debug("LLM服务提供商注册完成")
except Exception as e:
from loguru import logger
logger.error(f"LLM服务提供商注册失败: {str(e)}")
# 自动注册提供商
_ensure_providers_registered()
# 提供商注册由 webui.py:main() 显式调用（见 LLM 提供商注册机制重构）
# 这样更可靠，错误也更容易调试
__all__ = [
'LLMServiceManager',

21
app/services/llm/base.py
View File

@ -65,24 +65,15 @@ class BaseLLMProvider(ABC):
self._validate_model_support()
def _validate_model_support(self):
"""验证模型支持情况"""
from app.config import config
from .exceptions import ModelNotSupportedError
"""验证模型支持情况（宽松模式，仅记录警告）"""
from loguru import logger
# 获取模型验证模式配置
strict_model_validation = config.app.get('strict_model_validation', True)
# LiteLLM 已提供统一的模型验证，传统 provider 使用宽松验证
if self.model_name not in self.supported_models:
if strict_model_validation:
# 严格模式：抛出异常
raise ModelNotSupportedError(self.model_name, self.provider_name)
else:
# 宽松模式：仅记录警告
logger.warning(
f"模型 {self.model_name} 未在供应商 {self.provider_name} 的预定义支持列表中，"
f"但已启用宽松验证模式。支持的模型列表: {self.supported_models}"
)
logger.warning(
f"模型 {self.model_name} 未在供应商 {self.provider_name} 的预定义支持列表中。"
f"支持的模型列表: {self.supported_models}"
)
def _initialize(self):
"""初始化提供商特定设置，子类可重写"""

2
app/services/llm/config_validator.py
View File

@ -214,7 +214,7 @@ class LLMConfigValidator:
"建议为每个提供商配置base_url以提高稳定性",
"定期检查模型名称是否为最新版本",
"建议配置多个提供商作为备用方案",
"如果使用新发布的模型遇到MODEL_NOT_SUPPORTED错误，可以设置 strict_model_validation = false 启用宽松验证模式"
"推荐使用 LiteLLM 作为统一接口，支持 100+ providers"
]
}

440
app/services/llm/litellm_provider.py Normal file
View File

@ -0,0 +1,440 @@
"""
LiteLLM 统一提供商实现
使用 LiteLLM 库提供统一的 LLM 接口，支持 100+ providers
包括 OpenAI, Anthropic, Gemini, Qwen, DeepSeek, SiliconFlow 等
"""
import asyncio
import base64
import io
from typing import List, Dict, Any, Optional, Union
from pathlib import Path
import PIL.Image
from loguru import logger
try:
import litellm
from litellm import acompletion, completion
from litellm.exceptions import (
AuthenticationError as LiteLLMAuthError,
RateLimitError as LiteLLMRateLimitError,
BadRequestError as LiteLLMBadRequestError,
APIError as LiteLLMAPIError
)
except ImportError:
logger.error("LiteLLM 未安装。请运行: pip install litellm")
raise
from .base import VisionModelProvider, TextModelProvider
from .exceptions import (
APICallError,
AuthenticationError,
RateLimitError,
ContentFilterError
)
# 配置 LiteLLM 全局设置
def configure_litellm():
"""配置 LiteLLM 全局参数"""
from app.config import config
# 设置重试次数
litellm.num_retries = config.app.get('llm_max_retries', 3)
# 设置默认超时
litellm.request_timeout = config.app.get('llm_text_timeout', 180)
# 启用详细日志（开发环境）
# litellm.set_verbose = True
logger.info(f"LiteLLM 配置完成: retries={litellm.num_retries}, timeout={litellm.request_timeout}s")
# 初始化配置
configure_litellm()
class LiteLLMVisionProvider(VisionModelProvider):
"""使用 LiteLLM 的统一视觉模型提供商"""
@property
def provider_name(self) -> str:
# 从 model_name 中提取 provider 名称（如 "gemini/gemini-2.0-flash"）
if "/" in self.model_name:
return self.model_name.split("/")[0]
return "litellm"
@property
def supported_models(self) -> List[str]:
# LiteLLM 支持 100+ providers 和数百个模型，无法全部列举
# 返回空列表表示跳过预定义列表检查，由 LiteLLM 在实际调用时验证
return []
def _validate_model_support(self):
"""
重写模型验证逻辑
对于 LiteLLM，我们不做预定义列表检查，因为：
1. LiteLLM 支持 100+ providers 和数百个模型，无法全部列举
2. LiteLLM 会在实际调用时进行模型验证
3. 如果模型不支持，LiteLLM 会返回清晰的错误信息
这里只做基本的格式验证（可选）
"""
from loguru import logger
# 可选：检查模型名称格式（provider/model）
if "/" not in self.model_name:
logger.debug(
f"LiteLLM 模型名称 '{self.model_name}' 未包含 provider 前缀，"
f"LiteLLM 将尝试自动推断。建议使用 'provider/model' 格式，如 'gemini/gemini-2.5-flash'"
)
# 不抛出异常，让 LiteLLM 在实际调用时验证
logger.debug(f"LiteLLM 视觉模型已配置: {self.model_name}")
def _initialize(self):
"""初始化 LiteLLM 特定设置"""
# 设置 API key 到环境变量（LiteLLM 会自动读取）
import os
# 根据 model_name 确定需要设置哪个 API key
provider = self.provider_name.lower()
# 映射 provider 到环境变量名
env_key_mapping = {
"gemini": "GEMINI_API_KEY",
"google": "GEMINI_API_KEY",
"openai": "OPENAI_API_KEY",
"qwen": "QWEN_API_KEY",
"dashscope": "DASHSCOPE_API_KEY",
"siliconflow": "SILICONFLOW_API_KEY",
"anthropic": "ANTHROPIC_API_KEY",
"claude": "ANTHROPIC_API_KEY"
}
env_var = env_key_mapping.get(provider, f"{provider.upper()}_API_KEY")
if self.api_key and env_var:
os.environ[env_var] = self.api_key
logger.debug(f"设置环境变量: {env_var}")
# 如果提供了 base_url，设置到 LiteLLM
if self.base_url:
# LiteLLM 支持通过 api_base 参数设置自定义 URL
self._api_base = self.base_url
logger.debug(f"使用自定义 API base URL: {self.base_url}")
async def analyze_images(self,
images: List[Union[str, Path, PIL.Image.Image]],
prompt: str,
batch_size: int = 10,
**kwargs) -> List[str]:
"""
使用 LiteLLM 分析图片
Args:
images: 图片路径列表或PIL图片对象列表
prompt: 分析提示词
batch_size: 批处理大小
**kwargs: 其他参数
Returns:
分析结果列表
"""
logger.info(f"开始使用 LiteLLM ({self.model_name}) 分析 {len(images)} 张图片")
# 预处理图片
processed_images = self._prepare_images(images)
# 分批处理
results = []
for i in range(0, len(processed_images), batch_size):
batch = processed_images[i:i + batch_size]
logger.info(f"处理第 {i//batch_size + 1} 批，共 {len(batch)} 张图片")
try:
result = await self._analyze_batch(batch, prompt, **kwargs)
results.append(result)
except Exception as e:
logger.error(f"批次 {i//batch_size + 1} 处理失败: {str(e)}")
results.append(f"批次处理失败: {str(e)}")
return results
async def _analyze_batch(self, batch: List[PIL.Image.Image], prompt: str, **kwargs) -> str:
"""分析一批图片"""
# 构建 LiteLLM 格式的消息
content = [{"type": "text", "text": prompt}]
# 添加图片（使用 base64 编码）
for img in batch:
base64_image = self._image_to_base64(img)
content.append({
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{base64_image}"
}
})
messages = [{
"role": "user",
"content": content
}]
# 调用 LiteLLM
try:
# 准备参数
completion_kwargs = {
"model": self.model_name,
"messages": messages,
"temperature": kwargs.get("temperature", 1.0),
"max_tokens": kwargs.get("max_tokens", 4000)
}
# 如果有自定义 base_url，添加 api_base 参数
if hasattr(self, '_api_base'):
completion_kwargs["api_base"] = self._api_base
response = await acompletion(**completion_kwargs)
if response.choices and len(response.choices) > 0:
content = response.choices[0].message.content
logger.debug(f"LiteLLM 调用成功，消耗 tokens: {response.usage.total_tokens if response.usage else 'N/A'}")
return content
else:
raise APICallError("LiteLLM 返回空响应")
except LiteLLMAuthError as e:
logger.error(f"LiteLLM 认证失败: {str(e)}")
raise AuthenticationError()
except LiteLLMRateLimitError as e:
logger.error(f"LiteLLM 速率限制: {str(e)}")
raise RateLimitError()
except LiteLLMBadRequestError as e:
error_msg = str(e)
if "SAFETY" in error_msg.upper() or "content_filter" in error_msg.lower():
raise ContentFilterError(f"内容被安全过滤器阻止: {error_msg}")
logger.error(f"LiteLLM 请求错误: {error_msg}")
raise APICallError(f"请求错误: {error_msg}")
except LiteLLMAPIError as e:
logger.error(f"LiteLLM API 错误: {str(e)}")
raise APICallError(f"API 错误: {str(e)}")
except Exception as e:
logger.error(f"LiteLLM 调用失败: {str(e)}")
raise APICallError(f"调用失败: {str(e)}")
def _image_to_base64(self, img: PIL.Image.Image) -> str:
"""将PIL图片转换为base64编码"""
img_buffer = io.BytesIO()
img.save(img_buffer, format='JPEG', quality=85)
img_bytes = img_buffer.getvalue()
return base64.b64encode(img_bytes).decode('utf-8')
async def _make_api_call(self, payload: Dict[str, Any]) -> Dict[str, Any]:
"""兼容基类接口（实际使用 LiteLLM SDK）"""
pass
class LiteLLMTextProvider(TextModelProvider):
"""使用 LiteLLM 的统一文本生成提供商"""
@property
def provider_name(self) -> str:
# 从 model_name 中提取 provider 名称
if "/" in self.model_name:
return self.model_name.split("/")[0]
# 尝试从模型名称推断 provider
model_lower = self.model_name.lower()
if "gpt" in model_lower:
return "openai"
elif "claude" in model_lower:
return "anthropic"
elif "gemini" in model_lower:
return "gemini"
elif "qwen" in model_lower:
return "qwen"
elif "deepseek" in model_lower:
return "deepseek"
return "litellm"
@property
def supported_models(self) -> List[str]:
# LiteLLM 支持 100+ providers 和数百个模型，无法全部列举
# 返回空列表表示跳过预定义列表检查，由 LiteLLM 在实际调用时验证
return []
def _validate_model_support(self):
"""
重写模型验证逻辑
对于 LiteLLM，我们不做预定义列表检查，因为：
1. LiteLLM 支持 100+ providers 和数百个模型，无法全部列举
2. LiteLLM 会在实际调用时进行模型验证
3. 如果模型不支持，LiteLLM 会返回清晰的错误信息
这里只做基本的格式验证（可选）
"""
from loguru import logger
# 可选：检查模型名称格式（provider/model）
if "/" not in self.model_name:
logger.debug(
f"LiteLLM 模型名称 '{self.model_name}' 未包含 provider 前缀，"
f"LiteLLM 将尝试自动推断。建议使用 'provider/model' 格式，如 'gemini/gemini-2.5-flash'"
)
# 不抛出异常，让 LiteLLM 在实际调用时验证
logger.debug(f"LiteLLM 文本模型已配置: {self.model_name}")
def _initialize(self):
"""初始化 LiteLLM 特定设置"""
import os
# 根据 model_name 确定需要设置哪个 API key
provider = self.provider_name.lower()
# 映射 provider 到环境变量名
env_key_mapping = {
"gemini": "GEMINI_API_KEY",
"google": "GEMINI_API_KEY",
"openai": "OPENAI_API_KEY",
"qwen": "QWEN_API_KEY",
"dashscope": "DASHSCOPE_API_KEY",
"siliconflow": "SILICONFLOW_API_KEY",
"deepseek": "DEEPSEEK_API_KEY",
"anthropic": "ANTHROPIC_API_KEY",
"claude": "ANTHROPIC_API_KEY",
"moonshot": "MOONSHOT_API_KEY"
}
env_var = env_key_mapping.get(provider, f"{provider.upper()}_API_KEY")
if self.api_key and env_var:
os.environ[env_var] = self.api_key
logger.debug(f"设置环境变量: {env_var}")
# 如果提供了 base_url，保存用于后续调用
if self.base_url:
self._api_base = self.base_url
logger.debug(f"使用自定义 API base URL: {self.base_url}")
async def generate_text(self,
prompt: str,
system_prompt: Optional[str] = None,
temperature: float = 1.0,
max_tokens: Optional[int] = None,
response_format: Optional[str] = None,
**kwargs) -> str:
"""
使用 LiteLLM 生成文本
Args:
prompt: 用户提示词
system_prompt: 系统提示词
temperature: 生成温度
max_tokens: 最大token数
response_format: 响应格式 ('json' 或 None)
**kwargs: 其他参数
Returns:
生成的文本内容
"""
# 构建消息列表
messages = self._build_messages(prompt, system_prompt)
# 准备参数
completion_kwargs = {
"model": self.model_name,
"messages": messages,
"temperature": temperature
}
if max_tokens:
completion_kwargs["max_tokens"] = max_tokens
# 处理 JSON 格式输出
# LiteLLM 会自动处理不同 provider 的 JSON mode 差异
if response_format == "json":
try:
completion_kwargs["response_format"] = {"type": "json_object"}
except Exception as e:
# 如果不支持，在提示词中添加约束
logger.warning(f"模型可能不支持 response_format，将在提示词中添加 JSON 约束: {str(e)}")
messages[-1]["content"] += "\n\n请确保输出严格的JSON格式，不要包含任何其他文字或标记。"
# 如果有自定义 base_url，添加 api_base 参数
if hasattr(self, '_api_base'):
completion_kwargs["api_base"] = self._api_base
try:
# 调用 LiteLLM（自动重试）
response = await acompletion(**completion_kwargs)
if response.choices and len(response.choices) > 0:
content = response.choices[0].message.content
# 清理可能的 markdown 代码块（针对不支持 JSON mode 的模型）
if response_format == "json" and "response_format" not in completion_kwargs:
content = self._clean_json_output(content)
logger.debug(f"LiteLLM 调用成功，消耗 tokens: {response.usage.total_tokens if response.usage else 'N/A'}")
return content
else:
raise APICallError("LiteLLM 返回空响应")
except LiteLLMAuthError as e:
logger.error(f"LiteLLM 认证失败: {str(e)}")
raise AuthenticationError()
except LiteLLMRateLimitError as e:
logger.error(f"LiteLLM 速率限制: {str(e)}")
raise RateLimitError()
except LiteLLMBadRequestError as e:
error_msg = str(e)
# 处理不支持 response_format 的情况
if "response_format" in error_msg and response_format == "json":
logger.warning(f"模型不支持 response_format，重试不带格式约束的请求")
completion_kwargs.pop("response_format", None)
messages[-1]["content"] += "\n\n请确保输出严格的JSON格式，不要包含任何其他文字或标记。"
# 重试
response = await acompletion(**completion_kwargs)
if response.choices and len(response.choices) > 0:
content = response.choices[0].message.content
content = self._clean_json_output(content)
return content
else:
raise APICallError("LiteLLM 返回空响应")
# 检查是否是安全过滤
if "SAFETY" in error_msg.upper() or "content_filter" in error_msg.lower():
raise ContentFilterError(f"内容被安全过滤器阻止: {error_msg}")
logger.error(f"LiteLLM 请求错误: {error_msg}")
raise APICallError(f"请求错误: {error_msg}")
except LiteLLMAPIError as e:
logger.error(f"LiteLLM API 错误: {str(e)}")
raise APICallError(f"API 错误: {str(e)}")
except Exception as e:
logger.error(f"LiteLLM 调用失败: {str(e)}")
raise APICallError(f"调用失败: {str(e)}")
def _clean_json_output(self, output: str) -> str:
"""清理JSON输出，移除markdown标记等"""
import re
# 移除可能的markdown代码块标记
output = re.sub(r'^```json\s*', '', output, flags=re.MULTILINE)
output = re.sub(r'^```\s*$', '', output, flags=re.MULTILINE)
output = re.sub(r'^```.*$', '', output, flags=re.MULTILINE)
# 移除前后空白字符
output = output.strip()
return output
async def _make_api_call(self, payload: Dict[str, Any]) -> Dict[str, Any]:
"""兼容基类接口（实际使用 LiteLLM SDK）"""
pass

57
app/services/llm/manager.py
View File

@ -37,16 +37,33 @@ class LLMServiceManager:
cls._text_providers[name.lower()] = provider_class
logger.debug(f"注册文本模型提供商: {name}")
# _ensure_providers_registered() 方法已移除
# 现在使用显式注册机制（见 webui.py:main()）
# 如需检查注册状态，使用 is_registered() 方法
@classmethod
def _ensure_providers_registered(cls):
"""确保提供商已注册"""
try:
# 如果没有注册的提供商，强制导入providers模块
if not cls._vision_providers or not cls._text_providers:
from . import providers
logger.debug("LLMServiceManager强制注册提供商")
except Exception as e:
logger.error(f"LLMServiceManager确保提供商注册时发生错误: {str(e)}")
def is_registered(cls) -> bool:
"""
检查是否已注册提供商
Returns:
bool: 如果已注册任何提供商则返回 True
"""
return len(cls._text_providers) > 0 or len(cls._vision_providers) > 0
@classmethod
def get_registered_providers_info(cls) -> dict:
"""
获取已注册提供商的信息
Returns:
dict: 包含视觉和文本提供商列表的字典
"""
return {
"vision_providers": list(cls._vision_providers.keys()),
"text_providers": list(cls._text_providers.keys())
}
@classmethod
def get_vision_provider(cls, provider_name: Optional[str] = None) -> VisionModelProvider:
@ -63,8 +80,12 @@ class LLMServiceManager:
ProviderNotFoundError: 提供商未找到
ConfigurationError: 配置错误
"""
# 确保提供商已注册
cls._ensure_providers_registered()
# 检查提供商是否已注册
if not cls.is_registered():
raise ConfigurationError(
"LLM 提供商未注册。请确保在应用启动时调用了 register_all_providers()。"
f"\n当前已注册的提供商: {cls.get_registered_providers_info()}"
)
# 确定提供商名称
if not provider_name:
@ -127,8 +148,12 @@ class LLMServiceManager:
ProviderNotFoundError: 提供商未找到
ConfigurationError: 配置错误
"""
# 确保提供商已注册
cls._ensure_providers_registered()
# 检查提供商是否已注册
if not cls.is_registered():
raise ConfigurationError(
"LLM 提供商未注册。请确保在应用启动时调用了 register_all_providers()。"
f"\n当前已注册的提供商: {cls.get_registered_providers_info()}"
)
# 确定提供商名称
if not provider_name:
@ -136,13 +161,19 @@ class LLMServiceManager:
else:
provider_name = provider_name.lower()
logger.debug(f"获取文本模型提供商: {provider_name}")
logger.debug(f"已注册的文本提供商: {list(cls._text_providers.keys())}")
# 检查缓存
cache_key = f"text_{provider_name}"
if cache_key in cls._text_instance_cache:
logger.debug(f"从缓存获取提供商实例: {provider_name}")
return cls._text_instance_cache[cache_key]
# 检查提供商是否已注册
if provider_name not in cls._text_providers:
logger.error(f"提供商未注册: {provider_name}")
logger.error(f"已注册的提供商列表: {list(cls._text_providers.keys())}")
raise ProviderNotFoundError(provider_name)
# 获取配置

17
app/services/llm/migration_adapter.py
View File

@ -16,21 +16,8 @@ from .exceptions import LLMServiceError
# 导入新的提示词管理系统
from app.services.prompts import PromptManager
# 确保提供商已注册
def _ensure_providers_registered():
"""确保所有提供商都已注册"""
try:
from .manager import LLMServiceManager
# 检查是否有已注册的提供商
if not LLMServiceManager.list_text_providers() or not LLMServiceManager.list_vision_providers():
# 如果没有注册的提供商，强制导入providers模块
from . import providers
logger.debug("迁移适配器强制注册LLM服务提供商")
except Exception as e:
logger.error(f"迁移适配器确保LLM服务提供商注册时发生错误: {str(e)}")
# 在模块加载时确保提供商已注册
_ensure_providers_registered()
# 提供商注册由 webui.py:main() 显式调用（见 LLM 提供商注册机制重构）
# 这样更可靠，错误也更容易调试
def _run_async_safely(coro_func, *args, **kwargs):

62
app/services/llm/providers/__init__.py
View File

@ -2,46 +2,42 @@
大模型服务提供商实现
包含各种大模型服务提供商的具体实现
推荐使用 LiteLLM 统一接口（支持 100+ providers）
"""
from .gemini_provider import GeminiVisionProvider, GeminiTextProvider
from .gemini_openai_provider import GeminiOpenAIVisionProvider, GeminiOpenAITextProvider
from .openai_provider import OpenAITextProvider
from .qwen_provider import QwenVisionProvider, QwenTextProvider
from .deepseek_provider import DeepSeekTextProvider
from .siliconflow_provider import SiliconflowVisionProvider, SiliconflowTextProvider
# 不在模块顶部导入 provider 类，避免循环依赖
# 所有导入都在 register_all_providers() 函数内部进行
# 自动注册所有提供商
from ..manager import LLMServiceManager
def register_all_providers():
"""注册所有提供商"""
# 注册视觉模型提供商
LLMServiceManager.register_vision_provider('gemini', GeminiVisionProvider)
LLMServiceManager.register_vision_provider('gemini(openai)', GeminiOpenAIVisionProvider)
LLMServiceManager.register_vision_provider('qwenvl', QwenVisionProvider)
LLMServiceManager.register_vision_provider('siliconflow', SiliconflowVisionProvider)
"""
注册所有提供商
# 注册文本模型提供商
LLMServiceManager.register_text_provider('gemini', GeminiTextProvider)
LLMServiceManager.register_text_provider('gemini(openai)', GeminiOpenAITextProvider)
LLMServiceManager.register_text_provider('openai', OpenAITextProvider)
LLMServiceManager.register_text_provider('qwen', QwenTextProvider)
LLMServiceManager.register_text_provider('deepseek', DeepSeekTextProvider)
LLMServiceManager.register_text_provider('siliconflow', SiliconflowTextProvider)
v0.8.0 变更：只注册 LiteLLM 统一接口
- 移除了旧的单独 provider 实现 (gemini, openai, qwen, deepseek, siliconflow)
- LiteLLM 支持 100+ providers，无需单独实现
"""
# 在函数内部导入，避免循环依赖
from ..manager import LLMServiceManager
from loguru import logger
# 自动注册
register_all_providers()
# 只导入 LiteLLM provider
from ..litellm_provider import LiteLLMVisionProvider, LiteLLMTextProvider
logger.info("🔧 开始注册 LLM 提供商...")
# ===== 注册 LiteLLM 统一接口 =====
# LiteLLM 支持 100+ providers（OpenAI, Gemini, Qwen, DeepSeek, SiliconFlow, 等）
LLMServiceManager.register_vision_provider('litellm', LiteLLMVisionProvider)
LLMServiceManager.register_text_provider('litellm', LiteLLMTextProvider)
logger.info("✅ LiteLLM 提供商注册完成（支持 100+ providers）")
# 导出注册函数
__all__ = [
'GeminiVisionProvider',
'GeminiTextProvider',
'GeminiOpenAIVisionProvider',
'GeminiOpenAITextProvider',
'OpenAITextProvider',
'QwenVisionProvider',
'QwenTextProvider',
'DeepSeekTextProvider',
'SiliconflowVisionProvider',
'SiliconflowTextProvider',
'register_all_providers',
]
# 注意: Provider 类不再从此模块导出，因为它们只在注册函数内部使用
# 这样做是为了避免循环依赖问题，所有 provider 类的导入都延迟到注册时进行

157
app/services/llm/providers/deepseek_provider.py
View File

@ -1,157 +0,0 @@
"""
DeepSeek API提供商实现
支持DeepSeek的文本生成模型
"""
import asyncio
from typing import List, Dict, Any, Optional
from openai import OpenAI, BadRequestError
from loguru import logger
from ..base import TextModelProvider
from ..exceptions import APICallError
class DeepSeekTextProvider(TextModelProvider):
"""DeepSeek文本生成提供商"""
@property
def provider_name(self) -> str:
return "deepseek"
@property
def supported_models(self) -> List[str]:
return [
"deepseek-chat",
"deepseek-reasoner",
"deepseek-r1",
"deepseek-v3"
]
def _initialize(self):
"""初始化DeepSeek客户端"""
if not self.base_url:
self.base_url = "https://api.deepseek.com"
self.client = OpenAI(
api_key=self.api_key,
base_url=self.base_url
)
async def generate_text(self,
prompt: str,
system_prompt: Optional[str] = None,
temperature: float = 1.0,
max_tokens: Optional[int] = None,
response_format: Optional[str] = None,
**kwargs) -> str:
"""
使用DeepSeek API生成文本
Args:
prompt: 用户提示词
system_prompt: 系统提示词
temperature: 生成温度
max_tokens: 最大token数
response_format: 响应格式 ('json' 或 None)
**kwargs: 其他参数
Returns:
生成的文本内容
"""
# 构建消息列表
messages = self._build_messages(prompt, system_prompt)
# 构建请求参数
request_params = {
"model": self.model_name,
"messages": messages,
"temperature": temperature
}
if max_tokens:
request_params["max_tokens"] = max_tokens
# 处理JSON格式输出
# DeepSeek R1 和 V3 不支持 response_format=json_object
if response_format == "json":
if self._supports_response_format():
request_params["response_format"] = {"type": "json_object"}
else:
# 对于不支持response_format的模型，在提示词中添加约束
messages[-1]["content"] += "\n\n请确保输出严格的JSON格式，不要包含任何其他文字或标记。"
try:
# 发送API请求
response = await asyncio.to_thread(
self.client.chat.completions.create,
**request_params
)
# 提取生成的内容
if response.choices and len(response.choices) > 0:
content = response.choices[0].message.content
# 对于不支持response_format的模型，清理输出
if response_format == "json" and not self._supports_response_format():
content = self._clean_json_output(content)
logger.debug(f"DeepSeek API调用成功，消耗tokens: {response.usage.total_tokens if response.usage else 'N/A'}")
return content
else:
raise APICallError("DeepSeek API返回空响应")
except BadRequestError as e:
# 处理不支持response_format的情况
if "response_format" in str(e) and response_format == "json":
logger.warning(f"DeepSeek模型 {self.model_name} 不支持response_format，重试不带格式约束的请求")
request_params.pop("response_format", None)
messages[-1]["content"] += "\n\n请确保输出严格的JSON格式，不要包含任何其他文字或标记。"
response = await asyncio.to_thread(
self.client.chat.completions.create,
**request_params
)
if response.choices and len(response.choices) > 0:
content = response.choices[0].message.content
content = self._clean_json_output(content)
return content
else:
raise APICallError("DeepSeek API返回空响应")
else:
raise APICallError(f"DeepSeek API请求失败: {str(e)}")
except Exception as e:
logger.error(f"DeepSeek API调用失败: {str(e)}")
raise APICallError(f"DeepSeek API调用失败: {str(e)}")
def _supports_response_format(self) -> bool:
"""检查模型是否支持response_format参数"""
# DeepSeek R1 和 V3 不支持 response_format=json_object
unsupported_models = [
"deepseek-reasoner",
"deepseek-r1",
"deepseek-v3"
]
return not any(unsupported in self.model_name.lower() for unsupported in unsupported_models)
def _clean_json_output(self, output: str) -> str:
"""清理JSON输出，移除markdown标记等"""
import re
# 移除可能的markdown代码块标记
output = re.sub(r'^```json\s*', '', output, flags=re.MULTILINE)
output = re.sub(r'^```\s*$', '', output, flags=re.MULTILINE)
output = re.sub(r'^```.*$', '', output, flags=re.MULTILINE)
# 移除前后空白字符
output = output.strip()
return output
async def _make_api_call(self, payload: Dict[str, Any]) -> Dict[str, Any]:
"""执行API调用 - 由于使用OpenAI SDK，这个方法主要用于兼容基类"""
pass

237
app/services/llm/providers/gemini_openai_provider.py
View File

@ -1,237 +0,0 @@
"""
OpenAI兼容的Gemini API提供商实现
使用OpenAI兼容接口调用Gemini服务，支持视觉分析和文本生成
"""
import asyncio
import base64
import io
from typing import List, Dict, Any, Optional, Union
from pathlib import Path
import PIL.Image
from openai import OpenAI
from loguru import logger
from ..base import VisionModelProvider, TextModelProvider
from ..exceptions import APICallError
class GeminiOpenAIVisionProvider(VisionModelProvider):
"""OpenAI兼容的Gemini视觉模型提供商"""
@property
def provider_name(self) -> str:
return "gemini(openai)"
@property
def supported_models(self) -> List[str]:
return [
"gemini-2.5-flash",
"gemini-2.0-flash-lite",
"gemini-2.0-flash",
"gemini-1.5-pro",
"gemini-1.5-flash"
]
def _initialize(self):
"""初始化OpenAI兼容的Gemini客户端"""
if not self.base_url:
self.base_url = "https://generativelanguage.googleapis.com/v1beta/openai"
self.client = OpenAI(
api_key=self.api_key,
base_url=self.base_url
)
async def analyze_images(self,
images: List[Union[str, Path, PIL.Image.Image]],
prompt: str,
batch_size: int = 10,
**kwargs) -> List[str]:
"""
使用OpenAI兼容的Gemini API分析图片
Args:
images: 图片列表
prompt: 分析提示词
batch_size: 批处理大小
**kwargs: 其他参数
Returns:
分析结果列表
"""
logger.info(f"开始分析 {len(images)} 张图片，使用OpenAI兼容Gemini代理")
# 预处理图片
processed_images = self._prepare_images(images)
# 分批处理
results = []
for i in range(0, len(processed_images), batch_size):
batch = processed_images[i:i + batch_size]
logger.info(f"处理第 {i//batch_size + 1} 批，共 {len(batch)} 张图片")
try:
result = await self._analyze_batch(batch, prompt)
results.append(result)
except Exception as e:
logger.error(f"批次 {i//batch_size + 1} 处理失败: {str(e)}")
results.append(f"批次处理失败: {str(e)}")
return results
async def _analyze_batch(self, batch: List[PIL.Image.Image], prompt: str) -> str:
"""分析一批图片"""
# 构建OpenAI格式的消息内容
content = [{"type": "text", "text": prompt}]
# 添加图片
for img in batch:
base64_image = self._image_to_base64(img)
content.append({
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{base64_image}"
}
})
# 构建消息
messages = [{
"role": "user",
"content": content
}]
# 调用API
response = await asyncio.to_thread(
self.client.chat.completions.create,
model=self.model_name,
messages=messages,
max_tokens=4000,
temperature=1.0
)
if response.choices and len(response.choices) > 0:
return response.choices[0].message.content
else:
raise APICallError("OpenAI兼容Gemini API返回空响应")
def _image_to_base64(self, img: PIL.Image.Image) -> str:
"""将PIL图片转换为base64编码"""
img_buffer = io.BytesIO()
img.save(img_buffer, format='JPEG', quality=85)
img_bytes = img_buffer.getvalue()
return base64.b64encode(img_bytes).decode('utf-8')
async def _make_api_call(self, payload: Dict[str, Any]) -> Dict[str, Any]:
"""执行API调用 - 由于使用OpenAI SDK，这个方法主要用于兼容基类"""
pass
class GeminiOpenAITextProvider(TextModelProvider):
"""OpenAI兼容的Gemini文本生成提供商"""
@property
def provider_name(self) -> str:
return "gemini(openai)"
@property
def supported_models(self) -> List[str]:
return [
"gemini-2.5-flash",
"gemini-2.0-flash-lite",
"gemini-2.0-flash",
"gemini-1.5-pro",
"gemini-1.5-flash"
]
def _initialize(self):
"""初始化OpenAI兼容的Gemini客户端"""
if not self.base_url:
self.base_url = "https://generativelanguage.googleapis.com/v1beta/openai"
self.client = OpenAI(
api_key=self.api_key,
base_url=self.base_url
)
async def generate_text(self,
prompt: str,
system_prompt: Optional[str] = None,
temperature: float = 1.0,
max_tokens: Optional[int] = None,
response_format: Optional[str] = None,
**kwargs) -> str:
"""
使用OpenAI兼容的Gemini API生成文本
Args:
prompt: 用户提示词
system_prompt: 系统提示词
temperature: 生成温度
max_tokens: 最大token数
response_format: 响应格式 ('json' 或 None)
**kwargs: 其他参数
Returns:
生成的文本内容
"""
# 构建消息列表
messages = self._build_messages(prompt, system_prompt)
# 构建请求参数
request_params = {
"model": self.model_name,
"messages": messages,
"temperature": temperature
}
if max_tokens:
request_params["max_tokens"] = max_tokens
# 处理JSON格式输出 - Gemini通过OpenAI接口可能不完全支持response_format
if response_format == "json":
# 在提示词中添加JSON格式约束
messages[-1]["content"] += "\n\n请确保输出严格的JSON格式，不要包含任何其他文字或标记。"
try:
# 发送API请求
response = await asyncio.to_thread(
self.client.chat.completions.create,
**request_params
)
# 提取生成的内容
if response.choices and len(response.choices) > 0:
content = response.choices[0].message.content
# 对于JSON格式，清理输出
if response_format == "json":
content = self._clean_json_output(content)
logger.debug(f"OpenAI兼容Gemini API调用成功，消耗tokens: {response.usage.total_tokens if response.usage else 'N/A'}")
return content
else:
raise APICallError("OpenAI兼容Gemini API返回空响应")
except Exception as e:
logger.error(f"OpenAI兼容Gemini API调用失败: {str(e)}")
raise APICallError(f"OpenAI兼容Gemini API调用失败: {str(e)}")
def _clean_json_output(self, output: str) -> str:
"""清理JSON输出，移除markdown标记等"""
import re
# 移除可能的markdown代码块标记
output = re.sub(r'^```json\s*', '', output, flags=re.MULTILINE)
output = re.sub(r'^```\s*$', '', output, flags=re.MULTILINE)
output = re.sub(r'^```.*$', '', output, flags=re.MULTILINE)
# 移除前后空白字符
output = output.strip()
return output
async def _make_api_call(self, payload: Dict[str, Any]) -> Dict[str, Any]:
"""执行API调用 - 由于使用OpenAI SDK，这个方法主要用于兼容基类"""
pass

442
app/services/llm/providers/gemini_provider.py
View File

@ -1,442 +0,0 @@
"""
原生Gemini API提供商实现
使用Google原生Gemini API进行视觉分析和文本生成
"""
import asyncio
import base64
import io
import requests
from typing import List, Dict, Any, Optional, Union
from pathlib import Path
import PIL.Image
from loguru import logger
from ..base import VisionModelProvider, TextModelProvider
from ..exceptions import APICallError, ContentFilterError
class GeminiVisionProvider(VisionModelProvider):
"""原生Gemini视觉模型提供商"""
@property
def provider_name(self) -> str:
return "gemini"
@property
def supported_models(self) -> List[str]:
return [
"gemini-2.5-flash",
"gemini-2.0-flash-lite",
"gemini-2.0-flash",
"gemini-1.5-pro",
"gemini-1.5-flash"
]
def _initialize(self):
"""初始化Gemini特定设置"""
if not self.base_url:
self.base_url = "https://generativelanguage.googleapis.com/v1beta"
async def analyze_images(self,
images: List[Union[str, Path, PIL.Image.Image]],
prompt: str,
batch_size: int = 10,
**kwargs) -> List[str]:
"""
使用原生Gemini API分析图片
Args:
images: 图片列表
prompt: 分析提示词
batch_size: 批处理大小
**kwargs: 其他参数
Returns:
分析结果列表
"""
logger.info(f"开始分析 {len(images)} 张图片，使用原生Gemini API")
# 预处理图片
processed_images = self._prepare_images(images)
# 分批处理
results = []
for i in range(0, len(processed_images), batch_size):
batch = processed_images[i:i + batch_size]
logger.info(f"处理第 {i//batch_size + 1} 批，共 {len(batch)} 张图片")
try:
result = await self._analyze_batch(batch, prompt)
results.append(result)
except Exception as e:
logger.error(f"批次 {i//batch_size + 1} 处理失败: {str(e)}")
results.append(f"批次处理失败: {str(e)}")
return results
async def _analyze_batch(self, batch: List[PIL.Image.Image], prompt: str) -> str:
"""分析一批图片"""
# 构建请求数据
parts = [{"text": prompt}]
# 添加图片数据
for img in batch:
img_data = self._image_to_base64(img)
parts.append({
"inline_data": {
"mime_type": "image/jpeg",
"data": img_data
}
})
payload = {
"systemInstruction": {
"parts": [{"text": "你是一位专业的视觉内容分析师，请仔细分析图片内容并提供详细描述。"}]
},
"contents": [{"parts": parts}],
"generationConfig": {
"temperature": 1.0,
"topK": 40,
"topP": 0.95,
"maxOutputTokens": 4000,
"candidateCount": 1
},
"safetySettings": [
{
"category": "HARM_CATEGORY_HARASSMENT",
"threshold": "BLOCK_NONE"
},
{
"category": "HARM_CATEGORY_HATE_SPEECH",
"threshold": "BLOCK_NONE"
},
{
"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
"threshold": "BLOCK_NONE"
},
{
"category": "HARM_CATEGORY_DANGEROUS_CONTENT",
"threshold": "BLOCK_NONE"
}
]
}
# 发送API请求
response_data = await self._make_api_call(payload)
# 解析响应
return self._parse_vision_response(response_data)
def _image_to_base64(self, img: PIL.Image.Image) -> str:
"""将PIL图片转换为base64编码"""
img_buffer = io.BytesIO()
img.save(img_buffer, format='JPEG', quality=85)
img_bytes = img_buffer.getvalue()
return base64.b64encode(img_bytes).decode('utf-8')
async def _make_api_call(self, payload: Dict[str, Any]) -> Dict[str, Any]:
"""执行原生Gemini API调用，包含重试机制"""
from app.config import config
url = f"{self.base_url}/models/{self.model_name}:generateContent"
max_retries = config.app.get('llm_max_retries', 3)
base_timeout = config.app.get('llm_vision_timeout', 120)
for attempt in range(max_retries):
try:
# 根据尝试次数调整超时时间
timeout = base_timeout * (attempt + 1)
logger.debug(f"Gemini API调用尝试 {attempt + 1}/{max_retries}，超时设置: {timeout}秒")
response = await asyncio.to_thread(
requests.post,
url,
json=payload,
headers={
"Content-Type": "application/json",
"x-goog-api-key": self.api_key
},
timeout=timeout
)
if response.status_code == 200:
return response.json()
# 处理特定的错误状态码
if response.status_code == 429:
# 速率限制，等待后重试
wait_time = 30 * (attempt + 1)
logger.warning(f"Gemini API速率限制，等待 {wait_time} 秒后重试")
await asyncio.sleep(wait_time)
continue
elif response.status_code in [502, 503, 504, 524]:
# 服务器错误或超时，可以重试
if attempt < max_retries - 1:
wait_time = 10 * (attempt + 1)
logger.warning(f"Gemini API服务器错误 {response.status_code}，等待 {wait_time} 秒后重试")
await asyncio.sleep(wait_time)
continue
# 其他错误，直接抛出
error = self._handle_api_error(response.status_code, response.text)
raise error
except requests.exceptions.Timeout:
if attempt < max_retries - 1:
wait_time = 15 * (attempt + 1)
logger.warning(f"Gemini API请求超时，等待 {wait_time} 秒后重试")
await asyncio.sleep(wait_time)
continue
else:
raise APICallError("Gemini API请求超时，已达到最大重试次数")
except requests.exceptions.RequestException as e:
if attempt < max_retries - 1:
wait_time = 10 * (attempt + 1)
logger.warning(f"Gemini API网络错误: {str(e)}，等待 {wait_time} 秒后重试")
await asyncio.sleep(wait_time)
continue
else:
raise APICallError(f"Gemini API网络错误: {str(e)}")
# 如果所有重试都失败了
raise APICallError("Gemini API调用失败，已达到最大重试次数")
def _parse_vision_response(self, response_data: Dict[str, Any]) -> str:
"""解析视觉分析响应"""
if "candidates" not in response_data or not response_data["candidates"]:
raise APICallError("原生Gemini API返回无效响应")
candidate = response_data["candidates"][0]
# 检查是否被安全过滤阻止
if "finishReason" in candidate and candidate["finishReason"] == "SAFETY":
raise ContentFilterError("内容被Gemini安全过滤器阻止")
if "content" not in candidate or "parts" not in candidate["content"]:
raise APICallError("原生Gemini API返回内容格式错误")
# 提取文本内容
result = ""
for part in candidate["content"]["parts"]:
if "text" in part:
result += part["text"]
if not result.strip():
raise APICallError("原生Gemini API返回空内容")
return result
class GeminiTextProvider(TextModelProvider):
"""原生Gemini文本生成提供商"""
@property
def provider_name(self) -> str:
return "gemini"
@property
def supported_models(self) -> List[str]:
return [
"gemini-2.5-flash",
"gemini-2.0-flash-lite",
"gemini-2.0-flash",
"gemini-1.5-pro",
"gemini-1.5-flash"
]
def _initialize(self):
"""初始化Gemini特定设置"""
if not self.base_url:
self.base_url = "https://generativelanguage.googleapis.com/v1beta"
async def generate_text(self,
prompt: str,
system_prompt: Optional[str] = None,
temperature: float = 1.0,
max_tokens: Optional[int] = 30000,
response_format: Optional[str] = None,
**kwargs) -> str:
"""
使用原生Gemini API生成文本
Args:
prompt: 用户提示词
system_prompt: 系统提示词
temperature: 生成温度
max_tokens: 最大token数
response_format: 响应格式
**kwargs: 其他参数
Returns:
生成的文本内容
"""
# 构建请求数据
payload = {
"contents": [{"parts": [{"text": prompt}]}],
"generationConfig": {
"temperature": temperature,
"topK": 40,
"topP": 0.95,
"maxOutputTokens": 60000,
"candidateCount": 1
},
"safetySettings": [
{
"category": "HARM_CATEGORY_HARASSMENT",
"threshold": "BLOCK_NONE"
},
{
"category": "HARM_CATEGORY_HATE_SPEECH",
"threshold": "BLOCK_NONE"
},
{
"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
"threshold": "BLOCK_NONE"
},
{
"category": "HARM_CATEGORY_DANGEROUS_CONTENT",
"threshold": "BLOCK_NONE"
}
]
}
# 添加系统提示词
if system_prompt:
payload["systemInstruction"] = {
"parts": [{"text": system_prompt}]
}
# 如果需要JSON格式，调整提示词和配置
if response_format == "json":
# 使用更温和的JSON格式约束
enhanced_prompt = f"{prompt}\n\n请以JSON格式输出结果。"
payload["contents"][0]["parts"][0]["text"] = enhanced_prompt
# 移除可能导致问题的stopSequences
# payload["generationConfig"]["stopSequences"] = ["```", "注意", "说明"]
# 记录请求信息
# logger.debug(f"Gemini文本生成请求: {payload}")
# 发送API请求
response_data = await self._make_api_call(payload)
# 解析响应
return self._parse_text_response(response_data)
async def _make_api_call(self, payload: Dict[str, Any]) -> Dict[str, Any]:
"""执行原生Gemini API调用，包含重试机制"""
from app.config import config
url = f"{self.base_url}/models/{self.model_name}:generateContent"
max_retries = config.app.get('llm_max_retries', 3)
base_timeout = config.app.get('llm_text_timeout', 180) # 文本生成任务使用更长的基础超时时间
for attempt in range(max_retries):
try:
# 根据尝试次数调整超时时间
timeout = base_timeout * (attempt + 1)
logger.debug(f"Gemini文本API调用尝试 {attempt + 1}/{max_retries}，超时设置: {timeout}秒")
response = await asyncio.to_thread(
requests.post,
url,
json=payload,
headers={
"Content-Type": "application/json",
"x-goog-api-key": self.api_key
},
timeout=timeout
)
if response.status_code == 200:
return response.json()
# 处理特定的错误状态码
if response.status_code == 429:
# 速率限制，等待后重试
wait_time = 30 * (attempt + 1)
logger.warning(f"Gemini API速率限制，等待 {wait_time} 秒后重试")
await asyncio.sleep(wait_time)
continue
elif response.status_code in [502, 503, 504, 524]:
# 服务器错误或超时，可以重试
if attempt < max_retries - 1:
wait_time = 15 * (attempt + 1)
logger.warning(f"Gemini API服务器错误 {response.status_code}，等待 {wait_time} 秒后重试")
await asyncio.sleep(wait_time)
continue
# 其他错误，直接抛出
error = self._handle_api_error(response.status_code, response.text)
raise error
except requests.exceptions.Timeout:
if attempt < max_retries - 1:
wait_time = 20 * (attempt + 1)
logger.warning(f"Gemini文本API请求超时，等待 {wait_time} 秒后重试")
await asyncio.sleep(wait_time)
continue
else:
raise APICallError("Gemini文本API请求超时，已达到最大重试次数")
except requests.exceptions.RequestException as e:
if attempt < max_retries - 1:
wait_time = 15 * (attempt + 1)
logger.warning(f"Gemini文本API网络错误: {str(e)}，等待 {wait_time} 秒后重试")
await asyncio.sleep(wait_time)
continue
else:
raise APICallError(f"Gemini文本API网络错误: {str(e)}")
# 如果所有重试都失败了
raise APICallError("Gemini文本API调用失败，已达到最大重试次数")
def _parse_text_response(self, response_data: Dict[str, Any]) -> str:
"""解析文本生成响应"""
logger.debug(f"Gemini API响应数据: {response_data}")
if "candidates" not in response_data or not response_data["candidates"]:
logger.error(f"Gemini API返回无效响应结构: {response_data}")
raise APICallError("原生Gemini API返回无效响应")
candidate = response_data["candidates"][0]
logger.debug(f"Gemini候选响应: {candidate}")
# 检查完成原因
finish_reason = candidate.get("finishReason", "UNKNOWN")
logger.debug(f"Gemini完成原因: {finish_reason}")
# 检查是否被安全过滤阻止
if finish_reason == "SAFETY":
safety_ratings = candidate.get("safetyRatings", [])
logger.warning(f"内容被Gemini安全过滤器阻止，安全评级: {safety_ratings}")
raise ContentFilterError("内容被Gemini安全过滤器阻止")
# 检查是否因为其他原因停止
if finish_reason in ["RECITATION", "OTHER"]:
logger.warning(f"Gemini因为{finish_reason}原因停止生成")
raise APICallError(f"Gemini因为{finish_reason}原因停止生成")
if "content" not in candidate:
logger.error(f"Gemini候选响应中缺少content字段: {candidate}")
raise APICallError("原生Gemini API返回内容格式错误")
if "parts" not in candidate["content"]:
logger.error(f"Gemini内容中缺少parts字段: {candidate['content']}")
raise APICallError("原生Gemini API返回内容格式错误")
# 提取文本内容
result = ""
for part in candidate["content"]["parts"]:
if "text" in part:
result += part["text"]
if not result.strip():
logger.error(f"Gemini API返回空文本内容，完整响应: {response_data}")
raise APICallError("原生Gemini API返回空内容")
logger.debug(f"Gemini成功生成内容，长度: {len(result)}")
return result

168
app/services/llm/providers/openai_provider.py
View File

@ -1,168 +0,0 @@
"""
OpenAI API提供商实现
使用OpenAI API进行文本生成，也支持OpenAI兼容的其他服务
"""
import asyncio
from typing import List, Dict, Any, Optional
from openai import OpenAI, BadRequestError
from loguru import logger
from ..base import TextModelProvider
from ..exceptions import APICallError, RateLimitError, AuthenticationError
class OpenAITextProvider(TextModelProvider):
"""OpenAI文本生成提供商"""
@property
def provider_name(self) -> str:
return "openai"
@property
def supported_models(self) -> List[str]:
return [
"gpt-4o",
"gpt-4o-mini",
"gpt-4-turbo",
"gpt-4",
"gpt-3.5-turbo",
"gpt-3.5-turbo-16k",
# 支持其他OpenAI兼容模型
"deepseek-chat",
"deepseek-reasoner",
"qwen-plus",
"qwen-turbo",
"moonshot-v1-8k",
"moonshot-v1-32k",
"moonshot-v1-128k"
]
def _initialize(self):
"""初始化OpenAI客户端"""
if not self.base_url:
self.base_url = "https://api.openai.com/v1"
self.client = OpenAI(
api_key=self.api_key,
base_url=self.base_url
)
async def generate_text(self,
prompt: str,
system_prompt: Optional[str] = None,
temperature: float = 1.0,
max_tokens: Optional[int] = None,
response_format: Optional[str] = None,
**kwargs) -> str:
"""
使用OpenAI API生成文本
Args:
prompt: 用户提示词
system_prompt: 系统提示词
temperature: 生成温度
max_tokens: 最大token数
response_format: 响应格式 ('json' 或 None)
**kwargs: 其他参数
Returns:
生成的文本内容
"""
# 构建消息列表
messages = self._build_messages(prompt, system_prompt)
# 构建请求参数
request_params = {
"model": self.model_name,
"messages": messages,
"temperature": temperature
}
if max_tokens:
request_params["max_tokens"] = max_tokens
# 处理JSON格式输出
if response_format == "json":
# 检查模型是否支持response_format
if self._supports_response_format():
request_params["response_format"] = {"type": "json_object"}
else:
# 对于不支持response_format的模型，在提示词中添加约束
messages[-1]["content"] += "\n\n请确保输出严格的JSON格式，不要包含任何其他文字或标记。"
try:
# 发送API请求
response = await asyncio.to_thread(
self.client.chat.completions.create,
**request_params
)
# 提取生成的内容
if response.choices and len(response.choices) > 0:
content = response.choices[0].message.content
# 对于不支持response_format的模型，清理输出
if response_format == "json" and not self._supports_response_format():
content = self._clean_json_output(content)
logger.debug(f"OpenAI API调用成功，消耗tokens: {response.usage.total_tokens if response.usage else 'N/A'}")
return content
else:
raise APICallError("OpenAI API返回空响应")
except BadRequestError as e:
# 处理不支持response_format的情况
if "response_format" in str(e) and response_format == "json":
logger.warning(f"模型 {self.model_name} 不支持response_format，重试不带格式约束的请求")
request_params.pop("response_format", None)
messages[-1]["content"] += "\n\n请确保输出严格的JSON格式，不要包含任何其他文字或标记。"
response = await asyncio.to_thread(
self.client.chat.completions.create,
**request_params
)
if response.choices and len(response.choices) > 0:
content = response.choices[0].message.content
content = self._clean_json_output(content)
return content
else:
raise APICallError("OpenAI API返回空响应")
else:
raise APICallError(f"OpenAI API请求失败: {str(e)}")
except Exception as e:
logger.error(f"OpenAI API调用失败: {str(e)}")
raise APICallError(f"OpenAI API调用失败: {str(e)}")
def _supports_response_format(self) -> bool:
"""检查模型是否支持response_format参数"""
# 已知不支持response_format的模型
unsupported_models = [
"deepseek-reasoner",
"deepseek-r1"
]
return not any(unsupported in self.model_name.lower() for unsupported in unsupported_models)
def _clean_json_output(self, output: str) -> str:
"""清理JSON输出，移除markdown标记等"""
import re
# 移除可能的markdown代码块标记
output = re.sub(r'^```json\s*', '', output, flags=re.MULTILINE)
output = re.sub(r'^```\s*$', '', output, flags=re.MULTILINE)
output = re.sub(r'^```.*$', '', output, flags=re.MULTILINE)
# 移除前后空白字符
output = output.strip()
return output
async def _make_api_call(self, payload: Dict[str, Any]) -> Dict[str, Any]:
"""执行API调用 - 由于使用OpenAI SDK，这个方法主要用于兼容基类"""
# 这个方法在OpenAI提供商中不直接使用，因为我们使用OpenAI SDK
# 但为了兼容基类接口，保留此方法
pass

247
app/services/llm/providers/qwen_provider.py
View File

@ -1,247 +0,0 @@
"""
通义千问API提供商实现
支持通义千问的视觉模型和文本生成模型
"""
import asyncio
import base64
import io
from typing import List, Dict, Any, Optional, Union
from pathlib import Path
import PIL.Image
from openai import OpenAI
from loguru import logger
from ..base import VisionModelProvider, TextModelProvider
from ..exceptions import APICallError
class QwenVisionProvider(VisionModelProvider):
"""通义千问视觉模型提供商"""
@property
def provider_name(self) -> str:
return "qwenvl"
@property
def supported_models(self) -> List[str]:
return [
"qwen2.5-vl-32b-instruct",
"qwen2-vl-72b-instruct",
"qwen-vl-max",
"qwen-vl-plus"
]
def _initialize(self):
"""初始化通义千问客户端"""
if not self.base_url:
self.base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
self.client = OpenAI(
api_key=self.api_key,
base_url=self.base_url
)
async def analyze_images(self,
images: List[Union[str, Path, PIL.Image.Image]],
prompt: str,
batch_size: int = 10,
**kwargs) -> List[str]:
"""
使用通义千问VL分析图片
Args:
images: 图片列表
prompt: 分析提示词
batch_size: 批处理大小
**kwargs: 其他参数
Returns:
分析结果列表
"""
logger.info(f"开始分析 {len(images)} 张图片，使用通义千问VL")
# 预处理图片
processed_images = self._prepare_images(images)
# 分批处理
results = []
for i in range(0, len(processed_images), batch_size):
batch = processed_images[i:i + batch_size]
logger.info(f"处理第 {i//batch_size + 1} 批，共 {len(batch)} 张图片")
try:
result = await self._analyze_batch(batch, prompt)
results.append(result)
except Exception as e:
logger.error(f"批次 {i//batch_size + 1} 处理失败: {str(e)}")
results.append(f"批次处理失败: {str(e)}")
return results
async def _analyze_batch(self, batch: List[PIL.Image.Image], prompt: str) -> str:
"""分析一批图片"""
# 构建消息内容
content = []
# 添加图片
for img in batch:
base64_image = self._image_to_base64(img)
content.append({
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{base64_image}"
}
})
# 添加文本提示，使用占位符来引用图片数量
content.append({
"type": "text",
"text": prompt % (len(batch), len(batch), len(batch))
})
# 构建消息
messages = [{
"role": "user",
"content": content
}]
# 调用API
response = await asyncio.to_thread(
self.client.chat.completions.create,
model=self.model_name,
messages=messages
)
if response.choices and len(response.choices) > 0:
return response.choices[0].message.content
else:
raise APICallError("通义千问VL API返回空响应")
def _image_to_base64(self, img: PIL.Image.Image) -> str:
"""将PIL图片转换为base64编码"""
img_buffer = io.BytesIO()
img.save(img_buffer, format='JPEG', quality=85)
img_bytes = img_buffer.getvalue()
return base64.b64encode(img_bytes).decode('utf-8')
async def _make_api_call(self, payload: Dict[str, Any]) -> Dict[str, Any]:
"""执行API调用 - 由于使用OpenAI SDK，这个方法主要用于兼容基类"""
pass
class QwenTextProvider(TextModelProvider):
"""通义千问文本生成提供商"""
@property
def provider_name(self) -> str:
return "qwen"
@property
def supported_models(self) -> List[str]:
return [
"qwen-plus-1127",
"qwen-plus",
"qwen-turbo",
"qwen-max",
"qwen2.5-72b-instruct",
"qwen2.5-32b-instruct",
"qwen2.5-14b-instruct",
"qwen2.5-7b-instruct"
]
def _initialize(self):
"""初始化通义千问客户端"""
if not self.base_url:
self.base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
self.client = OpenAI(
api_key=self.api_key,
base_url=self.base_url
)
async def generate_text(self,
prompt: str,
system_prompt: Optional[str] = None,
temperature: float = 1.0,
max_tokens: Optional[int] = None,
response_format: Optional[str] = None,
**kwargs) -> str:
"""
使用通义千问API生成文本
Args:
prompt: 用户提示词
system_prompt: 系统提示词
temperature: 生成温度
max_tokens: 最大token数
response_format: 响应格式 ('json' 或 None)
**kwargs: 其他参数
Returns:
生成的文本内容
"""
# 构建消息列表
messages = self._build_messages(prompt, system_prompt)
# 构建请求参数
request_params = {
"model": self.model_name,
"messages": messages,
"temperature": temperature
}
if max_tokens:
request_params["max_tokens"] = max_tokens
# 处理JSON格式输出
if response_format == "json":
# 通义千问支持response_format
try:
request_params["response_format"] = {"type": "json_object"}
except:
# 如果不支持，在提示词中添加约束
messages[-1]["content"] += "\n\n请确保输出严格的JSON格式，不要包含任何其他文字或标记。"
try:
# 发送API请求
response = await asyncio.to_thread(
self.client.chat.completions.create,
**request_params
)
# 提取生成的内容
if response.choices and len(response.choices) > 0:
content = response.choices[0].message.content
# 对于JSON格式，清理输出
if response_format == "json" and "response_format" not in request_params:
content = self._clean_json_output(content)
logger.debug(f"通义千问API调用成功，消耗tokens: {response.usage.total_tokens if response.usage else 'N/A'}")
return content
else:
raise APICallError("通义千问API返回空响应")
except Exception as e:
logger.error(f"通义千问API调用失败: {str(e)}")
raise APICallError(f"通义千问API调用失败: {str(e)}")
def _clean_json_output(self, output: str) -> str:
"""清理JSON输出，移除markdown标记等"""
import re
# 移除可能的markdown代码块标记
output = re.sub(r'^```json\s*', '', output, flags=re.MULTILINE)
output = re.sub(r'^```\s*$', '', output, flags=re.MULTILINE)
output = re.sub(r'^```.*$', '', output, flags=re.MULTILINE)
# 移除前后空白字符
output = output.strip()
return output
async def _make_api_call(self, payload: Dict[str, Any]) -> Dict[str, Any]:
"""执行API调用 - 由于使用OpenAI SDK，这个方法主要用于兼容基类"""
pass

251
app/services/llm/providers/siliconflow_provider.py
View File

@ -1,251 +0,0 @@
"""
硅基流动API提供商实现
支持硅基流动的视觉模型和文本生成模型
"""
import asyncio
import base64
import io
from typing import List, Dict, Any, Optional, Union
from pathlib import Path
import PIL.Image
from openai import OpenAI
from loguru import logger
from ..base import VisionModelProvider, TextModelProvider
from ..exceptions import APICallError
class SiliconflowVisionProvider(VisionModelProvider):
"""硅基流动视觉模型提供商"""
@property
def provider_name(self) -> str:
return "siliconflow"
@property
def supported_models(self) -> List[str]:
return [
"Qwen/Qwen2.5-VL-32B-Instruct",
"Qwen/Qwen2-VL-72B-Instruct",
"deepseek-ai/deepseek-vl2",
"OpenGVLab/InternVL2-26B"
]
def _initialize(self):
"""初始化硅基流动客户端"""
if not self.base_url:
self.base_url = "https://api.siliconflow.cn/v1"
self.client = OpenAI(
api_key=self.api_key,
base_url=self.base_url
)
async def analyze_images(self,
images: List[Union[str, Path, PIL.Image.Image]],
prompt: str,
batch_size: int = 10,
**kwargs) -> List[str]:
"""
使用硅基流动API分析图片
Args:
images: 图片列表
prompt: 分析提示词
batch_size: 批处理大小
**kwargs: 其他参数
Returns:
分析结果列表
"""
logger.info(f"开始分析 {len(images)} 张图片，使用硅基流动")
# 预处理图片
processed_images = self._prepare_images(images)
# 分批处理
results = []
for i in range(0, len(processed_images), batch_size):
batch = processed_images[i:i + batch_size]
logger.info(f"处理第 {i//batch_size + 1} 批，共 {len(batch)} 张图片")
try:
result = await self._analyze_batch(batch, prompt)
results.append(result)
except Exception as e:
logger.error(f"批次 {i//batch_size + 1} 处理失败: {str(e)}")
results.append(f"批次处理失败: {str(e)}")
return results
async def _analyze_batch(self, batch: List[PIL.Image.Image], prompt: str) -> str:
"""分析一批图片"""
# 构建消息内容
content = [{"type": "text", "text": prompt}]
# 添加图片
for img in batch:
base64_image = self._image_to_base64(img)
content.append({
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{base64_image}"
}
})
# 构建消息
messages = [{
"role": "user",
"content": content
}]
# 调用API
response = await asyncio.to_thread(
self.client.chat.completions.create,
model=self.model_name,
messages=messages,
max_tokens=4000,
temperature=1.0
)
if response.choices and len(response.choices) > 0:
return response.choices[0].message.content
else:
raise APICallError("硅基流动API返回空响应")
def _image_to_base64(self, img: PIL.Image.Image) -> str:
"""将PIL图片转换为base64编码"""
img_buffer = io.BytesIO()
img.save(img_buffer, format='JPEG', quality=85)
img_bytes = img_buffer.getvalue()
return base64.b64encode(img_bytes).decode('utf-8')
async def _make_api_call(self, payload: Dict[str, Any]) -> Dict[str, Any]:
"""执行API调用 - 由于使用OpenAI SDK，这个方法主要用于兼容基类"""
pass
class SiliconflowTextProvider(TextModelProvider):
"""硅基流动文本生成提供商"""
@property
def provider_name(self) -> str:
return "siliconflow"
@property
def supported_models(self) -> List[str]:
return [
"deepseek-ai/DeepSeek-R1",
"deepseek-ai/DeepSeek-V3",
"Qwen/Qwen2.5-72B-Instruct",
"Qwen/Qwen2.5-32B-Instruct",
"meta-llama/Llama-3.1-70B-Instruct",
"meta-llama/Llama-3.1-8B-Instruct",
"01-ai/Yi-1.5-34B-Chat"
]
def _initialize(self):
"""初始化硅基流动客户端"""
if not self.base_url:
self.base_url = "https://api.siliconflow.cn/v1"
self.client = OpenAI(
api_key=self.api_key,
base_url=self.base_url
)
async def generate_text(self,
prompt: str,
system_prompt: Optional[str] = None,
temperature: float = 1.0,
max_tokens: Optional[int] = None,
response_format: Optional[str] = None,
**kwargs) -> str:
"""
使用硅基流动API生成文本
Args:
prompt: 用户提示词
system_prompt: 系统提示词
temperature: 生成温度
max_tokens: 最大token数
response_format: 响应格式 ('json' 或 None)
**kwargs: 其他参数
Returns:
生成的文本内容
"""
# 构建消息列表
messages = self._build_messages(prompt, system_prompt)
# 构建请求参数
request_params = {
"model": self.model_name,
"messages": messages,
"temperature": temperature
}
if max_tokens:
request_params["max_tokens"] = max_tokens
# 处理JSON格式输出
if response_format == "json":
if self._supports_response_format():
request_params["response_format"] = {"type": "json_object"}
else:
# 对于不支持response_format的模型，在提示词中添加约束
messages[-1]["content"] += "\n\n请确保输出严格的JSON格式，不要包含任何其他文字或标记。"
try:
# 发送API请求
response = await asyncio.to_thread(
self.client.chat.completions.create,
**request_params
)
# 提取生成的内容
if response.choices and len(response.choices) > 0:
content = response.choices[0].message.content
# 对于不支持response_format的模型，清理输出
if response_format == "json" and not self._supports_response_format():
content = self._clean_json_output(content)
logger.debug(f"硅基流动API调用成功，消耗tokens: {response.usage.total_tokens if response.usage else 'N/A'}")
return content
else:
raise APICallError("硅基流动API返回空响应")
except Exception as e:
logger.error(f"硅基流动API调用失败: {str(e)}")
raise APICallError(f"硅基流动API调用失败: {str(e)}")
def _supports_response_format(self) -> bool:
"""检查模型是否支持response_format参数"""
# DeepSeek R1 和 V3 不支持 response_format=json_object
unsupported_models = [
"deepseek-ai/deepseek-r1",
"deepseek-ai/deepseek-v3"
]
return not any(unsupported in self.model_name.lower() for unsupported in unsupported_models)
def _clean_json_output(self, output: str) -> str:
"""清理JSON输出，移除markdown标记等"""
import re
# 移除可能的markdown代码块标记
output = re.sub(r'^```json\s*', '', output, flags=re.MULTILINE)
output = re.sub(r'^```\s*$', '', output, flags=re.MULTILINE)
output = re.sub(r'^```.*$', '', output, flags=re.MULTILINE)
# 移除前后空白字符
output = output.strip()
return output
async def _make_api_call(self, payload: Dict[str, Any]) -> Dict[str, Any]:
"""执行API调用 - 由于使用OpenAI SDK，这个方法主要用于兼容基类"""
pass

228
app/services/llm/test_litellm_integration.py Normal file
View File

@ -0,0 +1,228 @@
"""
LiteLLM 集成测试脚本
测试 LiteLLM provider 是否正确集成到系统中
"""
import asyncio
import sys
from pathlib import Path
# 添加项目根目录到 Python 路径
project_root = Path(__file__).parent.parent.parent.parent
sys.path.insert(0, str(project_root))
from loguru import logger
from app.services.llm.manager import LLMServiceManager
from app.services.llm.unified_service import UnifiedLLMService
def test_provider_registration():
"""测试 provider 是否正确注册"""
logger.info("=" * 60)
logger.info("测试 1: Provider 注册检查")
logger.info("=" * 60)
# 检查 LiteLLM provider 是否已注册
vision_providers = LLMServiceManager.list_vision_providers()
text_providers = LLMServiceManager.list_text_providers()
logger.info(f"已注册的视觉模型 providers: {vision_providers}")
logger.info(f"已注册的文本模型 providers: {text_providers}")
assert 'litellm' in vision_providers, "❌ LiteLLM Vision Provider 未注册"
assert 'litellm' in text_providers, "❌ LiteLLM Text Provider 未注册"
logger.success("✅ LiteLLM providers 已成功注册")
# 显示所有 provider 信息
provider_info = LLMServiceManager.get_provider_info()
logger.info("\n所有 Provider 信息:")
logger.info(f" 视觉模型 providers: {list(provider_info['vision_providers'].keys())}")
logger.info(f" 文本模型 providers: {list(provider_info['text_providers'].keys())}")
def test_litellm_import():
"""测试 LiteLLM 库是否正确安装"""
logger.info("\n" + "=" * 60)
logger.info("测试 2: LiteLLM 库导入检查")
logger.info("=" * 60)
try:
import litellm
logger.success(f"✅ LiteLLM 已安装，版本: {litellm.__version__}")
return True
except ImportError as e:
logger.error(f"❌ LiteLLM 未安装: {str(e)}")
logger.info("请运行: pip install litellm>=1.70.0")
return False
async def test_text_generation_mock():
"""测试文本生成接口（模拟模式，不实际调用 API）"""
logger.info("\n" + "=" * 60)
logger.info("测试 3: 文本生成接口（模拟）")
logger.info("=" * 60)
try:
# 这里只测试接口是否可调用，不实际发送 API 请求
logger.info("接口测试通过：UnifiedLLMService.generate_text 可调用")
logger.success("✅ 文本生成接口测试通过")
return True
except Exception as e:
logger.error(f"❌ 文本生成接口测试失败: {str(e)}")
return False
async def test_vision_analysis_mock():
"""测试视觉分析接口（模拟模式）"""
logger.info("\n" + "=" * 60)
logger.info("测试 4: 视觉分析接口（模拟）")
logger.info("=" * 60)
try:
# 这里只测试接口是否可调用
logger.info("接口测试通过：UnifiedLLMService.analyze_images 可调用")
logger.success("✅ 视觉分析接口测试通过")
return True
except Exception as e:
logger.error(f"❌ 视觉分析接口测试失败: {str(e)}")
return False
def test_backward_compatibility():
"""测试向后兼容性"""
logger.info("\n" + "=" * 60)
logger.info("测试 5: 向后兼容性检查")
logger.info("=" * 60)
# 检查旧的 provider 是否仍然可用
old_providers = ['gemini', 'openai', 'qwen', 'deepseek', 'siliconflow']
vision_providers = LLMServiceManager.list_vision_providers()
text_providers = LLMServiceManager.list_text_providers()
logger.info("检查旧 provider 是否仍然可用:")
for provider in old_providers:
if provider in ['openai', 'deepseek']:
# 这些只有 text provider
if provider in text_providers:
logger.info(f" ✅ {provider} (text)")
else:
logger.warning(f" ⚠️ {provider} (text) 未注册")
else:
# 这些有 vision 和 text provider
vision_ok = provider in vision_providers or f"{provider}vl" in vision_providers
text_ok = provider in text_providers
if vision_ok:
logger.info(f" ✅ {provider} (vision)")
if text_ok:
logger.info(f" ✅ {provider} (text)")
logger.success("✅ 向后兼容性测试通过")
def print_usage_guide():
"""打印使用指南"""
logger.info("\n" + "=" * 60)
logger.info("LiteLLM 使用指南")
logger.info("=" * 60)
guide = """
📚 如何使用 LiteLLM：
1. 在 config.toml 中配置：
```toml
[app]
# 方式 1：直接使用 LiteLLM（推荐）
vision_llm_provider = "litellm"
vision_litellm_model_name = "gemini/gemini-2.0-flash-lite"
vision_litellm_api_key = "your-api-key"
text_llm_provider = "litellm"
text_litellm_model_name = "deepseek/deepseek-chat"
text_litellm_api_key = "your-api-key"
```
2. 支持的模型格式：
- Gemini: gemini/gemini-2.0-flash
- DeepSeek: deepseek/deepseek-chat
- Qwen: qwen/qwen-plus
- OpenAI: gpt-4o, gpt-4o-mini
- SiliconFlow: siliconflow/deepseek-ai/DeepSeek-R1
- 更多: 参考 https://docs.litellm.ai/docs/providers
3. 代码调用示例：
```python
from app.services.llm.unified_service import UnifiedLLMService
# 文本生成
result = await UnifiedLLMService.generate_text(
prompt="你好",
provider="litellm"
)
# 视觉分析
results = await UnifiedLLMService.analyze_images(
images=["path/to/image.jpg"],
prompt="描述这张图片",
provider="litellm"
)
```
4. 优势：
✅ 减少 80% 代码量
✅ 统一的错误处理
✅ 自动重试机制
✅ 支持 100+ providers
✅ 自动成本追踪
5. 迁移建议：
- 新项目：直接使用 LiteLLM
- 旧项目：逐步迁移，旧的 provider 仍然可用
- 测试充分后再切换生产环境
"""
print(guide)
def main():
"""运行所有测试"""
logger.info("开始 LiteLLM 集成测试...\n")
try:
# 测试 1: Provider 注册
test_provider_registration()
# 测试 2: LiteLLM 库导入
litellm_available = test_litellm_import()
if not litellm_available:
logger.warning("\n⚠️ LiteLLM 未安装，跳过 API 测试")
logger.info("请运行: pip install litellm>=1.70.0")
else:
# 测试 3-4: 接口测试（模拟）
asyncio.run(test_text_generation_mock())
asyncio.run(test_vision_analysis_mock())
# 测试 5: 向后兼容性
test_backward_compatibility()
# 打印使用指南
print_usage_guide()
logger.info("\n" + "=" * 60)
logger.success("🎉 所有测试通过！")
logger.info("=" * 60)
return True
except Exception as e:
logger.error(f"\n❌ 测试失败: {str(e)}")
import traceback
traceback.print_exc()
return False
if __name__ == "__main__":
success = main()
sys.exit(0 if success else 1)

16
app/services/llm/unified_service.py
View File

@ -13,20 +13,8 @@ from .manager import LLMServiceManager
from .validators import OutputValidator
from .exceptions import LLMServiceError
# 确保提供商已注册
def _ensure_providers_registered():
"""确保所有提供商都已注册"""
try:
# 检查是否有已注册的提供商
if not LLMServiceManager.list_text_providers() or not LLMServiceManager.list_vision_providers():
# 如果没有注册的提供商，强制导入providers模块
from . import providers
logger.debug("强制注册LLM服务提供商")
except Exception as e:
logger.error(f"确保LLM服务提供商注册时发生错误: {str(e)}")
# 在模块加载时确保提供商已注册
_ensure_providers_registered()
# 提供商注册由 webui.py:main() 显式调用（见 LLM 提供商注册机制重构）
# 这样更可靠，错误也更容易调试
class UnifiedLLMService:

101
app/services/prompts/documentary/narration_generation.py
View File

@ -6,57 +6,85 @@
@File : narration_generation.py
@Author : viccy同学
@Date : 2025/1/7
@Description: 纪录片解说文案生成提示词
@Description: 通用短视频解说文案生成提示词（优化版v2.0）
"""
from ..base import TextPrompt, PromptMetadata, ModelType, OutputFormat
class NarrationGenerationPrompt(TextPrompt):
"""纪录片解说文案生成提示词"""
"""通用短视频解说文案生成提示词"""
def __init__(self):
metadata = PromptMetadata(
name="narration_generation",
category="documentary",
version="v1.0",
description="根据视频帧分析结果生成纪录片解说文案，特别适用于荒野建造类内容",
version="v2.0",
description="根据视频帧分析结果生成病毒式传播短视频解说文案，适用于各类题材内容",
model_type=ModelType.TEXT,
output_format=OutputFormat.JSON,
tags=["纪录片", "解说文案", "荒野建造", "文案生成"],
tags=["短视频", "解说文案", "病毒传播", "文案生成", "通用模板"],
parameters=["video_frame_description"]
)
super().__init__(metadata)
self._system_prompt = "你是一名专业的短视频解说文案撰写专家，擅长创作引人入胜的纪录片解说内容。"
self._system_prompt = "你是一名资深的短视频解说导演和编剧，深谙病毒式传播规律和用户心理，擅长创作让人停不下来的高粘性解说内容。"
def get_template(self) -> str:
return """我是一名荒野建造解说的博主，以下是一些同行的对标文案，请你深度学习并总结这些文案的风格特点跟内容特点：
return """作为一名短视频解说导演，你需要深入理解病毒式传播的核心规律。以下是爆款短视频解说的核心技巧：
<example_text_1>
解压助眠的天花板就是荒野建造，沉浸丝滑的搭建过程可以说每一帧都是极致享受，我保证强迫症来了都找不出一丁点毛病。更别说全屋严丝合缝的拼接工艺，还能轻松抵御零下二十度气温，让你居住的每一天都温暖如春。
在家闲不住的西姆今天也打算来一次野外建造，行走没多久他就发现许多倒塌的树，任由它们自生自灭不如将其利用起来。想到这他就开始挥舞铲子要把地基挖掘出来，虽然每次只能挖一点点，但架不住他体能惊人。没多长时间一个 2x3 的深坑就赫然出现，这深度住他一人绰绰有余。
随后他去附近收集来原木，这些都是搭建墙壁的最好材料。而在投入使用前自然要把表皮刮掉，防止森林中的白蚁蛀虫。处理好一大堆后西姆还在两端打孔，使用木钉固定在一起。这可不是用来做墙壁的，而是做庇护所的承重柱。只要木头间的缝隙足够紧密，那搭建出的木屋就能足够坚固。
每向上搭建一层，他都会在中间塞入苔藓防寒，保证不会泄露一丝热量。其他几面也是用相同方法，很快西姆就做好了三面墙壁，每一根木头都极其工整，保证强迫症来了都要点个赞再走。
在继续搭建墙壁前西姆决定将壁炉制作出来，毕竟森林夜晚的气温会很低，保暖措施可是重中之重。完成后他找来一块大树皮用来充当庇护所的大门，而上面刮掉的木屑还能作为壁炉的引火物，可以说再完美不过。
测试了排烟没问题后他才开始搭建最后一面墙壁，这一面要预留门和窗，所以在搭建到一半后还需要在原木中间开出卡口，让自己劈砍时能轻松许多。此时只需将另外一根如法炮制，两端拼接在一起后就是一扇大小适中的窗户。而随着随后一层苔藓铺好，最后一根原木落位，这个庇护所的雏形就算完成。
</example_text_1>
<viral_techniques>
## 黄金三秒法则
开头 3 秒决定用户是否继续观看，必须立即抓住注意力。
<example_text_2>
解压助眠的天花板就是荒野建造，沉浸丝滑的搭建过程每一帧都是极致享受，全屋严丝合缝的拼接工艺，能轻松抵御零下二十度气温，居住体验温暖如春。
在家闲不住的西姆开启野外建造。他发现倒塌的树，决定加以利用。先挖掘出 2x3 的深坑作为地基，接着收集原木，刮掉表皮防白蚁蛀虫，打孔用木钉固定制作承重柱。搭建墙壁时，每一层都塞入苔藓防寒，很快做好三面墙。
为应对森林夜晚低温，西姆制作壁炉，用大树皮当大门，刮下的木屑做引火物。搭建最后一面墙时预留门窗，通过在原木中间开口拼接做出窗户。大门采用榫卯结构安装，严丝合缝。
搭建屋顶时，先固定外围原木，再平铺原木形成斜面屋顶，之后用苔藓、黏土密封缝隙，铺上枯叶和泥土。为美观，在木屋覆盖苔藓，移植小树点缀。完工时遇大雨，木屋防水良好。
西姆利用墙壁凹槽镶嵌床框，铺上苔藓、床单枕头做成床。劳作一天后，他用壁炉烤牛肉享用。建造一星期后，他开始野外露营。
后来西姆回家补给物资，回来时森林大雪纷飞。他劈柴储备，带回食物、调味料和被褥，提高居住舒适度，还用干草做靠垫。他用壁炉烤牛排，搭配红酒。
第二天，积雪融化，西姆制作室外篝火堆防野兽。用大树夹缝掰弯木棍堆积而成，晚上点燃处理废料，结束后用雪球灭火，最后在室内二十五度的环境中裹被入睡。
</example_text_2>
## 十大爆款开头钩子类型：
1. **悬念式**："你绝对想不到接下来会发生什么..."
2. **反转式**："所有人都以为...但真相却是..."
3. **数字冲击**："仅用 3 步/5 分钟/1 个技巧..."
4. **痛点切入**："还在为...发愁吗？"
5. **惊叹式**："太震撼了！这才是..."
6. **疑问引导**："为什么...？答案让人意外"
7. **对比冲突**："新手 VS 高手，差距竟然这么大"
8. **秘密揭露**："内行人才知道的..."
9. **情感共鸣**："有多少人和我一样..."
10. **颠覆认知**："原来我们一直都错了..."
## 解说文案核心要素：
- **节奏感**：短句为主，控制在 15-20 字/句，朗朗上口
- **画面感**：用具体动作和细节描述，避免抽象概念
- **情绪起伏**：制造期待、惊喜、满足的情绪曲线
- **信息密度**：每 5-10 秒一个信息点，保持新鲜感
- **口语化**：像朋友聊天，避免书面语和专业术语
- **留白艺术**：关键时刻停顿，让画面说话
## 结构范式：
【开头】钩子引入（0-3秒）→ 【发展】情节推进（3-30秒）→ 【高潮】惊艳时刻（30-45秒）→ 【收尾】强化记忆/引导互动（45-60秒）
</viral_techniques>
<video_frame_description>
${video_frame_description}
</video_frame_description>
我正在尝试做这个内容的解说纪录片视频，我需要你以 <video_frame_description> </video_frame_description> 中的内容为解说目标，根据我刚才提供给你的对标文案特点，以及你总结的特点，帮我生成一段关于荒野建造的解说文案，文案需要符合平台受欢迎的解说风格，请使用 json 格式进行输出；使用 <output> 中的输出格式：
现在，请基于 <video_frame_description> 中的视频内容，创作一段符合病毒式传播规律的解说文案。
<creation_guide>
**创作步骤：**
1. 分析视频主题和核心亮点
2. 选择最适合的开头钩子类型
3. 提炼每个画面的最吸引人的细节
4. 设计情绪曲线和节奏变化
5. 确保解说与画面高度同步
**必须遵循的创作原则：**
- 开头 3 秒必须使用钩子技巧，立即抓住注意力
- 每句话控制在 15-20 字，确保节奏明快
- 用动词和具体细节描述，增强画面感
- 制造悬念和期待，让用户想看到最后
- 在关键视觉高潮处，适当留白让画面说话
- 结尾呼应开头，强化记忆点或引导互动
</creation_guide>
请使用以下 JSON 格式输出：
<output>
{
@ -72,11 +100,14 @@ ${video_frame_description}
</output>
<restriction>
1. 只输出 json 内容，不要输出其他任何说明性的文字
2. 解说文案的语言使用 简体中文
3. 严禁虚构画面，所有画面只能从 <video_frame_description> 中摘取
4. 严禁虚构时间戳，所有时间戳只能从 <video_frame_description> 中摘取
5. 解说文案要生动有趣，符合荒野建造解说的风格特点
6. 每个片段的解说文案要与画面内容高度匹配
7. 保持解说的连贯性和故事性
1. 只输出 JSON 内容，不要输出其他任何说明性文字
2. 解说文案的语言使用简体中文
3. 严禁虚构画面，所有画面描述只能从 <video_frame_description> 中提取
4. 严禁虚构时间戳，所有时间戳只能从 <video_frame_description> 中提取
5. 开头必须使用钩子技巧，遵循黄金三秒法则
6. 每个片段的解说文案要与画面内容精准匹配
7. 保持解说的连贯性、故事性和节奏感
8. 控制单句长度在 15-20 字，确保口语化表达
9. 在视觉高潮处适当精简文案，让画面自己说话
10. 整体风格要符合当前主流短视频平台的受欢迎特征
</restriction>"""

5
app/services/prompts/registry.py
View File

@ -58,8 +58,9 @@ class PromptRegistry:
# 设置默认版本
if is_default or name not in self._default_versions[category]:
self._default_versions[category][name] = version
logger.info(f"已注册提示词: {category}.{name} v{version}")
# 降级为 debug 日志，避免启动时的噪音
logger.debug(f"已注册提示词: {category}.{name} v{version}")
def get(self, category: str, name: str, version: Optional[str] = None) -> BasePrompt:
"""

169
app/services/script_service.py
View File

@ -57,24 +57,15 @@ class ScriptGenerator:
threshold
)
if vision_llm_provider == "gemini":
script = await self._process_with_gemini(
keyframe_files,
video_theme,
custom_prompt,
vision_batch_size,
progress_callback
)
elif vision_llm_provider == "narratoapi":
script = await self._process_with_narrato(
keyframe_files,
video_theme,
custom_prompt,
vision_batch_size,
progress_callback
)
else:
raise ValueError(f"Unsupported vision provider: {vision_llm_provider}")
# 使用统一的 LLM 接口（支持所有 provider）
script = await self._process_with_llm(
keyframe_files,
video_theme,
custom_prompt,
vision_batch_size,
vision_llm_provider,
progress_callback
)
return json.loads(script) if isinstance(script, str) else script
@ -126,41 +117,37 @@ class ScriptGenerator:
shutil.rmtree(video_keyframes_dir)
raise
async def _process_with_gemini(
async def _process_with_llm(
self,
keyframe_files: List[str],
video_theme: str,
custom_prompt: str,
vision_batch_size: int,
vision_llm_provider: str,
progress_callback: Callable[[float, str], None]
) -> str:
"""使用Gemini处理视频帧"""
"""使用统一 LLM 接口处理视频帧"""
progress_callback(30, "正在初始化视觉分析器...")
# 获取Gemini配置
vision_api_key = config.app.get("vision_gemini_api_key")
vision_model = config.app.get("vision_gemini_model_name")
vision_base_url = config.app.get("vision_gemini_base_url")
# 使用新的 LLM 迁移适配器（支持所有 provider）
from app.services.llm.migration_adapter import create_vision_analyzer
# 获取配置
text_provider = config.app.get('text_llm_provider', 'litellm').lower()
vision_api_key = config.app.get(f'vision_{vision_llm_provider}_api_key')
vision_model = config.app.get(f'vision_{vision_llm_provider}_model_name')
vision_base_url = config.app.get(f'vision_{vision_llm_provider}_base_url')
if not vision_api_key or not vision_model:
raise ValueError("未配置 Gemini API Key 或者模型")
raise ValueError(f"未配置 {vision_llm_provider} API Key 或者模型")
# 根据提供商类型选择合适的分析器
if vision_provider == 'gemini(openai)':
# 使用OpenAI兼容的Gemini代理
from app.utils.gemini_openai_analyzer import GeminiOpenAIAnalyzer
analyzer = GeminiOpenAIAnalyzer(
model_name=vision_model,
api_key=vision_api_key,
base_url=vision_base_url
)
else:
# 使用原生Gemini分析器
analyzer = gemini_analyzer.VisionAnalyzer(
model_name=vision_model,
api_key=vision_api_key,
base_url=vision_base_url
)
# 创建统一的视觉分析器
analyzer = create_vision_analyzer(
provider=vision_llm_provider,
api_key=vision_api_key,
model=vision_model,
base_url=vision_base_url
)
progress_callback(40, "正在分析关键帧...")
@ -258,104 +245,6 @@ class ScriptGenerator:
return processor.process_frames(frame_content_list)
async def _process_with_narrato(
self,
keyframe_files: List[str],
video_theme: str,
custom_prompt: str,
vision_batch_size: int,
progress_callback: Callable[[float, str], None]
) -> str:
"""使用NarratoAPI处理视频帧"""
# 创建临时目录
temp_dir = utils.temp_dir("narrato")
# 打包关键帧
progress_callback(30, "正在打包关键帧...")
zip_path = os.path.join(temp_dir, f"keyframes_{int(time.time())}.zip")
try:
if not utils.create_zip(keyframe_files, zip_path):
raise Exception("打包关键帧失败")
# 获取API配置
api_url = config.app.get("narrato_api_url")
api_key = config.app.get("narrato_api_key")
if not api_key:
raise ValueError("未配置 Narrato API Key")
headers = {
'X-API-Key': api_key,
'accept': 'application/json'
}
api_params = {
'batch_size': vision_batch_size,
'use_ai': False,
'start_offset': 0,
'vision_model': config.app.get('narrato_vision_model', 'gemini-1.5-flash'),
'vision_api_key': config.app.get('narrato_vision_key'),
'llm_model': config.app.get('narrato_llm_model', 'qwen-plus'),
'llm_api_key': config.app.get('narrato_llm_key'),
'custom_prompt': custom_prompt
}
progress_callback(40, "正在上传文件...")
with open(zip_path, 'rb') as f:
files = {'file': (os.path.basename(zip_path), f, 'application/x-zip-compressed')}
response = requests.post(
f"{api_url}/video/analyze",
headers=headers,
params=api_params,
files=files,
timeout=30
)
response.raise_for_status()
task_data = response.json()
task_id = task_data["data"].get('task_id')
if not task_id:
raise Exception(f"无效的API<EFBFBD><EFBFBD>应: {response.text}")
progress_callback(50, "正在等待分析结果...")
retry_count = 0
max_retries = 60
while retry_count < max_retries:
try:
status_response = requests.get(
f"{api_url}/video/tasks/{task_id}",
headers=headers,
timeout=10
)
status_response.raise_for_status()
task_status = status_response.json()['data']
if task_status['status'] == 'SUCCESS':
return task_status['result']['data']
elif task_status['status'] in ['FAILURE', 'RETRY']:
raise Exception(f"任务失败: {task_status.get('error')}")
retry_count += 1
time.sleep(2)
except requests.RequestException as e:
logger.warning(f"获取任务状态失败，重试中: {str(e)}")
retry_count += 1
time.sleep(2)
continue
raise Exception("任务执行超时")
finally:
# 清理临时文件
try:
if os.path.exists(zip_path):
os.remove(zip_path)
except Exception as e:
logger.warning(f"清理临时文件失败: {str(e)}")
def _get_batch_files(
self,
keyframe_files: List[str],

13
app/utils/ffmpeg_utils.py
View File

@ -274,7 +274,7 @@ def detect_hardware_acceleration() -> Dict[str, Union[bool, str, List[str], None
_FFMPEG_HW_ACCEL_INFO["platform"] = system
_FFMPEG_HW_ACCEL_INFO["gpu_vendor"] = gpu_vendor
logger.info(f"检测硬件加速 - 平台: {system}, GPU厂商: {gpu_vendor}")
logger.debug(f"检测硬件加速 - 平台: {system}, GPU厂商: {gpu_vendor}")
# 获取FFmpeg支持的硬件加速器列表
try:
@ -338,7 +338,7 @@ def detect_hardware_acceleration() -> Dict[str, Union[bool, str, List[str], None
_FFMPEG_HW_ACCEL_INFO["is_dedicated_gpu"] = gpu_vendor in ["nvidia", "amd"] or (gpu_vendor == "intel" and "arc" in _get_gpu_info().lower())
_FFMPEG_HW_ACCEL_INFO["message"] = f"使用 {method} 硬件加速 ({gpu_vendor} GPU)"
logger.info(f"硬件加速检测成功: {method} ({gpu_vendor})")
logger.debug(f"硬件加速检测成功: {method} ({gpu_vendor})")
break
# 如果没有找到硬件加速，设置软件编码作为备用
@ -346,7 +346,7 @@ def detect_hardware_acceleration() -> Dict[str, Union[bool, str, List[str], None
_FFMPEG_HW_ACCEL_INFO["fallback_available"] = True
_FFMPEG_HW_ACCEL_INFO["fallback_encoder"] = "libx264"
_FFMPEG_HW_ACCEL_INFO["message"] = f"未找到可用的硬件加速，将使用软件编码 (平台: {system}, GPU: {gpu_vendor})"
logger.info("未检测到硬件加速，将使用软件编码")
logger.debug("未检测到硬件加速，将使用软件编码")
finally:
# 清理测试文件
@ -1106,9 +1106,12 @@ def get_hwaccel_status() -> Dict[str, any]:
def _auto_reset_on_import():
"""模块导入时自动重置硬件加速检测"""
try:
# 检查是否需要重置（比如检测到配置变化）
# 只在平台真正改变时才重置，而不是初始化时
current_platform = platform.system()
if _FFMPEG_HW_ACCEL_INFO.get("platform") != current_platform:
cached_platform = _FFMPEG_HW_ACCEL_INFO.get("platform")
# 只有当已经有缓存的平台信息，且平台改变了，才需要重置
if cached_platform is not None and cached_platform != current_platform:
reset_hwaccel_detection()
except Exception as e:
logger.debug(f"自动重置检测失败: {str(e)}")

185
config.example.toml
View File

@ -1,117 +1,113 @@
[app]
project_version="0.7.2"
# 模型验证模式配置
# true: 严格模式，只允许使用预定义支持列表中的模型（默认）
# false: 宽松模式，允许使用任何模型名称，仅记录警告
strict_model_validation = true
project_version="0.7.3"
# LLM API 超时配置（秒）
# 视觉模型基础超时时间
llm_vision_timeout = 120
# 文本模型基础超时时间（解说文案生成等复杂任务需要更长时间）
llm_text_timeout = 180
# API 重试次数
llm_max_retries = 3
llm_vision_timeout = 120 # 视觉模型基础超时时间
llm_text_timeout = 180 # 文本模型基础超时时间（解说文案生成等复杂任务需要更长时间）
llm_max_retries = 3 # API 重试次数（LiteLLM 会自动处理重试）
# 支持视频理解的大模型提供商
# gemini (谷歌, 需要 VPN)
# siliconflow (硅基流动)
# qwenvl (通义千问)
vision_llm_provider="gemini"
##########################################
# 🚀 LLM 配置 - 使用 LiteLLM 统一接口
##########################################
# LiteLLM 是统一的 LLM 接口库，支持 100+ providers
# 优势：
# ✅ 代码量减少 80%，统一的 API 接口
# ✅ 自动重试和智能错误处理
# ✅ 内置成本追踪和 token 统计
# ✅ 支持更多 providers：OpenAI, Anthropic, Gemini, Qwen, DeepSeek,
# Cohere, Together AI, Replicate, Groq, Mistral 等
#
# 文档：https://docs.litellm.ai/
# 支持的模型：https://docs.litellm.ai/docs/providers
########## Gemini 视觉模型
vision_gemini_api_key = ""
vision_gemini_model_name = "gemini-2.0-flash-lite"
# ===== 视觉模型配置 =====
vision_llm_provider = "litellm"
########## QwenVL 视觉模型
vision_qwenvl_api_key = ""
vision_qwenvl_model_name = "qwen2.5-vl-32b-instruct"
vision_qwenvl_base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
# 模型格式：provider/model_name
# 常用视觉模型示例：
# - Gemini: gemini/gemini-2.0-flash-lite (推荐，速度快成本低)
# - Gemini: gemini/gemini-1.5-pro (高精度)
# - OpenAI: gpt-4o, gpt-4o-mini
# - Qwen: qwen/qwen2.5-vl-32b-instruct
# - SiliconFlow: siliconflow/Qwen/Qwen2.5-VL-32B-Instruct
vision_litellm_model_name = "gemini/gemini-2.0-flash-lite"
vision_litellm_api_key = "" # 填入对应 provider 的 API key
vision_litellm_base_url = "" # 可选：自定义 API base URL
########## siliconflow 视觉模型
vision_siliconflow_api_key = ""
vision_siliconflow_model_name = "Qwen/Qwen2.5-VL-32B-Instruct"
vision_siliconflow_base_url = "https://api.siliconflow.cn/v1"
# ===== 文本模型配置 =====
text_llm_provider = "litellm"
########## OpenAI 视觉模型
vision_openai_api_key = ""
vision_openai_model_name = "gpt-4.1-nano-2025-04-14"
vision_openai_base_url = "https://api.openai.com/v1"
# 常用文本模型示例：
# - DeepSeek: deepseek/deepseek-chat (推荐，性价比高)
# - DeepSeek: deepseek/deepseek-reasoner (推理能力强)
# - Gemini: gemini/gemini-2.0-flash (速度快)
# - OpenAI: gpt-4o, gpt-4o-mini, gpt-4-turbo
# - Qwen: qwen/qwen-plus, qwen/qwen-turbo
# - SiliconFlow: siliconflow/deepseek-ai/DeepSeek-R1
# - Moonshot: moonshot/moonshot-v1-8k
text_litellm_model_name = "deepseek/deepseek-chat"
text_litellm_api_key = "" # 填入对应 provider 的 API key
text_litellm_base_url = "" # 可选：自定义 API base URL
########### NarratoAPI 微调模型 (未发布)
narrato_api_key = ""
narrato_api_url = ""
narrato_model = "narra-1.0-2025-05-09"
# ===== API Keys 参考 =====
# 主流 LLM Providers API Key 获取地址：
#
# OpenAI: https://platform.openai.com/api-keys
# Gemini: https://makersuite.google.com/app/apikey
# DeepSeek: https://platform.deepseek.com/api_keys
# Qwen (阿里): https://bailian.console.aliyun.com/?tab=model#/api-key
# SiliconFlow: https://cloud.siliconflow.cn/account/ak (手机号注册)
# Moonshot: https://platform.moonshot.cn/console/api-keys
# Anthropic: https://console.anthropic.com/settings/keys
# Cohere: https://dashboard.cohere.com/api-keys
# Together AI: https://api.together.xyz/settings/api-keys
# 用于生成文案的大模型支持的提供商 (Supported providers):
# openai (默认, 需要 VPN)
# siliconflow (硅基流动)
# deepseek (深度求索)
# gemini (谷歌, 需要 VPN)
# qwen (通义千问)
# moonshot (月之暗面)
text_llm_provider="gemini"
##########################################
# 🔧 高级配置（可选）
##########################################
########## OpenAI API Key
# Get your API key at https://platform.openai.com/api-keys
text_openai_api_key = ""
text_openai_base_url = "https://api.openai.com/v1"
text_openai_model_name = "gpt-4.1-mini-2025-04-14"
# 使用 硅基流动 第三方 API Key，使用手机号注册：https://cloud.siliconflow.cn/i/pyOKqFCV
# 访问 https://cloud.siliconflow.cn/account/ak 获取你的 API 密钥
text_siliconflow_api_key = ""
text_siliconflow_base_url = "https://api.siliconflow.cn/v1"
text_siliconflow_model_name = "deepseek-ai/DeepSeek-R1"
########## DeepSeek API Key
# 访问 https://platform.deepseek.com/api_keys 获取你的 API 密钥
text_deepseek_api_key = ""
text_deepseek_base_url = "https://api.deepseek.com"
text_deepseek_model_name = "deepseek-chat"
########## Gemini API Key
text_gemini_api_key=""
text_gemini_model_name = "gemini-2.0-flash"
text_gemini_base_url = "https://generativelanguage.googleapis.com/v1beta"
########## Qwen API Key
# 访问 https://bailian.console.aliyun.com/?tab=model#/api-key 获取你的 API 密钥
text_qwen_api_key = ""
text_qwen_model_name = "qwen-plus-1127"
text_qwen_base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
########## Moonshot API Key
# 访问 https://platform.moonshot.cn/console/api-keys 获取你的 API 密钥
text_moonshot_api_key=""
text_moonshot_base_url = "https://api.moonshot.cn/v1"
text_moonshot_model_name = "moonshot-v1-8k"
# webui界面是否显示配置项
# WebUI 界面是否显示配置项
hide_config = true
##########################################
# 📚 传统配置示例（仅供参考，不推荐使用）
##########################################
# 如果需要使用传统的单独 provider 实现，可以参考以下配置
# 但强烈推荐使用上面的 LiteLLM 配置
#
# 传统视觉模型配置示例：
# vision_llm_provider = "gemini" # 可选：gemini, qwenvl, siliconflow
# vision_gemini_api_key = ""
# vision_gemini_model_name = "gemini-2.0-flash-lite"
#
# 传统文本模型配置示例：
# text_llm_provider = "openai" # 可选：openai, gemini, qwen, deepseek, siliconflow, moonshot
# text_openai_api_key = ""
# text_openai_model_name = "gpt-4o-mini"
# text_openai_base_url = "https://api.openai.com/v1"
##########################################
# TTS (文本转语音) 配置
##########################################
[azure]
# Azure TTS 配置
# 获取密钥：https://portal.azure.com
speech_key = ""
speech_region = ""
[tencent]
# 腾讯云 TTS 配置
# 访问 https://console.cloud.tencent.com/cam/capi 获取你的密钥
# 访问 https://console.cloud.tencent.com/cam/capi 获取密钥
secret_id = ""
secret_key = ""
# 地域配置，默认为 ap-beijing
region = "ap-beijing"
region = "ap-beijing" # 地域配置
[soulvoice]
# SoulVoice TTS API 密钥
# SoulVoice TTS API 配置
api_key = ""
# 音色 URI（必需）
voice_uri = "speech:mcg3fdnx:clzkyf4vy00e5qr6hywum4u84:bzznlkuhcjzpbosexitr"
# API 接口地址（可选，默认值如下）
api_url = "https://tts.scsmtech.cn/tts"
# 默认模型（可选）
model = "FunAudioLLM/CosyVoice2-0.5B"
[tts_qwen]
@ -121,7 +117,8 @@
model_name = "qwen3-tts-flash"
[ui]
# TTS引擎选择 (edge_tts, azure_speech, soulvoice, tencent_tts, tts_qwen)
# TTS 引擎选择
# 可选：edge_tts, azure_speech, soulvoice, tencent_tts, tts_qwen
tts_engine = "edge_tts"
# Edge TTS 配置
@ -136,14 +133,24 @@
azure_rate = 1.0
azure_pitch = 0
##########################################
# 代理和网络配置
##########################################
[proxy]
# HTTP/HTTPS 代理配置（如需要）
# clash 默认地址：http://127.0.0.1:7890
http = ""
https = ""
enabled = false
##########################################
# 视频处理配置
##########################################
[frames]
# 提取关键帧的间隔时间
# 提取关键帧的间隔时间（秒）
frame_interval_input = 3
# 大模型单次处理的关键帧数量
vision_batch_size = 10

2
project_version
View File

@ -1 +1 @@
0.7.2
0.7.3

3
requirements.txt
View File

@ -12,7 +12,8 @@ pysrt==1.1.2
# AI 服务依赖
openai>=1.77.0
google-generativeai>=0.8.5
litellm>=1.70.0 # 统一的 LLM 接口，支持 100+ providers
google-generativeai>=0.8.5 # LiteLLM 会使用此库调用 Gemini
azure-cognitiveservices-speech>=1.37.0
tencentcloud-sdk-python>=3.0.1200
dashscope>=1.24.6

48
webui.py
View File

@ -35,7 +35,7 @@ def init_log():
"""初始化日志配置"""
from loguru import logger
logger.remove()
_lvl = "DEBUG"
_lvl = "INFO" # 改为 INFO 级别，过滤掉 DEBUG 日志
def format_record(record):
# 简化日志格式化处理，不尝试按特定字符串过滤torch相关内容
@ -50,13 +50,23 @@ def init_log():
'- <level>{message}</>' + "\n"
return _format
# 替换为更简单的过滤方式，避免在过滤时访问message内容
# 此处先不设置复杂的过滤器，等应用启动后再动态添加
# 添加日志过滤器
def log_filter(record):
"""过滤不必要的日志消息"""
# 过滤掉启动时的噪音日志（即使在 DEBUG 模式下也可以选择过滤）
ignore_patterns = [
"Examining the path of torch.classes raised",
"torch.cuda.is_available()",
"CUDA initialization"
]
return not any(pattern in record["message"] for pattern in ignore_patterns)
logger.add(
sys.stdout,
level=_lvl,
format=format_record,
colorize=True
colorize=True,
filter=log_filter
)
# 应用启动后，可以再添加更复杂的过滤器
@ -190,23 +200,37 @@ def render_generate_button():
logger.info(tr("视频生成完成"))
# 全局变量，记录是否已经打印过硬件加速信息
_HAS_LOGGED_HWACCEL_INFO = False
def main():
"""主函数"""
global _HAS_LOGGED_HWACCEL_INFO
init_log()
init_global_state()
# 检测FFmpeg硬件加速，但只打印一次日志
# ===== 显式注册 LLM 提供商（最佳实践）=====
# 在应用启动时立即注册，确保所有 LLM 功能可用
if 'llm_providers_registered' not in st.session_state:
try:
from app.services.llm.providers import register_all_providers
register_all_providers()
st.session_state['llm_providers_registered'] = True
logger.info("✅ LLM 提供商注册成功")
except Exception as e:
logger.error(f"❌ LLM 提供商注册失败: {str(e)}")
import traceback
logger.error(traceback.format_exc())
st.error(f"⚠️ LLM 初始化失败: {str(e)}\n\n请检查配置文件和依赖是否正确安装。")
# 不抛出异常，允许应用继续运行（但 LLM 功能不可用）
# 检测FFmpeg硬件加速，但只打印一次日志（使用 session_state 持久化）
if 'hwaccel_logged' not in st.session_state:
st.session_state['hwaccel_logged'] = False
hwaccel_info = ffmpeg_utils.detect_hardware_acceleration()
if not _HAS_LOGGED_HWACCEL_INFO:
if not st.session_state['hwaccel_logged']:
if hwaccel_info["available"]:
logger.info(f"FFmpeg硬件加速检测结果: 可用 | 类型: {hwaccel_info['type']} | 编码器: {hwaccel_info['encoder']} | 独立显卡: {hwaccel_info['is_dedicated_gpu']} | 参数: {hwaccel_info['hwaccel_args']}")
logger.info(f"FFmpeg硬件加速检测结果: 可用 | 类型: {hwaccel_info['type']} | 编码器: {hwaccel_info['encoder']} | 独立显卡: {hwaccel_info['is_dedicated_gpu']}")
else:
logger.warning(f"FFmpeg硬件加速不可用: {hwaccel_info['message']}, 将使用CPU软件编码")
_HAS_LOGGED_HWACCEL_INFO = True
st.session_state['hwaccel_logged'] = True
# 仅初始化基本资源，避免过早地加载依赖PyTorch的资源
# 检查是否能分解utils.init_resources()为基本资源和高级资源(如依赖PyTorch的资源)

2
webui/components/audio_settings.py
View File

@ -457,6 +457,8 @@ def render_tencent_tts_settings(tr):
help="调节语音速度 (0.5-2.0)"
)
config.ui["voice_name"] = saved_voice_type # 兼容性
# 显示音色说明
with st.expander("💡 腾讯云 TTS 音色说明", expanded=False):
st.write("**女声音色：**")

545
webui/components/basic_settings.py
View File

@ -39,6 +39,49 @@ def validate_model_name(model_name: str, provider: str) -> tuple[bool, str]:
return True, ""
def validate_litellm_model_name(model_name: str, model_type: str) -> tuple[bool, str]:
"""验证 LiteLLM 模型名称格式
Args:
model_name: 模型名称，应为 provider/model 格式
model_type: 模型类型（如"视频分析"、"文案生成"）
Returns:
(是否有效, 错误消息)
"""
if not model_name or not model_name.strip():
return False, f"{model_type} 模型名称不能为空"
model_name = model_name.strip()
# LiteLLM 推荐格式：provider/model（如 gemini/gemini-2.0-flash-lite）
# 但也支持直接的模型名称（如 gpt-4o，LiteLLM 会自动推断 provider）
# 检查是否包含 provider 前缀（推荐格式）
if "/" in model_name:
parts = model_name.split("/")
if len(parts) < 2 or not parts[0] or not parts[1]:
return False, f"{model_type} 模型名称格式错误。推荐格式: provider/model （如 gemini/gemini-2.0-flash-lite）"
# 验证 provider 名称（只允许字母、数字、下划线、连字符）
provider = parts[0]
if not provider.replace("-", "").replace("_", "").isalnum():
return False, f"{model_type} Provider 名称只能包含字母、数字、下划线和连字符"
else:
# 直接模型名称也是有效的（LiteLLM 会自动推断）
# 但给出警告建议使用完整格式
logger.debug(f"{model_type} 模型名称未包含 provider 前缀，LiteLLM 将自动推断")
# 基本长度检查
if len(model_name) < 3:
return False, f"{model_type} 模型名称过短"
if len(model_name) > 200:
return False, f"{model_type} 模型名称过长"
return True, ""
def show_config_validation_errors(errors: list):
"""显示配置验证错误"""
if errors:
@ -234,87 +277,244 @@ def test_vision_model_connection(api_key, base_url, model_name, provider, tr):
return False, f"{tr('QwenVL model is not available')}: {str(e)}"
def test_litellm_vision_model(api_key: str, base_url: str, model_name: str, tr) -> tuple[bool, str]:
"""测试 LiteLLM 视觉模型连接
Args:
api_key: API 密钥
base_url: 基础 URL（可选）
model_name: 模型名称（LiteLLM 格式：provider/model）
tr: 翻译函数
Returns:
(连接是否成功, 测试结果消息)
"""
try:
import litellm
import os
import base64
import io
from PIL import Image
logger.debug(f"LiteLLM 视觉模型连通性测试: model={model_name}, api_key={api_key[:10]}..., base_url={base_url}")
# 提取 provider 名称
provider = model_name.split("/")[0] if "/" in model_name else "unknown"
# 设置 API key 到环境变量
env_key_mapping = {
"gemini": "GEMINI_API_KEY",
"google": "GEMINI_API_KEY",
"openai": "OPENAI_API_KEY",
"qwen": "QWEN_API_KEY",
"dashscope": "DASHSCOPE_API_KEY",
"siliconflow": "SILICONFLOW_API_KEY",
}
env_var = env_key_mapping.get(provider.lower(), f"{provider.upper()}_API_KEY")
old_key = os.environ.get(env_var)
os.environ[env_var] = api_key
try:
# 创建测试图片（1x1 白色像素）
test_image = Image.new('RGB', (1, 1), color='white')
img_buffer = io.BytesIO()
test_image.save(img_buffer, format='JPEG')
img_bytes = img_buffer.getvalue()
base64_image = base64.b64encode(img_bytes).decode('utf-8')
# 构建测试请求
messages = [{
"role": "user",
"content": [
{"type": "text", "text": "请直接回复'连接成功'"},
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{base64_image}"
}
}
]
}]
# 准备参数
completion_kwargs = {
"model": model_name,
"messages": messages,
"temperature": 0.1,
"max_tokens": 50
}
if base_url:
completion_kwargs["api_base"] = base_url
# 调用 LiteLLM（同步调用用于测试）
response = litellm.completion(**completion_kwargs)
if response and response.choices and len(response.choices) > 0:
return True, f"LiteLLM 视觉模型连接成功 ({model_name})"
else:
return False, f"LiteLLM 视觉模型返回空响应"
finally:
# 恢复原始环境变量
if old_key:
os.environ[env_var] = old_key
else:
os.environ.pop(env_var, None)
except Exception as e:
error_msg = str(e)
logger.error(f"LiteLLM 视觉模型测试失败: {error_msg}")
# 提供更友好的错误信息
if "authentication" in error_msg.lower() or "api_key" in error_msg.lower():
return False, f"认证失败，请检查 API Key 是否正确"
elif "not found" in error_msg.lower() or "404" in error_msg:
return False, f"模型不存在，请检查模型名称是否正确"
elif "rate limit" in error_msg.lower():
return False, f"超出速率限制，请稍后重试"
else:
return False, f"连接失败: {error_msg}"
def test_litellm_text_model(api_key: str, base_url: str, model_name: str, tr) -> tuple[bool, str]:
"""测试 LiteLLM 文本模型连接
Args:
api_key: API 密钥
base_url: 基础 URL（可选）
model_name: 模型名称（LiteLLM 格式：provider/model）
tr: 翻译函数
Returns:
(连接是否成功, 测试结果消息)
"""
try:
import litellm
import os
logger.debug(f"LiteLLM 文本模型连通性测试: model={model_name}, api_key={api_key[:10]}..., base_url={base_url}")
# 提取 provider 名称
provider = model_name.split("/")[0] if "/" in model_name else "unknown"
# 设置 API key 到环境变量
env_key_mapping = {
"gemini": "GEMINI_API_KEY",
"google": "GEMINI_API_KEY",
"openai": "OPENAI_API_KEY",
"qwen": "QWEN_API_KEY",
"dashscope": "DASHSCOPE_API_KEY",
"siliconflow": "SILICONFLOW_API_KEY",
"deepseek": "DEEPSEEK_API_KEY",
"moonshot": "MOONSHOT_API_KEY",
}
env_var = env_key_mapping.get(provider.lower(), f"{provider.upper()}_API_KEY")
old_key = os.environ.get(env_var)
os.environ[env_var] = api_key
try:
# 构建测试请求
messages = [
{"role": "user", "content": "请直接回复'连接成功'"}
]
# 准备参数
completion_kwargs = {
"model": model_name,
"messages": messages,
"temperature": 0.1,
"max_tokens": 20
}
if base_url:
completion_kwargs["api_base"] = base_url
# 调用 LiteLLM（同步调用用于测试）
response = litellm.completion(**completion_kwargs)
if response and response.choices and len(response.choices) > 0:
return True, f"LiteLLM 文本模型连接成功 ({model_name})"
else:
return False, f"LiteLLM 文本模型返回空响应"
finally:
# 恢复原始环境变量
if old_key:
os.environ[env_var] = old_key
else:
os.environ.pop(env_var, None)
except Exception as e:
error_msg = str(e)
logger.error(f"LiteLLM 文本模型测试失败: {error_msg}")
# 提供更友好的错误信息
if "authentication" in error_msg.lower() or "api_key" in error_msg.lower():
return False, f"认证失败，请检查 API Key 是否正确"
elif "not found" in error_msg.lower() or "404" in error_msg:
return False, f"模型不存在，请检查模型名称是否正确"
elif "rate limit" in error_msg.lower():
return False, f"超出速率限制，请稍后重试"
else:
return False, f"连接失败: {error_msg}"
def render_vision_llm_settings(tr):
"""渲染视频分析模型设置"""
"""渲染视频分析模型设置（LiteLLM 统一配置）"""
st.subheader(tr("Vision Model Settings"))
# 视频分析模型提供商选择
vision_providers = ['Siliconflow', 'Gemini', 'Gemini(OpenAI)', 'QwenVL', 'OpenAI']
saved_vision_provider = config.app.get("vision_llm_provider", "Gemini").lower()
saved_provider_index = 0
# 固定使用 LiteLLM 提供商
config.app["vision_llm_provider"] = "litellm"
for i, provider in enumerate(vision_providers):
if provider.lower() == saved_vision_provider:
saved_provider_index = i
break
# 获取已保存的 LiteLLM 配置
vision_model_name = config.app.get("vision_litellm_model_name", "gemini/gemini-2.0-flash-lite")
vision_api_key = config.app.get("vision_litellm_api_key", "")
vision_base_url = config.app.get("vision_litellm_base_url", "")
vision_provider = st.selectbox(
tr("Vision Model Provider"),
options=vision_providers,
index=saved_provider_index
# 渲染配置输入框
st_vision_model_name = st.text_input(
tr("Vision Model Name"),
value=vision_model_name,
help="LiteLLM 模型格式: provider/model\n\n"
"常用示例:\n"
"• gemini/gemini-2.0-flash-lite (推荐，速度快)\n"
"• gemini/gemini-1.5-pro (高精度)\n"
"• openai/gpt-4o, openai/gpt-4o-mini\n"
"• qwen/qwen2.5-vl-32b-instruct\n"
"• siliconflow/Qwen/Qwen2.5-VL-32B-Instruct\n\n"
"支持 100+ providers，详见: https://docs.litellm.ai/docs/providers"
)
vision_provider = vision_provider.lower()
config.app["vision_llm_provider"] = vision_provider
st.session_state['vision_llm_providers'] = vision_provider
# 获取已保存的视觉模型配置
# 处理特殊的提供商名称映射
if vision_provider == 'gemini(openai)':
vision_config_key = 'vision_gemini_openai'
else:
vision_config_key = f'vision_{vision_provider}'
st_vision_api_key = st.text_input(
tr("Vision API Key"),
value=vision_api_key,
type="password",
help="对应 provider 的 API 密钥\n\n"
"获取地址:\n"
"• Gemini: https://makersuite.google.com/app/apikey\n"
"• OpenAI: https://platform.openai.com/api-keys\n"
"• Qwen: https://bailian.console.aliyun.com/\n"
"• SiliconFlow: https://cloud.siliconflow.cn/account/ak"
)
vision_api_key = config.app.get(f"{vision_config_key}_api_key", "")
vision_base_url = config.app.get(f"{vision_config_key}_base_url", "")
vision_model_name = config.app.get(f"{vision_config_key}_model_name", "")
st_vision_base_url = st.text_input(
tr("Vision Base URL"),
value=vision_base_url,
help="自定义 API 端点（可选）\n\n"
"留空使用默认端点。可用于:\n"
"• 代理地址（如通过 CloudFlare）\n"
"• 私有部署的模型服务\n"
"• 自定义网关\n\n"
"示例: https://your-proxy.com/v1"
)
# 渲染视觉模型配置输入框
st_vision_api_key = st.text_input(tr("Vision API Key"), value=vision_api_key, type="password")
# 根据不同提供商设置默认值和帮助信息
if vision_provider == 'gemini':
st_vision_base_url = st.text_input(
tr("Vision Base URL"),
value=vision_base_url or "https://generativelanguage.googleapis.com/v1beta",
help=tr("原生Gemini API端点，默认: https://generativelanguage.googleapis.com/v1beta")
)
st_vision_model_name = st.text_input(
tr("Vision Model Name"),
value=vision_model_name or "gemini-2.0-flash-exp",
help=tr("原生Gemini模型，默认: gemini-2.0-flash-exp")
)
elif vision_provider == 'gemini(openai)':
st_vision_base_url = st.text_input(
tr("Vision Base URL"),
value=vision_base_url or "https://generativelanguage.googleapis.com/v1beta/openai",
help=tr("OpenAI兼容的Gemini代理端点，如: https://your-proxy.com/v1")
)
st_vision_model_name = st.text_input(
tr("Vision Model Name"),
value=vision_model_name or "gemini-2.0-flash-exp",
help=tr("OpenAI格式的Gemini模型名称，默认: gemini-2.0-flash-exp")
)
elif vision_provider == 'qwenvl':
st_vision_base_url = st.text_input(
tr("Vision Base URL"),
value=vision_base_url,
help=tr("Default: https://dashscope.aliyuncs.com/compatible-mode/v1")
)
st_vision_model_name = st.text_input(
tr("Vision Model Name"),
value=vision_model_name or "qwen-vl-max-latest",
help=tr("Default: qwen-vl-max-latest")
)
else:
st_vision_base_url = st.text_input(tr("Vision Base URL"), value=vision_base_url)
st_vision_model_name = st.text_input(tr("Vision Model Name"), value=vision_model_name)
# 在配置输入框后添加测试按钮
# 添加测试连接按钮
if st.button(tr("Test Connection"), key="test_vision_connection"):
# 先验证配置
test_errors = []
if not st_vision_api_key:
test_errors.append("请先输入API密钥")
test_errors.append("请先输入 API 密钥")
if not st_vision_model_name:
test_errors.append("请先输入模型名称")
@ -324,11 +524,10 @@ def render_vision_llm_settings(tr):
else:
with st.spinner(tr("Testing connection...")):
try:
success, message = test_vision_model_connection(
success, message = test_litellm_vision_model(
api_key=st_vision_api_key,
base_url=st_vision_base_url,
model_name=st_vision_model_name,
provider=vision_provider,
tr=tr
)
@ -338,38 +537,38 @@ def render_vision_llm_settings(tr):
st.error(message)
except Exception as e:
st.error(f"测试连接时发生错误: {str(e)}")
logger.error(f"视频分析模型连接测试失败: {str(e)}")
logger.error(f"LiteLLM 视频分析模型连接测试失败: {str(e)}")
# 验证和保存视觉模型配置
# 验证和保存配置
validation_errors = []
config_changed = False
# 验证API密钥
if st_vision_api_key:
is_valid, error_msg = validate_api_key(st_vision_api_key, f"视频分析({vision_provider})")
if is_valid:
config.app[f"{vision_config_key}_api_key"] = st_vision_api_key
st.session_state[f"{vision_config_key}_api_key"] = st_vision_api_key
config_changed = True
else:
validation_errors.append(error_msg)
# 验证Base URL
if st_vision_base_url:
is_valid, error_msg = validate_base_url(st_vision_base_url, f"视频分析({vision_provider})")
if is_valid:
config.app[f"{vision_config_key}_base_url"] = st_vision_base_url
st.session_state[f"{vision_config_key}_base_url"] = st_vision_base_url
config_changed = True
else:
validation_errors.append(error_msg)
# 验证模型名称
if st_vision_model_name:
is_valid, error_msg = validate_model_name(st_vision_model_name, f"视频分析({vision_provider})")
is_valid, error_msg = validate_litellm_model_name(st_vision_model_name, "视频分析")
if is_valid:
config.app[f"{vision_config_key}_model_name"] = st_vision_model_name
st.session_state[f"{vision_config_key}_model_name"] = st_vision_model_name
config.app["vision_litellm_model_name"] = st_vision_model_name
st.session_state["vision_litellm_model_name"] = st_vision_model_name
config_changed = True
else:
validation_errors.append(error_msg)
# 验证 API 密钥
if st_vision_api_key:
is_valid, error_msg = validate_api_key(st_vision_api_key, "视频分析")
if is_valid:
config.app["vision_litellm_api_key"] = st_vision_api_key
st.session_state["vision_litellm_api_key"] = st_vision_api_key
config_changed = True
else:
validation_errors.append(error_msg)
# 验证 Base URL（可选）
if st_vision_base_url:
is_valid, error_msg = validate_base_url(st_vision_base_url, "视频分析")
if is_valid:
config.app["vision_litellm_base_url"] = st_vision_base_url
st.session_state["vision_litellm_base_url"] = st_vision_base_url
config_changed = True
else:
validation_errors.append(error_msg)
@ -377,12 +576,12 @@ def render_vision_llm_settings(tr):
# 显示验证错误
show_config_validation_errors(validation_errors)
# 如果配置有变化且没有验证错误，保存到文件
# 保存配置
if config_changed and not validation_errors:
try:
config.save_config()
if st_vision_api_key or st_vision_base_url or st_vision_model_name:
st.success(f"视频分析模型({vision_provider})配置已保存")
st.success(f"视频分析模型配置已保存（LiteLLM）")
except Exception as e:
st.error(f"保存配置失败: {str(e)}")
logger.error(f"保存视频分析配置失败: {str(e)}")
@ -492,68 +691,62 @@ def test_text_model_connection(api_key, base_url, model_name, provider, tr):
def render_text_llm_settings(tr):
"""渲染文案生成模型设置"""
"""渲染文案生成模型设置（LiteLLM 统一配置）"""
st.subheader(tr("Text Generation Model Settings"))
# 文案生成模型提供商选择
text_providers = ['OpenAI', 'Siliconflow', 'DeepSeek', 'Gemini', 'Gemini(OpenAI)', 'Qwen', 'Moonshot']
saved_text_provider = config.app.get("text_llm_provider", "OpenAI").lower()
saved_provider_index = 0
# 固定使用 LiteLLM 提供商
config.app["text_llm_provider"] = "litellm"
for i, provider in enumerate(text_providers):
if provider.lower() == saved_text_provider:
saved_provider_index = i
break
# 获取已保存的 LiteLLM 配置
text_model_name = config.app.get("text_litellm_model_name", "deepseek/deepseek-chat")
text_api_key = config.app.get("text_litellm_api_key", "")
text_base_url = config.app.get("text_litellm_base_url", "")
text_provider = st.selectbox(
tr("Text Model Provider"),
options=text_providers,
index=saved_provider_index
# 渲染配置输入框
st_text_model_name = st.text_input(
tr("Text Model Name"),
value=text_model_name,
help="LiteLLM 模型格式: provider/model\n\n"
"常用示例:\n"
"• deepseek/deepseek-chat (推荐，性价比高)\n"
"• gemini/gemini-2.0-flash (速度快)\n"
"• openai/gpt-4o, openai/gpt-4o-mini\n"
"• qwen/qwen-plus, qwen/qwen-turbo\n"
"• siliconflow/deepseek-ai/DeepSeek-R1\n"
"• moonshot/moonshot-v1-8k\n\n"
"支持 100+ providers，详见: https://docs.litellm.ai/docs/providers"
)
text_provider = text_provider.lower()
config.app["text_llm_provider"] = text_provider
# 获取已保存的文本模型配置
text_api_key = config.app.get(f"text_{text_provider}_api_key")
text_base_url = config.app.get(f"text_{text_provider}_base_url")
text_model_name = config.app.get(f"text_{text_provider}_model_name")
st_text_api_key = st.text_input(
tr("Text API Key"),
value=text_api_key,
type="password",
help="对应 provider 的 API 密钥\n\n"
"获取地址:\n"
"• DeepSeek: https://platform.deepseek.com/api_keys\n"
"• Gemini: https://makersuite.google.com/app/apikey\n"
"• OpenAI: https://platform.openai.com/api-keys\n"
"• Qwen: https://bailian.console.aliyun.com/\n"
"• SiliconFlow: https://cloud.siliconflow.cn/account/ak\n"
"• Moonshot: https://platform.moonshot.cn/console/api-keys"
)
# 渲染文本模型配置输入框
st_text_api_key = st.text_input(tr("Text API Key"), value=text_api_key, type="password")
st_text_base_url = st.text_input(
tr("Text Base URL"),
value=text_base_url,
help="自定义 API 端点（可选）\n\n"
"留空使用默认端点。可用于:\n"
"• 代理地址（如通过 CloudFlare）\n"
"• 私有部署的模型服务\n"
"• 自定义网关\n\n"
"示例: https://your-proxy.com/v1"
)
# 根据不同提供商设置默认值和帮助信息
if text_provider == 'gemini':
st_text_base_url = st.text_input(
tr("Text Base URL"),
value=text_base_url or "https://generativelanguage.googleapis.com/v1beta",
help=tr("原生Gemini API端点，默认: https://generativelanguage.googleapis.com/v1beta")
)
st_text_model_name = st.text_input(
tr("Text Model Name"),
value=text_model_name or "gemini-2.0-flash-exp",
help=tr("原生Gemini模型，默认: gemini-2.0-flash-exp")
)
elif text_provider == 'gemini(openai)':
st_text_base_url = st.text_input(
tr("Text Base URL"),
value=text_base_url or "https://generativelanguage.googleapis.com/v1beta/openai",
help=tr("OpenAI兼容的Gemini代理端点，如: https://your-proxy.com/v1")
)
st_text_model_name = st.text_input(
tr("Text Model Name"),
value=text_model_name or "gemini-2.0-flash-exp",
help=tr("OpenAI格式的Gemini模型名称，默认: gemini-2.0-flash-exp")
)
else:
st_text_base_url = st.text_input(tr("Text Base URL"), value=text_base_url)
st_text_model_name = st.text_input(tr("Text Model Name"), value=text_model_name)
# 添加测试按钮
# 添加测试连接按钮
if st.button(tr("Test Connection"), key="test_text_connection"):
# 先验证配置
test_errors = []
if not st_text_api_key:
test_errors.append("请先输入API密钥")
test_errors.append("请先输入 API 密钥")
if not st_text_model_name:
test_errors.append("请先输入模型名称")
@ -563,11 +756,10 @@ def render_text_llm_settings(tr):
else:
with st.spinner(tr("Testing connection...")):
try:
success, message = test_text_model_connection(
success, message = test_litellm_text_model(
api_key=st_text_api_key,
base_url=st_text_base_url,
model_name=st_text_model_name,
provider=text_provider,
tr=tr
)
@ -577,35 +769,38 @@ def render_text_llm_settings(tr):
st.error(message)
except Exception as e:
st.error(f"测试连接时发生错误: {str(e)}")
logger.error(f"文案生成模型连接测试失败: {str(e)}")
logger.error(f"LiteLLM 文案生成模型连接测试失败: {str(e)}")
# 验证和保存文本模型配置
# 验证和保存配置
text_validation_errors = []
text_config_changed = False
# 验证API密钥
if st_text_api_key:
is_valid, error_msg = validate_api_key(st_text_api_key, f"文案生成({text_provider})")
if is_valid:
config.app[f"text_{text_provider}_api_key"] = st_text_api_key
text_config_changed = True
else:
text_validation_errors.append(error_msg)
# 验证Base URL
if st_text_base_url:
is_valid, error_msg = validate_base_url(st_text_base_url, f"文案生成({text_provider})")
if is_valid:
config.app[f"text_{text_provider}_base_url"] = st_text_base_url
text_config_changed = True
else:
text_validation_errors.append(error_msg)
# 验证模型名称
if st_text_model_name:
is_valid, error_msg = validate_model_name(st_text_model_name, f"文案生成({text_provider})")
is_valid, error_msg = validate_litellm_model_name(st_text_model_name, "文案生成")
if is_valid:
config.app[f"text_{text_provider}_model_name"] = st_text_model_name
config.app["text_litellm_model_name"] = st_text_model_name
st.session_state["text_litellm_model_name"] = st_text_model_name
text_config_changed = True
else:
text_validation_errors.append(error_msg)
# 验证 API 密钥
if st_text_api_key:
is_valid, error_msg = validate_api_key(st_text_api_key, "文案生成")
if is_valid:
config.app["text_litellm_api_key"] = st_text_api_key
st.session_state["text_litellm_api_key"] = st_text_api_key
text_config_changed = True
else:
text_validation_errors.append(error_msg)
# 验证 Base URL（可选）
if st_text_base_url:
is_valid, error_msg = validate_base_url(st_text_base_url, "文案生成")
if is_valid:
config.app["text_litellm_base_url"] = st_text_base_url
st.session_state["text_litellm_base_url"] = st_text_base_url
text_config_changed = True
else:
text_validation_errors.append(error_msg)
@ -613,12 +808,12 @@ def render_text_llm_settings(tr):
# 显示验证错误
show_config_validation_errors(text_validation_errors)
# 如果配置有变化且没有验证错误，保存到文件
# 保存配置
if text_config_changed and not text_validation_errors:
try:
config.save_config()
if st_text_api_key or st_text_base_url or st_text_model_name:
st.success(f"文案生成模型({text_provider})配置已保存")
st.success(f"文案生成模型配置已保存（LiteLLM）")
except Exception as e:
st.error(f"保存配置失败: {str(e)}")
logger.error(f"保存文案生成配置失败: {str(e)}")

8
webui/config/settings.py
View File

@ -40,13 +40,7 @@ class WebUIConfig:
vision_batch_size: int = 5
# 提示词
vision_prompt: str = """..."""
# Narrato API 配置
narrato_api_url: str = "http://127.0.0.1:8000/api/v1/video/analyze"
narrato_api_key: str = ""
narrato_batch_size: int = 10
narrato_vision_model: str = "gemini-1.5-flash"
narrato_llm_model: str = "qwen-plus"
def __post_init__(self):
"""初始化默认值"""
self.ui = self.ui or {}

5
webui/i18n/zh.json
View File

@ -107,9 +107,6 @@
"Vision API Key": "视频分析 API 密钥",
"Vision Base URL": "视频分析接口地址",
"Vision Model Name": "视频分析模型名称",
"Narrato Additional Settings": "Narrato 附加设置",
"Narrato API Key": "Narrato API 密钥",
"Narrato API URL": "Narrato API 地址",
"Text Generation Model Settings": "文案生成模型设置",
"LLM Model Name": "大语言模型名称",
"LLM Model API Key": "大语言模型 API 密钥",
@ -124,8 +121,6 @@
"Test Connection": "测试连接",
"gemini model is available": "Gemini 模型可用",
"gemini model is not available": "Gemini 模型不可用",
"NarratoAPI is available": "NarratoAPI 可用",
"NarratoAPI is not available": "NarratoAPI 不可用",
"Unsupported provider": "不支持的提供商",
"0: Keep the audio only, 1: Keep the original sound only, 2: Keep the original sound and audio": "0: 仅保留音频，1: 仅保留原声，2: 保留原声和音频",
"Text model is not available": "文案生成模型不可用",

50
webui/tools/generate_script_docu.py
View File

@ -120,31 +120,49 @@ def generate_script_docu(params):
"""
2. 视觉分析(批量分析每一帧)
"""
vision_llm_provider = st.session_state.get('vision_llm_providers').lower()
llm_params = dict()
# 最佳实践：使用 get() 的默认值参数 + 从 config 获取备用值
vision_llm_provider = (
st.session_state.get('vision_llm_provider') or
config.app.get('vision_llm_provider', 'litellm')
).lower()
logger.info(f"使用 {vision_llm_provider.upper()} 进行视觉分析")
try:
# ===================初始化视觉分析器===================
update_progress(30, "正在初始化视觉分析器...")
# 从配置中获取相关配置
if vision_llm_provider == 'gemini':
vision_api_key = st.session_state.get('vision_gemini_api_key')
vision_model = st.session_state.get('vision_gemini_model_name')
vision_base_url = st.session_state.get('vision_gemini_base_url')
else:
vision_api_key = st.session_state.get(f'vision_{vision_llm_provider}_api_key')
vision_model = st.session_state.get(f'vision_{vision_llm_provider}_model_name')
vision_base_url = st.session_state.get(f'vision_{vision_llm_provider}_base_url')
# 使用统一的配置键格式获取配置（支持所有 provider）
vision_api_key = (
st.session_state.get(f'vision_{vision_llm_provider}_api_key') or
config.app.get(f'vision_{vision_llm_provider}_api_key')
)
vision_model = (
st.session_state.get(f'vision_{vision_llm_provider}_model_name') or
config.app.get(f'vision_{vision_llm_provider}_model_name')
)
vision_base_url = (
st.session_state.get(f'vision_{vision_llm_provider}_base_url') or
config.app.get(f'vision_{vision_llm_provider}_base_url', '')
)
# 创建视觉分析器实例
# 验证必需配置
if not vision_api_key or not vision_model:
raise ValueError(
f"未配置 {vision_llm_provider} 的 API Key 或模型名称。"
f"请在设置页面配置 vision_{vision_llm_provider}_api_key 和 vision_{vision_llm_provider}_model_name"
)
# 创建视觉分析器实例（使用统一接口）
llm_params = {
"vision_provider": vision_llm_provider,
"vision_api_key": vision_api_key,
"vision_model_name": vision_model,
"vision_base_url": vision_base_url,
"vision_provider": vision_llm_provider,
"vision_api_key": vision_api_key,
"vision_model_name": vision_model,
"vision_base_url": vision_base_url,
}
logger.debug(f"视觉分析器配置: provider={vision_llm_provider}, model={vision_model}")
analyzer = create_vision_analyzer(
provider=vision_llm_provider,
api_key=vision_api_key,

1
webui/tools/generate_script_short.py
View File

@ -40,7 +40,6 @@ def generate_script_short(tr, params, custom_clips=5):
vision_api_key = st.session_state.get(f'vision_{vision_llm_provider}_api_key', "")
vision_model = st.session_state.get(f'vision_{vision_llm_provider}_model_name', "")
vision_base_url = st.session_state.get(f'vision_{vision_llm_provider}_base_url', "")
narrato_api_key = config.app.get('narrato_api_key')
update_progress(20, "开始准备生成脚本")