AIRegulation-DocAnalysis/backend/app/services/llm/llm_factory.py

# src/services/llm/llm_factory.py
"""LLM工厂 - 统一创建和管理LLM客户端"""

from typing import Optional, Dict, Any
from loguru import logger
from functools import lru_cache

from .base_client import BaseLLMClient, LLMConfig, LLMProvider, LLMResponse
from .deepseek_client import DeepSeekClient
from .qwen_client import QwenClient, QwenVLClient


# 默认模型映射
DEFAULT_MODELS = {
    LLMProvider.DEEPSEEK: "deepseek-v4-flash",
    LLMProvider.QWEN: "qwen3.5-flash",
    LLMProvider.QWEN_VL: "qwen3-vl-plus"
}

# API基础URL（使用统一代理服务）
DEFAULT_BASE_URLS = {
    LLMProvider.DEEPSEEK: "http://6.86.80.4:30080/v1",
    LLMProvider.QWEN: "http://6.86.80.4:30080/v1",
    LLMProvider.QWEN_VL: "http://6.86.80.4:30080/v1"
}


class LLMFactory:
    """
    LLM客户端工厂（支持全局缓存）

    支持的提供商和模型：
    - DeepSeek: deepseek-chat (DeepSeek-V3), deepseek-coder
    - Qwen: qwen-turbo, qwen-plus, qwen-max, qwen-long
    - QwenVL: qwen-vl-plus, qwen-vl-max (多模态)

    使用示例：
        factory = LLMFactory()

        # 使用默认配置
        client = factory.create("deepseek")

        # 自定义配置
        client = factory.create("qwen", model="qwen-max", temperature=0.5)

        # 调用LLM
        response = client.complete("你好，介绍一下自己")
    """

    # 全局客户端缓存（类级别，跨实例共享）
    _global_instances: Dict[str, BaseLLMClient] = {}

    def __init__(self):
        self._config_cache: Dict[str, Any] = {}

    def create(
        self,
        provider: str,
        api_key: Optional[str] = None,
        model: Optional[str] = None,
        base_url: Optional[str] = None,
        max_tokens: int = 4096,
        temperature: float = 0.7,
        **kwargs
    ) -> BaseLLMClient:
        """
        创建LLM客户端

        Args:
            provider: 提供商名称 ("deepseek", "qwen", "qwen_vl")
            api_key: API密钥（如未提供，从环境变量获取）
            model: 模型名称（如未提供，使用默认模型）
            base_url: API基础URL
            max_tokens: 最大输出token数
            temperature: 温度参数
            **kwargs: 其他配置参数

        Returns:
            BaseLLMClient: LLM客户端实例
        """
        provider_enum = self._parse_provider(provider)

        # 获取配置
        api_key = api_key or self._get_api_key(provider_enum)
        model = model or DEFAULT_MODELS.get(provider_enum)
        base_url = base_url or DEFAULT_BASE_URLS.get(provider_enum)

        if not api_key:
            raise ValueError(f"缺少API密钥，请设置环境变量或传入api_key参数")

        # 检查全局缓存
        cache_key = f"{provider}_{model}"
        if cache_key in LLMFactory._global_instances:
            logger.debug(f"使用缓存的LLM客户端: {cache_key}")
            return LLMFactory._global_instances[cache_key]

        config = LLMConfig(
            provider=provider_enum,
            model=model,
            api_key=api_key,
            base_url=base_url,
            max_tokens=max_tokens,
            temperature=temperature,
            **kwargs
        )

        # 创建客户端
        client = self._create_client(config)

        # 缓存到全局实例
        LLMFactory._global_instances[cache_key] = client

        logger.info(f"LLM客户端创建成功并缓存: {provider} - {model}")
        return client

    def _parse_provider(self, provider: str) -> LLMProvider:
        """解析提供商名称"""
        provider_map = {
            "deepseek": LLMProvider.DEEPSEEK,
            "deepseek-v3": LLMProvider.DEEPSEEK,
            "deepseek_chat": LLMProvider.DEEPSEEK,
            "qwen": LLMProvider.QWEN,
            "qwen-turbo": LLMProvider.QWEN,
            "qwen-plus": LLMProvider.QWEN,
            "qwen-max": LLMProvider.QWEN,
            "qwen3.5-flash": LLMProvider.QWEN,
            "qwen3.5-plus": LLMProvider.QWEN,
            "qwen_vl": LLMProvider.QWEN_VL,
            "qwen-vl": LLMProvider.QWEN_VL,
            "qwen-vl-plus": LLMProvider.QWEN_VL,
            "qwen-vl-max": LLMProvider.QWEN_VL
        }

        provider_lower = provider.lower()
        if provider_lower not in provider_map:
            raise ValueError(f"不支持的提供商: {provider}，支持的: {list(provider_map.keys())}")

        return provider_map[provider_lower]

    def _get_api_key(self, provider: LLMProvider) -> Optional[str]:
        """从环境变量获取API密钥"""
        import os

        key_map = {
            LLMProvider.DEEPSEEK: ["DEEPSEEK_API_KEY", "OPENAI_API_KEY"],
            LLMProvider.QWEN: ["QWEN_API_KEY", "DASHSCOPE_API_KEY", "ALIBABA_API_KEY"],
            LLMProvider.QWEN_VL: ["QWEN_API_KEY", "DASHSCOPE_API_KEY", "ALIBABA_API_KEY"]
        }

        for key_name in key_map.get(provider, []):
            api_key = os.getenv(key_name)
            if api_key:
                return api_key

        return None

    def _create_client(self, config: LLMConfig) -> BaseLLMClient:
        """创建具体客户端"""
        client_map = {
            LLMProvider.DEEPSEEK: DeepSeekClient,
            LLMProvider.QWEN: QwenClient,
            LLMProvider.QWEN_VL: QwenVLClient
        }

        client_class = client_map.get(config.provider)
        if not client_class:
            raise ValueError(f"不支持的提供商: {config.provider}")

        return client_class(config)

    def get_cached(self, provider: str, model: Optional[str] = None) -> Optional[BaseLLMClient]:
        """获取缓存的客户端"""
        provider_enum = self._parse_provider(provider)
        model = model or DEFAULT_MODELS.get(provider_enum)
        cache_key = f"{provider}_{model}"
        return LLMFactory._global_instances.get(cache_key)

    def list_available_providers(self) -> Dict[str, list]:
        """列出可用的提供商和模型"""
        return {
            "deepseek": DeepSeekClient.SUPPORTED_MODELS,
            "qwen": QwenClient.SUPPORTED_MODELS,
            "qwen_vl": QwenVLClient.SUPPORTED_MODELS
        }

    @classmethod
    def preload_clients(cls, providers: list = None):
        """
        预加载LLM客户端（应用启动时调用）

        Args:
            providers: 要预加载的提供商列表，默认加载qwen和deepseek
        """
        if providers is None:
            providers = ["qwen", "deepseek"]

        factory = cls()
        for provider in providers:
            try:
                client = factory.create(provider)
                logger.success(f"预加载LLM客户端成功: {provider}")
            except Exception as e:
                logger.warning(f"预加载LLM客户端失败: {provider} - {e}")

    @classmethod
    def get_global_client(cls, provider: str, model: Optional[str] = None) -> Optional[BaseLLMClient]:
        """获取全局缓存的客户端"""
        provider_lower = provider.lower()
        # 处理模型名作为provider的情况（如 qwen3.5-flash）
        if provider_lower.startswith("qwen"):
            provider_lower = "qwen"
        model = model or DEFAULT_MODELS.get(LLMProvider.QWEN if provider_lower == "qwen" else LLMProvider.DEEPSEEK)
        cache_key = f"{provider_lower}_{model}"
        return cls._global_instances.get(cache_key)

    @classmethod
    def cleanup(cls):
        """清理所有缓存的客户端"""
        for cache_key, client in cls._global_instances.items():
            try:
                client.close()
                logger.debug(f"关闭LLM客户端: {cache_key}")
            except Exception as e:
                logger.warning(f"关闭LLM客户端失败: {cache_key} - {e}")
        cls._global_instances.clear()
        logger.info("所有LLM客户端已清理")


@lru_cache
def get_llm_factory() -> LLMFactory:
    """获取LLM工厂实例（缓存）"""
    return LLMFactory()


def get_llm_client(
    provider: str = "qwen",
    model: Optional[str] = None,
    **kwargs
) -> BaseLLMClient:
    """
    便捷函数：获取LLM客户端（优先使用缓存）

    Args:
        provider: 提供商名称
        model: 模型名称
        **kwargs: 其他配置

    Returns:
        BaseLLMClient: LLM客户端实例
    """
    factory = get_llm_factory()

    # 先尝试获取缓存的实例
    cached = factory.get_cached(provider, model)
    if cached:
        return cached

    return factory.create(provider, model=model, **kwargs)