feat: implement LLMFactory for unified model creation and health checks; add is_deleted field to model config

Author: Dallas98

backend/shared/domain-common/src/main/java/com/datamate/common/setting/domain/entity/ModelConfig.java

@@ -12,7 +12,7 @@
  */
 @Getter
 @Setter
-@TableName("t_model_config")
+@TableName("t_models")
 @Builder
 @ToString
 @NoArgsConstructor

…ate-python/app/db/models/model_config.py …/datamate-python/app/db/models/models.pyruntime/datamate-python/app/db/models/model_config.py renamed to runtime/datamate-python/app/db/models/models.py runtime/datamate-python/app/db/models/model_config.py renamed to runtime/datamate-python/app/db/models/models.py

@@ -1,18 +1,12 @@
-from sqlalchemy import Column, String, Integer, TIMESTAMP, select
+from sqlalchemy import Boolean, Column, String, TIMESTAMP
 
 from app.db.models.base_entity import BaseEntity
 
 
-async def get_model_by_id(db_session, model_id: str):
-    """根据 ID 获取单个模型配置。"""
-    result =await db_session.execute(select(ModelConfig).where(ModelConfig.id == model_id))
-    model_config = result.scalar_one_or_none()
-    return model_config
+class Models(BaseEntity):
+    """模型配置表，对应表 t_models
 
-class ModelConfig(BaseEntity):
-    """模型配置表，对应表 t_model_config
-
-    CREATE TABLE IF NOT EXISTS t_model_config (
+    CREATE TABLE IF NOT EXISTS t_models (
         id         VARCHAR(36) PRIMARY KEY COMMENT '主键ID',
         model_name VARCHAR(100) NOT NULL COMMENT '模型名称（如 qwen2）',
         provider   VARCHAR(50)  NOT NULL COMMENT '模型提供商（如 Ollama、OpenAI、DeepSeek）',
@@ -29,7 +23,7 @@ class ModelConfig(BaseEntity):
     ) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COMMENT ='模型配置表';
     """
 
-    __tablename__ = "t_model_config"
+    __tablename__ = "t_models"
 
     id = Column(String(36), primary_key=True, index=True, comment="主键ID")
     model_name = Column(String(100), nullable=False, comment="模型名称（如 qwen2）")
@@ -38,10 +32,9 @@ class ModelConfig(BaseEntity):
     api_key = Column(String(512), nullable=False, default="", comment="API 密钥（无密钥则为空）")
     type = Column(String(50), nullable=False, comment="模型类型（如 chat、embedding）")
 
-    # 使用 Integer 存储 TINYINT，后续可在业务层将 0/1 转为 bool
-    is_enabled = Column(Integer, nullable=False, default=1, comment="是否启用：1-启用，0-禁用")
-    is_default = Column(Integer, nullable=False, default=0, comment="是否默认：1-默认，0-非默认")
-    is_deleted = Column(Integer, nullable=False, default=0, comment="是否删除：1-已删除，0-未删除")
+    is_enabled = Column(Boolean, nullable=False, default=True, comment="是否启用")
+    is_default = Column(Boolean, nullable=False, default=False, comment="是否默认")
+    is_deleted = Column(Boolean, nullable=False, default=False, comment="是否删除")
 
     __table_args__ = (
         # 与 DDL 中的 uk_model_provider 保持一致

runtime/datamate-python/app/module/evaluation/interface/evaluation.py

@@ -80,8 +80,8 @@ async def create_evaluation_task(
         if existing_task.scalar_one_or_none():
             raise HTTPException(status_code=400, detail=f"Evaluation task with name '{request.name}' already exists")
 
-        model_config = await get_model_by_id(db, request.eval_config.model_id)
-        if not model_config:
+        models = await get_model_by_id(db, request.eval_config.model_id)
+        if not models:
             raise HTTPException(status_code=400, detail=f"Model with id '{request.eval_config.model_id}' not found")
 
         # 创建评估任务
@@ -96,7 +96,7 @@ async def create_evaluation_task(
             eval_prompt=request.eval_prompt,
             eval_config=json.dumps({
                 "modelId": request.eval_config.model_id,
-                "modelName": model_config.model_name,
+                "modelName": models.model_name,
                 "dimensions": request.eval_config.dimensions,
             }),
             status=TaskStatus.PENDING.value,

runtime/datamate-python/app/module/evaluation/service/evaluation.py

@@ -43,7 +43,7 @@ def get_eval_prompt(self, item: EvaluationItem) -> str:
 
     async def execute(self):
         eval_config = json.loads(self.task.eval_config)
-        model_config = await get_model_by_id(self.db, eval_config.get("modelId"))
+        models = await get_model_by_id(self.db, eval_config.get("modelId"))
         semaphore = asyncio.Semaphore(10)
         files = (await self.db.execute(
             select(EvaluationFile).where(EvaluationFile.task_id == self.task.id)
@@ -55,7 +55,7 @@ async def execute(self):
         for file in files:
             items = (await self.db.execute(query.where(EvaluationItem.file_id == file.file_id))).scalars().all()
             tasks = [
-                self.evaluate_item(model_config, item, semaphore)
+                self.evaluate_item(models, item, semaphore)
                 for item in items
             ]
             await asyncio.gather(*tasks, return_exceptions=True)
@@ -64,13 +64,13 @@ async def execute(self):
             self.task.eval_process = evaluated_count / total
             await self.db.commit()
 
-    async def evaluate_item(self, model_config, item: EvaluationItem, semaphore: asyncio.Semaphore):
+    async def evaluate_item(self, models, item: EvaluationItem, semaphore: asyncio.Semaphore):
         async with semaphore:
             max_try = 3
             while max_try > 0:
                 prompt_text = self.get_eval_prompt(item)
                 resp_text = await asyncio.to_thread(
-                    call_openai_style_model, model_config.base_url, model_config.api_key, model_config.model_name,
+                    call_openai_style_model, models.base_url, models.api_key, models.model_name,
                     prompt_text,
                 )
                 resp_text = extract_json_substring(resp_text)

runtime/datamate-python/app/module/generation/service/generation_service.py

@@ -24,7 +24,7 @@
 from app.module.shared.common.document_loaders import load_documents
 from app.module.shared.common.text_split import DocumentSplitter
 from app.module.shared.util.model_chat import extract_json_substring
-from app.core.llm import LLMFactory
+from app.module.shared.llm import LLMFactory
 from app.module.system.service.common_service import get_model_by_id
 
 

runtime/datamate-python/app/module/rag/service/rag_service.py

@@ -2,7 +2,7 @@
 import asyncio
 from typing import Optional, Sequence
 
-from fastapi import BackgroundTasks, Depends
+from fastapi import Depends
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -17,7 +17,7 @@
     build_llm_model_func,
     initialize_rag,
 )
-from app.core.llm import LLMFactory
+from app.module.shared.llm import LLMFactory
 from ...system.service.common_service import get_model_by_id
 
 logger = get_logger(__name__)
@@ -44,8 +44,8 @@ async def get_unprocessed_files(self, knowledge_base_id: str) -> Sequence[RagFil
 
     async def init_graph_rag(self, knowledge_base_id: str):
         kb = await self._get_knowledge_base(knowledge_base_id)
-        embedding_model = await self._get_model_config(kb.embedding_model)
-        chat_model = await self._get_model_config(kb.chat_model)
+        embedding_model = await self._get_models(kb.embedding_model)
+        chat_model = await self._get_models(kb.chat_model)
 
         llm_callable = await build_llm_model_func(
             chat_model.model_name, chat_model.base_url, chat_model.api_key
@@ -126,13 +126,13 @@ async def _get_knowledge_base(self, knowledge_base_id: str):
             raise ValueError(f"Knowledge base with ID {knowledge_base_id} not found.")
         return knowledge_base
 
-    async def _get_model_config(self, model_id: Optional[str]):
+    async def _get_models(self, model_id: Optional[str]):
         if not model_id:
             raise ValueError("Model ID is required for initializing RAG.")
-        model = await get_model_by_id(self.db, model_id)
-        if not model:
-            raise ValueError(f"Model config with ID {model_id} not found.")
-        return model
+        models = await get_model_by_id(self.db, model_id)
+        if not models:
+            raise ValueError(f"Models with ID {model_id} not found.")
+        return models
 
     async def query_rag(self, query: str, knowledge_base_id: str) -> str:
         if not self.rag:

…datamate-python/app/core/llm/__init__.py …python/app/module/shared/llm/__init__.pyruntime/datamate-python/app/core/llm/__init__.py renamed to runtime/datamate-python/app/module/shared/llm/__init__.py runtime/datamate-python/app/core/llm/__init__.py renamed to runtime/datamate-python/app/module/shared/llm/__init__.py

@@ -45,7 +45,7 @@ def check_health(
         model_name: str,
         base_url: str,
         api_key: str | None,
-        model_type: Literal["CHAT", "EMBEDDING"],
+        model_type: Literal["CHAT", "EMBEDDING"] | str,
     ) -> None:
         """对配置做一次最小化调用进行健康检查，失败则抛出。"""
         if model_type == "CHAT":

…/datamate-python/app/core/llm/factory.py …-python/app/module/shared/llm/factory.pyruntime/datamate-python/app/core/llm/factory.py renamed to runtime/datamate-python/app/module/shared/llm/factory.py runtime/datamate-python/app/core/llm/factory.py renamed to runtime/datamate-python/app/module/shared/llm/factory.py

@@ -1,9 +1,9 @@
 from fastapi import APIRouter
 
 from .about import router as about_router
-from .model_config import router as model_config_router
+from app.module.system.interface.models import router as models_router
 
 router = APIRouter()
 
 router.include_router(about_router)
-router.include_router(model_config_router)
+router.include_router(models_router)

runtime/datamate-python/app/module/system/interface/__init__.py

@@ -1,38 +1,34 @@
-"""
-模型配置 REST 接口：与 Java ModelConfigController 路径、语义一致，响应使用 StandardResponse。
-db 通过 ModelConfigService 的 Depends(get_db) 注入，不在本层传递。
-"""
 from fastapi import APIRouter, Depends, Query
 
 from app.module.shared.schema import StandardResponse, PaginatedData
-from app.module.system.schema import (
+from app.module.system.schema.models import (
     CreateModelRequest,
     QueryModelRequest,
-    ModelConfigResponse,
+    ModelsResponse,
     ProviderItem,
     ModelType,
 )
-from app.module.system.service.model_config_service import ModelConfigService
+from app.module.system.service.models_service import ModelsService
 
 router = APIRouter(prefix="/models", tags=["models"])
 
 
 @router.get("/providers", response_model=StandardResponse[list[ProviderItem]])
-async def get_providers(svc: ModelConfigService = Depends()):
+async def get_providers(svc: ModelsService = Depends()):
     """获取厂商列表，与 Java GET /models/providers 一致。"""
     data = await svc.get_providers()
     return StandardResponse(code=200, message="success", data=data)
 
 
-@router.get("/list", response_model=StandardResponse[PaginatedData[ModelConfigResponse]])
+@router.get("/list", response_model=StandardResponse[PaginatedData[ModelsResponse]])
 async def get_models(
     page: int = Query(0, ge=0, description="页码，从 0 开始"),
     size: int = Query(20, gt=0, le=500, description="每页大小"),
     provider: str | None = Query(None, description="模型提供商"),
     type: ModelType | None = Query(None, description="模型类型"),
     isEnabled: bool | None = Query(None, description="是否启用"),
     isDefault: bool | None = Query(None, description="是否默认"),
-    svc: ModelConfigService = Depends(),
+    svc: ModelsService = Depends(),
 ):
     """分页查询模型列表，与 Java GET /models/list 一致。"""
     q = QueryModelRequest(
@@ -47,33 +43,33 @@ async def get_models(
     return StandardResponse(code=200, message="success", data=data)
 
 
-@router.post("/create", response_model=StandardResponse[ModelConfigResponse])
-async def create_model(req: CreateModelRequest, svc: ModelConfigService = Depends()):
+@router.post("/create", response_model=StandardResponse[ModelsResponse])
+async def create_model(req: CreateModelRequest, svc: ModelsService = Depends()):
     """创建模型配置，与 Java POST /models/create 一致。"""
     data = await svc.create_model(req)
     return StandardResponse(code=200, message="success", data=data)
 
 
-@router.get("/{model_id}", response_model=StandardResponse[ModelConfigResponse])
-async def get_model_detail(model_id: str, svc: ModelConfigService = Depends()):
+@router.get("/{model_id}", response_model=StandardResponse[ModelsResponse])
+async def get_model_detail(model_id: str, svc: ModelsService = Depends()):
     """获取模型详情，与 Java GET /models/{modelId} 一致。"""
     data = await svc.get_model_detail(model_id)
     return StandardResponse(code=200, message="success", data=data)
 
 
-@router.put("/{model_id}", response_model=StandardResponse[ModelConfigResponse])
+@router.put("/{model_id}", response_model=StandardResponse[ModelsResponse])
 async def update_model(
     model_id: str,
     req: CreateModelRequest,
-    svc: ModelConfigService = Depends(),
+    svc: ModelsService = Depends(),
 ):
     """更新模型配置，与 Java PUT /models/{modelId} 一致。"""
     data = await svc.update_model(model_id, req)
     return StandardResponse(code=200, message="success", data=data)
 
 
 @router.delete("/{model_id}", response_model=StandardResponse[None])
-async def delete_model(model_id: str, svc: ModelConfigService = Depends()):
+async def delete_model(model_id: str, svc: ModelsService = Depends()):
     """删除模型配置，与 Java DELETE /models/{modelId} 一致。"""
     await svc.delete_model(model_id)
     return StandardResponse(code=200, message="success", data=None)