fix: 处理 embed_info 可能为字典或 EmbedModelInfo 对象的情况，确保获取模型名称和其他属性的兼容性

Author: xerrors

docs/changelog/roadmap.md

@@ -7,7 +7,7 @@
 
 ## Bugs
 
--
+- [x] 修复本地知识库的 metadata 和 向量数据库中不一致的情况。
 
 ## Next
 

src/knowledge/base.py

@@ -1,5 +1,7 @@
 import json
 import os
+import tempfile
+import shutil
 from abc import ABC, abstractmethod
 from typing import Any
 
@@ -524,6 +526,7 @@ async def retriever(query_text):
     def _load_metadata(self):
         """加载元数据"""
         meta_file = os.path.join(self.work_dir, f"metadata_{self.kb_type}.json")
+
         if os.path.exists(meta_file):
             try:
                 with open(meta_file, encoding="utf-8") as f:
@@ -533,19 +536,74 @@ def _load_metadata(self):
                 logger.info(f"Loaded {self.kb_type} metadata for {len(self.databases_meta)} databases")
             except Exception as e:
                 logger.error(f"Failed to load {self.kb_type} metadata: {e}")
+                # 尝试从备份恢复
+                backup_file = f"{meta_file}.backup"
+                if os.path.exists(backup_file):
+                    try:
+                        with open(backup_file, encoding="utf-8") as f:
+                            data = json.load(f)
+                            self.databases_meta = data.get("databases", {})
+                            self.files_meta = data.get("files", {})
+                        logger.info(f"Loaded {self.kb_type} metadata from backup")
+                        # 恢复备份文件
+                        shutil.copy2(backup_file, meta_file)
+                        return
+                    except Exception as backup_e:
+                        logger.error(f"Failed to load backup: {backup_e}")
+
+                # 如果加载失败，初始化为空状态
+                logger.warning(f"Initializing empty {self.kb_type} metadata")
+                self.databases_meta = {}
+                self.files_meta = {}
+
+    def _serialize_metadata(self, obj):
+        """递归序列化元数据中的 Pydantic 模型"""
+        if hasattr(obj, 'dict'):
+            return obj.dict()
+        elif isinstance(obj, dict):
+            return {k: self._serialize_metadata(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [self._serialize_metadata(item) for item in obj]
+        else:
+            return obj
 
     def _save_metadata(self):
         """保存元数据"""
         self._normalize_metadata_state()
         meta_file = os.path.join(self.work_dir, f"metadata_{self.kb_type}.json")
+        backup_file = f"{meta_file}.backup"
+
         try:
+            # 创建简单备份
+            if os.path.exists(meta_file):
+                shutil.copy2(meta_file, backup_file)
+
+            # 准备数据并序列化 Pydantic 模型
             data = {
-                "databases": self.databases_meta,
-                "files": self.files_meta,
+                "databases": self._serialize_metadata(self.databases_meta),
+                "files": self._serialize_metadata(self.files_meta),
                 "kb_type": self.kb_type,
                 "updated_at": utc_isoformat(),
             }
-            with open(meta_file, "w", encoding="utf-8") as f:
-                json.dump(data, f, ensure_ascii=False, indent=2)
+
+            # 原子性写入（使用临时文件）
+            with tempfile.NamedTemporaryFile(
+                mode='w', dir=os.path.dirname(meta_file),
+                prefix='.tmp_', suffix='.json', delete=False
+            ) as tmp_file:
+                json.dump(data, tmp_file, ensure_ascii=False, indent=2)
+                temp_path = tmp_file.name
+
+            os.replace(temp_path, meta_file)
+            logger.debug(f"Saved {self.kb_type} metadata")
+
         except Exception as e:
             logger.error(f"Failed to save {self.kb_type} metadata: {e}")
+            # 尝试恢复备份
+            if os.path.exists(backup_file):
+                try:
+                    shutil.copy2(backup_file, meta_file)
+                    logger.info("Restored metadata from backup")
+                except Exception as restore_e:
+                    logger.error(f"Failed to restore backup: {restore_e}")
+            raise e

src/knowledge/graph.py

@@ -299,7 +299,7 @@ def _batch_set_embeddings(tx, entity_embedding_pairs):
             logger.info(f"Adding entity to {kgdb_name}")
             session.execute_write(_create_graph, triples)
             logger.info(f"Creating vector index for {kgdb_name} with {config.embed_model}")
-            session.execute_write(_create_vector_index, cur_embed_info["dimension"])
+            session.execute_write(_create_vector_index, getattr(cur_embed_info, 'dimension', 1024))
 
             # 收集所有需要处理的实体名称，去重
             all_entities = []

src/knowledge/implementations/chroma.py

@@ -72,7 +72,12 @@ async def _create_kb_instance(self, db_id: str, kb_config: dict) -> Any:
             logger.info(f"Retrieved existing collection: {collection_name}")
 
             # 检查现有集合的配置是否匹配当前的 embed_info
-            expected_model = embed_info.get("name") if embed_info else "default"
+            expected_model = getattr(embed_info, 'name', None) if embed_info else None
+            if expected_model is None and hasattr(embed_info, 'get'):
+                expected_model = embed_info.get('name')
+            elif embed_info and isinstance(embed_info, dict):
+                expected_model = embed_info.get('name')
+            expected_model = expected_model or "default"
             collection_metadata = collection.metadata or {}
             current_model = collection_metadata.get("embedding_model", "unknown")
 
@@ -88,11 +93,18 @@ async def _create_kb_instance(self, db_id: str, kb_config: dict) -> Any:
 
         except Exception:
             # 创建新集合
-            logger.info(f"Creating new collection with embedding model: {embed_info.get('name', 'default')}")
+            model_name = getattr(embed_info, 'name', None) if embed_info else None
+            if model_name is None and hasattr(embed_info, 'get'):
+                model_name = embed_info.get('name')
+            elif embed_info and isinstance(embed_info, dict):
+                model_name = embed_info.get('name')
+
+            model_name = model_name or 'default'
+            logger.info(f"Creating new collection with embedding model: {model_name}")
             collection_metadata = {
                 "db_id": db_id,
                 "created_at": utc_isoformat(),
-                "embedding_model": embed_info.get("name") if embed_info else "default",
+                "embedding_model": model_name,
             }
             collection = self.chroma_client.create_collection(
                 name=collection_name, embedding_function=embedding_function, metadata=collection_metadata

src/knowledge/implementations/milvus.py

@@ -103,7 +103,7 @@ async def _create_kb_instance(self, db_id: str, kb_config: dict) -> Any:
 
                 # 检查嵌入模型是否匹配
                 description = collection.description
-                expected_model = embed_info.get("name") if embed_info else "default"
+                expected_model = getattr(embed_info, 'name', 'default') if embed_info else "default"
 
                 if expected_model not in description:
                     logger.warning(f"Collection {collection_name} model mismatch, recreating...")
@@ -116,8 +116,8 @@ async def _create_kb_instance(self, db_id: str, kb_config: dict) -> Any:
 
         except Exception:
             # 创建新集合
-            embedding_dim = embed_info.get("dimension", 1024) if embed_info else 1024
-            model_name = embed_info.get("name", "default") if embed_info else "default"
+            embedding_dim = getattr(embed_info, 'dimension', 1024) if embed_info else 1024
+            model_name = getattr(embed_info, 'name', 'default') if embed_info else "default"
 
             # 定义集合Schema
             fields = [