chore: layout optimize

backend/app/services/embedding_model_store.py

@@ -0,0 +1,77 @@
+import json
+import threading
+import uuid
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from app.core.data_root import get_data_root
+
+class EmbeddingModelStore:
+    def __init__(self) -> None:
+        self._lock = threading.RLock()
+
+    @staticmethod
+    def _file_path() -> Path:
+        return get_data_root() / "embedding_models.json"
+
+    def _read(self) -> List[Dict[str, Any]]:
+        file_path = self._file_path()
+        if not file_path.exists():
+            return []
+        try:
+            with file_path.open("r", encoding="utf-8") as f:
+                data = json.load(f)
+        except (OSError, json.JSONDecodeError):
+            return []
+        if not isinstance(data, list):
+            return []
+        return data
+
+    def _write(self, data: List[Dict[str, Any]]) -> None:
+        file_path = self._file_path()
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        with file_path.open("w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+    def list_models(self) -> List[Dict[str, Any]]:
+        with self._lock:
+            return self._read()
+
+    def get_model(self, model_id: str) -> Optional[Dict[str, Any]]:
+        with self._lock:
+            data = self._read()
+            for item in data:
+                if item.get("id") == model_id:
+                    return item
+            return None
+
+    def create_model(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        with self._lock:
+            data = self._read()
+            new_model = payload.copy()
+            new_model["id"] = uuid.uuid4().hex
+            data.append(new_model)
+            self._write(data)
+            return new_model
+
+    def update_model(self, model_id: str, payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        with self._lock:
+            data = self._read()
+            for item in data:
+                if item.get("id") == model_id:
+                    item.update(payload)
+                    self._write(data)
+                    return item
+            return None
+
+    def delete_model(self, model_id: str) -> bool:
+        with self._lock:
+            data = self._read()
+            initial_len = len(data)
+            data = [item for item in data if item.get("id") != model_id]
+            if len(data) < initial_len:
+                self._write(data)
+                return True
+            return False
+
+embedding_model_store = EmbeddingModelStore()

backend/app/services/knowledge_index.py

@@ -124,10 +124,27 @@ class KnowledgeIndexService:
 
     @staticmethod
     def _build_embed_model(kb: Dict[str, Any]) -> Any:
-        global_config = knowledge_global_config_store.get()
-        api_base = global_config.get("api_base")
-        api_key = global_config.get("api_key")
-        model_name = kb.get("embedding_model") or global_config.get("default_embedding_model")
+        from app.services.embedding_model_store import embedding_model_store
+        models = embedding_model_store.list_models()
+        if not models:
+            return None
+        
+        target_model = None
+        kb_model_val = kb.get("embedding_model")
+        if kb_model_val:
+            # Try matching by ID first, then by model name
+            target_model = next((m for m in models if m.get("id") == kb_model_val), None)
+            if not target_model:
+                target_model = next((m for m in models if m.get("model") == kb_model_val), None)
+        
+        if not target_model:
+            # Fallback to the first model
+            target_model = models[0]
+            
+        api_base = target_model.get("api_base")
+        api_key = target_model.get("api_key")
+        model_name = target_model.get("model")
+        
         if not api_base or not api_key or not model_name:
             return None
         api_base = _normalize_embedding_api_base(api_base)