refactor(models): unify model configuration and standardize LLM client factory (#283)

Author: Dallas98

backend/api-gateway/src/main/java/com/datamate/gateway/ApiGatewayApplication.java

@@ -42,7 +42,7 @@ public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
                  .uri("http://datamate-backend-python:18000"))
 
             // 知识图谱RAG服务路由
-            .route("graph-rag", r -> r.path("/api/rag/**")
+            .route("python-service", r -> r.path("/api/rag/**", "api/models/**")
                  .uri("http://datamate-backend-python:18000"))
 
             .route("deer-flow-frontend", r -> r.path("/chat/**")

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
@@ -47,4 +47,9 @@ public class ModelConfig extends BaseEntity<String> {
      * 是否默认：1-默认，0-非默认
      */
     private Boolean isDefault;
+
+    /**
+     * 是否删除：1-已删除，0-未删除
+     */
+    private Boolean isDeleted;
 }

frontend/vite.config.ts

@@ -1,4 +1,4 @@
-import { defineConfig } from "vite";
+import {defineConfig} from "vite";
 import react from "@vitejs/plugin-react";
 import tailwindcss from "@tailwindcss/vite";
 import path from "path"; // 需要安装 Node.js 的类型声明（@types/node）
@@ -12,30 +12,55 @@ export default defineConfig({
     },
   },
   server: {
-    // headers: {
-    //   "Access-Control-Allow-Origin": "*",
-    //   "access-control-allow-headers":
-    //     "Origin, X-Requested-With, Content-Type, Accept",
-    // },
-    proxy: {
-      "^/api": {
-        target: "http://localhost:8080", // 本地后端服务地址
+    host: "0.0.0.0",
+    proxy: (() => {
+      const pythonProxyConfig = {
+        target: "http://localhost:18000",
         changeOrigin: true,
         secure: false,
-        rewrite: (path) => path.replace(/^\/api/, "/api"),
-        configure: (proxy, options) => {
-          // proxy 是 'http-proxy' 的实例
-          proxy.on("proxyReq", (proxyReq, req, res) => {
-            // 可以在这里修改请求头
-            proxyReq.removeHeader("referer");
-            proxyReq.removeHeader("origin");
+        configure: (proxy: { on: (event: string, handler: (arg: unknown) => void) => void }) => {
+          proxy.on("proxyReq", (proxyReq: unknown) => {
+            (proxyReq as { removeHeader: (name: string) => void }).removeHeader("referer");
+            (proxyReq as { removeHeader: (name: string) => void }).removeHeader("origin");
           });
-          proxy.on("proxyRes", (proxyRes, req, res) => {
-            delete proxyRes.headers["set-cookie"];
-            proxyRes.headers["cookies"] = ""; // 清除 cookies 头
+          proxy.on("proxyRes", (proxyRes: unknown) => {
+            const res = proxyRes as { headers: Record<string, unknown> };
+            delete res.headers["set-cookie"];
+            res.headers["cookies"] = "";
           });
         },
-      },
-    },
+      };
+
+      const javaProxyConfig = {
+        target: "http://localhost:8080",
+        changeOrigin: true,
+        secure: false,
+        configure: (proxy: { on: (event: string, handler: (arg: unknown) => void) => void }) => {
+          proxy.on("proxyReq", (proxyReq: unknown) => {
+            (proxyReq as { removeHeader: (name: string) => void }).removeHeader("referer");
+            (proxyReq as { removeHeader: (name: string) => void }).removeHeader("origin");
+          });
+          proxy.on("proxyRes", (proxyRes: unknown) => {
+            const res = proxyRes as { headers: Record<string, unknown> };
+            delete res.headers["set-cookie"];
+            res.headers["cookies"] = "";
+          });
+        },
+      };
+
+      // Python 服务: rag, synthesis, annotation, evaluation, models
+      const pythonPaths = ["rag", "synthesis", "annotation", "data-collection", "evaluation", "models"];
+      // Java 服务: data-management, knowledge-base
+      const javaPaths = ["data-management", "knowledge-base", "operators"];
+
+      const proxy: Record<string, object> = {};
+      for (const p of pythonPaths) {
+        proxy[`/api/${p}`] = pythonProxyConfig;
+      }
+      for (const p of javaPaths) {
+        proxy[`/api/${p}`] = javaProxyConfig;
+      }
+      return proxy;
+    })(),
   },
 });

…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。模型为系统级配置，RAG/生成等按 ID 引用时不受数据权限过滤。
 
-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,9 +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_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,8 @@
 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.module.system.service.common_service import chat, get_model_by_id, get_chat_client
+from app.module.shared.llm import LLMFactory
+from app.module.system.service.common_service import get_model_by_id
 
 
 def _filter_docs(split_docs, chunk_size):
@@ -171,8 +172,12 @@ async def _process_single_file(
         # 为本文件构建模型 client
         question_model = await get_model_by_id(self.db, question_cfg.model_id)
         answer_model = await get_model_by_id(self.db, answer_cfg.model_id)
-        question_chat = get_chat_client(question_model)
-        answer_chat = get_chat_client(answer_model)
+        question_chat = LLMFactory.create_chat(
+            question_model.model_name, question_model.base_url, question_model.api_key
+        )
+        answer_chat = LLMFactory.create_chat(
+            answer_model.model_name, answer_model.base_url, answer_model.api_key
+        )
 
         # 分批次从 DB 读取并处理 chunk
         batch_size = 100
@@ -356,7 +361,7 @@ async def _generate_questions_for_one_chunk(
             loop = asyncio.get_running_loop()
             raw_answer = await loop.run_in_executor(
                 None,
-                chat,
+                LLMFactory.invoke_sync,
                 question_chat,
                 prompt,
             )
@@ -400,7 +405,7 @@ async def process_single_question(question: str):
                 loop = asyncio.get_running_loop()
                 answer = await loop.run_in_executor(
                     None,
-                    chat,
+                    LLMFactory.invoke_sync,
                     answer_chat,
                     prompt_local,
                 )

runtime/datamate-python/app/module/rag/interface/rag_interface.py

@@ -9,12 +9,12 @@
 router = APIRouter(prefix="/rag", tags=["rag"])
 
 @router.post("/process/{knowledge_base_id}")
-async def process_knowledge_base(knowledge_base_id: str, db: AsyncSession = Depends(get_db)):
+async def process_knowledge_base(knowledge_base_id: str, rag_service: RAGService = Depends()):
     """
     Process all unprocessed files in a knowledge base.
     """
     try:
-        await RAGService(db).init_graph_rag(knowledge_base_id)
+        await rag_service.init_graph_rag(knowledge_base_id)
         return StandardResponse(
             code=200,
             message="Processing started for knowledge base.",
@@ -24,12 +24,11 @@ async def process_knowledge_base(knowledge_base_id: str, db: AsyncSession = Depe
         raise HTTPException(status_code=500, detail=str(e))
 
 @router.post("/query")
-async def query_knowledge_graph(payload: QueryRequest, db: AsyncSession = Depends(get_db)):
+async def query_knowledge_graph(payload: QueryRequest, rag_service: RAGService = Depends()):
     """
     Query the knowledge graph with the given query text and knowledge base ID.
     """
     try:
-        rag_service = RAGService(db)
         result = await rag_service.query_rag(payload.query, payload.knowledge_base_id)
         return StandardResponse(code=200, message="success", data=result)
     except HTTPException:

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

@@ -2,14 +2,13 @@
 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
 
 from app.core.logging import get_logger
 from app.db.models.dataset_management import DatasetFiles
 from app.db.models.knowledge_gen import RagFile, RagKnowledgeBase
-from app.db.models.model_config import ModelConfig
 from app.db.session import get_db, AsyncSessionLocal
 from app.module.shared.common.document_loaders import load_documents
 from .graph_rag import (
@@ -18,7 +17,8 @@
     build_llm_model_func,
     initialize_rag,
 )
-from ...system.service.common_service import get_embedding_dimension, get_openai_client
+from app.module.shared.llm import LLMFactory
+from ...system.service.common_service import get_model_by_id
 
 logger = get_logger(__name__)
 
@@ -27,10 +27,10 @@ class RAGService:
     def __init__(
         self,
         db: AsyncSession = Depends(get_db),
-        background_tasks: BackgroundTasks | None = None,
+
     ):
         self.db = db
-        self.background_tasks = background_tasks
+        self.background_tasks = None
         self.rag = None
 
     async def get_unprocessed_files(self, knowledge_base_id: str) -> Sequence[RagFile]:
@@ -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
@@ -54,7 +54,9 @@ async def init_graph_rag(self, knowledge_base_id: str):
             embedding_model.model_name,
             embedding_model.base_url,
             embedding_model.api_key,
-            embedding_dim=get_embedding_dimension(get_openai_client(embedding_model)),
+            embedding_dim=LLMFactory.get_embedding_dimension(
+                embedding_model.model_name, embedding_model.base_url, embedding_model.api_key
+            ),
         )
 
         kb_working_dir = os.path.join(DEFAULT_WORKING_DIR, kb.name)
@@ -124,14 +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.")
-        result = await self.db.execute(select(ModelConfig).where(ModelConfig.id == model_id))
-        model = result.scalars().first()
-        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:

runtime/datamate-python/app/module/shared/llm/__init__.py

@@ -0,0 +1,7 @@
+# app/core/llm/__init__.py
+"""
+LangChain 模型工厂：统一创建 Chat、Embedding 及健康检查，便于各模块复用。
+"""
+from .factory import LLMFactory
+
+__all__ = ["LLMFactory"]