refactor: 重构RAG核心组件，简化代码结构和测试文件

backend/app/model_services/__init__.py

@@ -6,9 +6,11 @@
 
 from .embedding_services import get_embedding_service
 from .rerank_services import get_rerank_service, BaseRerankService
+from .chat_services import get_small_llm_service
 
 __all__ = [
     "get_embedding_service",
     "get_rerank_service",
+    "get_small_llm_service",
     "BaseRerankService"
 ]

backend/app/model_services/chat_services.py

@@ -219,51 +219,98 @@ class DeepSeekChatProvider(BaseServiceProvider[BaseChatModel]):
 
 # ========== 轻量级模型 Provider ==========
 
-class ZhipuSmallModelProvider(BaseServiceProvider[BaseChatModel]):
+class LocalSmallModelProvider(BaseServiceProvider[BaseChatModel]):
     """
-    智谱 AI 轻量级模型服务提供者（用于意图分类等简单任务）
-    使用 glm-5.1-flash 或其他小模型
+    本地轻量级模型服务提供者（用于查询改写、意图分类等简单任务）
+    使用小模型独立配置
     """
     
-    def __init__(self, model: str = "glm-5.1-flash"):
-        super().__init__("zhipu_small")
-        self._model = model
+    def __init__(self, model: str = None):
+        from app.config import SMALL_LOCAL_MODEL_NAME, SMALL_VLLM_BASE_URL, SMALL_LLM_API_KEY
+        super().__init__("local_small")
+        self._model = model or SMALL_LOCAL_MODEL_NAME
+        self._base_url = SMALL_VLLM_BASE_URL
+        self._api_key = SMALL_LLM_API_KEY
     
     def is_available(self) -> bool:
-        """检查智谱轻量模型服务是否可用"""
-        if not ZHIPUAI_API_KEY:
-            logger.warning("ZHIPUAI_API_KEY 未配置，轻量模型不可用")
+        """检查本地小模型服务是否可用"""
+        if not self._base_url:
+            logger.warning("SMALL_VLLM_BASE_URL 未配置，本地小模型不可用")
+            return False
+        
+        try:
+            # 先测试主机名能否解析
+            import httpx
+            from urllib.parse import urlparse
+            
+            parsed_url = urlparse(self._base_url)
+            host = parsed_url.hostname
+            port = parsed_url.port or (80 if parsed_url.scheme == 'http' else 443)
+            
+            # 测试能否建立 TCP 连接（快速失败）
+            import socket
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(2.0)
+            try:
+                sock.connect((host, port))
+                sock.close()
+            except Exception as e:
+                logger.warning(f"本地小模型服务无法连接: {host}:{port} - {e}")
+                return False
+            
+            # 再尝试调用简单的 API
+            client = httpx.Client(base_url=self._base_url.rstrip('/'), timeout=5.0)
+            headers = {}
+            if self._api_key:
+                headers["Authorization"] = f"Bearer {self._api_key}"
+            
+            try:
+                response = client.get("/models", headers=headers)
+                if response.status_code == 200:
+                    logger.info(f"本地小模型服务可用: {self._model}")
+                    return True
+            except Exception:
+                pass
+            
+            logger.warning(f"本地小模型服务响应异常")
+            return False
+        except Exception as e:
+            logger.warning(f"本地小模型服务不可用: {e}")
             return False
-        logger.info(f"智谱轻量模型配置正确: {self._model}")
-        return True
     
     def get_service(self) -> BaseChatModel:
-        """获取智谱轻量模型服务"""
+        """获取本地小模型服务"""
         if self._service_instance is None:
-            from langchain_community.chat_models import ChatZhipuAI
-            self._service_instance = ChatZhipuAI(
+            from langchain_openai import ChatOpenAI
+            from pydantic import SecretStr
+            
+            self._service_instance = ChatOpenAI(
+                base_url=self._base_url,
+                api_key=SecretStr(self._api_key) if self._api_key else SecretStr(""),
                 model=self._model,
-                api_key=ZHIPUAI_API_KEY,
-                temperature=0.1,
-                max_tokens=2048,
                 timeout=30.0,
                 max_retries=2,
-                streaming=False
+                streaming=False,
             )
         return self._service_instance
 
+
 class DeepSeekSmallModelProvider(BaseServiceProvider[BaseChatModel]):
     """
-    DeepSeek 轻量级模型服务提供者（备选）
+    DeepSeek 轻量级模型服务提供者（用于查询改写、意图分类等简单任务）
+    使用小模型独立配置
     """
     
-    def __init__(self, model: str = "deepseek-chat"):
+    def __init__(self, model: str = None):
+        from app.config import SMALL_DEEPSEEK_MODEL, SMALL_DEEPSEEK_API_KEY, SMALL_DEEPSEEK_API_BASE
         super().__init__("deepseek_small")
-        self._model = model
+        self._model = model or SMALL_DEEPSEEK_MODEL
+        self._api_key = SMALL_DEEPSEEK_API_KEY
+        self._api_base = SMALL_DEEPSEEK_API_BASE
     
     def is_available(self) -> bool:
-        if not DEEPSEEK_API_KEY:
-            logger.warning("DEEPSEEK_API_KEY 未配置")
+        if not self._api_key:
+            logger.warning("SMALL_DEEPSEEK_API_KEY 未配置")
             return False
         logger.info(f"DeepSeek 轻量模型配置正确: {self._model}")
         return True
@@ -274,8 +321,8 @@ class DeepSeekSmallModelProvider(BaseServiceProvider[BaseChatModel]):
             from pydantic import SecretStr
             
             self._service_instance = ChatOpenAI(
-                base_url="https://api.deepseek.com",
-                api_key=SecretStr(DEEPSEEK_API_KEY),
+                base_url=self._api_base,
+                api_key=SecretStr(self._api_key),
                 model=self._model,
                 temperature=0.1,
                 max_tokens=2048,
@@ -339,20 +386,17 @@ def get_all_chat_services() -> Dict[str, BaseChatModel]:
 
 def get_small_llm_service() -> BaseChatModel:
     """
-    获取轻量级大模型服务（用于意图分类等简单任务）
-    优先顺序: zhipu_small -> deepseek_small -> (降级到 get_chat_service)
+    获取轻量级大模型服务（用于查询改写、意图分类等简单任务）
+    优先顺序: 本地模型 -> DeepSeek 小模型
+    ⚠️  注意：小模型任务不降级到大模型，避免不必要的 token 消耗！
     
     Returns:
         BaseChatModel: LangChain 兼容的 ChatModel 实例
     """
     def _create_small_chain():
-        primary = ZhipuSmallModelProvider()
+        primary = LocalSmallModelProvider()
         fallbacks = [DeepSeekSmallModelProvider()]
         return FallbackServiceChain(primary, fallbacks)
     
-    try:
-        chain = SingletonServiceManager.get_or_create("small_llm_chain", _create_small_chain)
-        return chain.get_available_service()
-    except Exception as e:
-        logger.warning(f"轻量模型初始化失败，降级到默认大模型: {e}")
-        return get_chat_service()
+    chain = SingletonServiceManager.get_or_create("small_llm_chain", _create_small_chain)
+    return chain.get_available_service()