Merge branch 'develop' into fix/memory-enduser-config

api/app/repositories/memory_config_repository.py

@@ -32,6 +32,8 @@ db_logger = get_db_logger()
 config_logger = get_config_logger()
 
 TABLE_NAME = "memory_config"
+
+
 class MemoryConfigRepository:
     """记忆配置Repository
 
@@ -154,7 +156,7 @@ class MemoryConfigRepository:
         return memory_config_obj
 
     @staticmethod
-    def query_reflection_config_by_id(db: Session, config_id: uuid.UUID) -> MemoryConfig:
+    def query_reflection_config_by_id(db: Session, config_id: uuid.UUID|int|str) -> MemoryConfig:
         """构建反思配置查询语句，通过config_id查询反思配置（SQLAlchemy text() 命名参数）
 
         Args:
@@ -170,6 +172,7 @@ class MemoryConfigRepository:
         if not memory_config:
             raise RuntimeError("reflection config not found")
         return memory_config
+
     @staticmethod
     def query_reflection_config_by_workspace_id(db: Session, workspace_id: uuid.UUID) -> MemoryConfig:
         """构建查询所有配置的语句（SQLAlchemy text() 命名参数）
@@ -189,7 +192,6 @@ class MemoryConfigRepository:
             raise RuntimeError("reflection config not found")
         return memory_config
 
-
     @staticmethod
     def build_select_all(workspace_id: uuid.UUID) -> Tuple[str, Dict]:
         """构建查询所有配置的语句（SQLAlchemy text() 命名参数）
@@ -229,6 +231,7 @@ class MemoryConfigRepository:
                 config_name=params.config_name,
                 config_desc=params.config_desc,
                 workspace_id=params.workspace_id,
+                scene_id=params.scene_id,
                 llm_id=params.llm_id,
                 embedding_id=params.embedding_id,
                 rerank_id=params.rerank_id,
@@ -289,7 +292,6 @@ class MemoryConfigRepository:
             db_logger.error(f"更新记忆配置失败: config_id={update.config_id} - {str(e)}")
             raise
 
-
     @staticmethod
     def update_extracted(db: Session, update: ConfigUpdateExtracted) -> Optional[MemoryConfig]:
         """更新记忆萃取引擎配置
@@ -412,7 +414,7 @@ class MemoryConfigRepository:
             raise
 
     @staticmethod
-    def get_extracted_config(db: Session, config_id: UUID |int) -> Optional[Dict]:
+    def get_extracted_config(db: Session, config_id: UUID | int) -> Optional[Dict]:
         """获取萃取配置，通过主键查询某条配置
 
         Args:
@@ -422,7 +424,7 @@ class MemoryConfigRepository:
         Returns:
             Optional[Dict]: 萃取配置字典，不存在则返回None
         """
-        config_id=resolve_config_id(config_id,db)
+        config_id = resolve_config_id(config_id, db)
         db_logger.debug(f"查询萃取配置: config_id={config_id}")
         try:
             db_config = db.query(MemoryConfig).filter(MemoryConfig.config_id == config_id).first()
@@ -516,26 +518,28 @@ class MemoryConfigRepository:
         except Exception as e:
             db_logger.error(f"根据ID查询记忆配置失败: config_id={config_id} - {str(e)}")
             raise
+
     @staticmethod
-    def get_config_with_workspace(db: Session, config_id: uuid.UUID) -> Optional[tuple]:
+    def get_config_with_workspace(db: Session, config_id: uuid.UUID | int | str) -> Optional[tuple]:
         """Get memory config and its associated workspace information
-        
+
         Args:
             db: Database session
             config_id: Configuration ID
-            
+
         Returns:
             Optional[tuple]: (MemoryConfig, Workspace) tuple, None if not found
-            
+
         Raises:
             ValueError: Raised when config exists but workspace doesn't
         """
         import time
 
         from app.models.workspace_model import Workspace
-        
+
         start_time = time.time()
-        
+        config_id = resolve_config_id(config_id, db)
+
         # Log configuration loading start
         config_logger.info(
             "Loading configuration with workspace",
@@ -544,17 +548,17 @@ class MemoryConfigRepository:
                 "config_id": config_id
             }
         )
-        
+
         db_logger.debug(f"Querying memory config and workspace: config_id={config_id}")
-        
+
         try:
             # Use join query to get both config and workspace
             result = db.query(MemoryConfig, Workspace).join(
                 Workspace, MemoryConfig.workspace_id == Workspace.id
             ).filter(MemoryConfig.config_id == config_id).first()
-            
+
             elapsed_ms = (time.time() - start_time) * 1000
-            
+
             if not result:
                 # Check if config exists but workspace is missing
                 config_only = db.query(MemoryConfig).filter(MemoryConfig.config_id == config_id).first()
@@ -583,9 +587,11 @@ class MemoryConfigRepository:
                                 "elapsed_ms": elapsed_ms
                             }
                         )
-                        db_logger.error(f"Memory config {config_id} references non-existent workspace {config_only.workspace_id}")
-                        raise ValueError(f"Workspace {config_only.workspace_id} not found for configuration {config_id}")
-                
+                        db_logger.error(
+                            f"Memory config {config_id} references non-existent workspace {config_only.workspace_id}")
+                        raise ValueError(
+                            f"Workspace {config_only.workspace_id} not found for configuration {config_id}")
+
                 config_logger.debug(
                     "Configuration not found",
                     extra={
@@ -597,9 +603,9 @@ class MemoryConfigRepository:
                 )
                 db_logger.debug(f"Memory config not found: config_id={config_id}")
                 return None
-            
+
             config, workspace = result
-            
+
             # Log successful configuration loading
             config_logger.info(
                 "Configuration with workspace loaded successfully",
@@ -614,16 +620,17 @@ class MemoryConfigRepository:
                     "elapsed_ms": elapsed_ms
                 }
             )
-            
-            db_logger.debug(f"Memory config and workspace query successful: config={config.config_name}, workspace={workspace.name}")
+
+            db_logger.debug(
+                f"Memory config and workspace query successful: config={config.config_name}, workspace={workspace.name}")
             return (config, workspace)
-            
+
         except ValueError:
             # Re-raise known business exceptions
             raise
         except Exception as e:
             elapsed_ms = (time.time() - start_time) * 1000
-            
+
             config_logger.error(
                 "Failed to load configuration with workspace",
                 extra={
@@ -636,9 +643,10 @@ class MemoryConfigRepository:
                 },
                 exc_info=True
             )
-            
+
             db_logger.error(f"Failed to query memory config and workspace: config_id={config_id} - {str(e)}")
             raise
+
     @staticmethod
     def get_all(db: Session, workspace_id: Optional[uuid.UUID] = None) -> List[MemoryConfig]:
         """获取所有配置参数

api/app/repositories/model_repository.py

@@ -630,6 +630,13 @@ class ModelBaseRepository:
         db.add(model_base)
         return model_base
 
+    @staticmethod
+    def get_by_name_and_provider(db: Session, name: str, provider: str) -> Optional['ModelBase']:
+        return db.query(ModelBase).filter(
+            ModelBase.name == name,
+            ModelBase.provider == provider
+        ).first()
+
     @staticmethod
     def update(db: Session, model_base_id: uuid.UUID, data: dict) -> Optional['ModelBase']:
         model_base = db.query(ModelBase).filter(ModelBase.id == model_base_id).first()

api/app/repositories/neo4j/cypher_queries.py

@@ -877,7 +877,8 @@ RETURN
     CASE
       WHEN ms:ExtractedEntity THEN {
         text: ms.name,
-        created_at: ms.created_at
+        created_at: ms.created_at,
+        type: "情景记忆" 
       }
     END
   ) AS ExtractedEntity,
@@ -887,7 +888,8 @@ RETURN
     CASE
       WHEN n:MemorySummary THEN {
         text: n.content,
-        created_at: n.created_at
+        created_at: n.created_at,
+        type: "长期沉淀" 
       }
     END
   ) AS MemorySummary,
@@ -895,7 +897,8 @@ RETURN
   collect(
     DISTINCT {
       text: e.statement,
-      created_at: e.created_at
+      created_at: e.created_at,
+      type: "情绪记忆" 
     }
   ) AS statement;
 """

api/app/repositories/ontology_class_repository.py

@@ -0,0 +1,404 @@
+# -*- coding: utf-8 -*-
+"""本体类型Repository层
+
+本模块提供本体类型的数据访问层实现。
+
+Classes:
+    OntologyClassRepository: 本体类型数据访问类
+"""
+
+import logging
+from typing import List, Optional
+from uuid import UUID
+
+from sqlalchemy.orm import Session, joinedload
+
+from app.core.logging_config import get_db_logger
+from app.models.ontology_class import OntologyClass
+from app.models.ontology_scene import OntologyScene
+
+
+logger = get_db_logger()
+
+
+class OntologyClassRepository:
+    """本体类型Repository
+    
+    提供本体类型的CRUD操作和权限检查。
+    
+    Attributes:
+        db: SQLAlchemy数据库会话
+    """
+    
+    def __init__(self, db: Session):
+        """初始化Repository
+        
+        Args:
+            db: SQLAlchemy数据库会话
+        """
+        self.db = db
+    
+    def create(self, class_data: dict, scene_id: UUID) -> OntologyClass:
+        """创建本体类型
+        
+        Args:
+            class_data: 类型数据字典，包含class_name和class_description
+            scene_id: 所属场景ID
+            
+        Returns:
+            OntologyClass: 创建的类型对象
+            
+        Raises:
+            Exception: 数据库操作失败
+            
+        Examples:
+            >>> repo = OntologyClassRepository(db)
+            >>> ontology_class = repo.create(
+            ...     {"class_name": "患者", "class_description": "描述"},
+            ...     scene_id
+            ... )
+        """
+        try:
+            logger.info(
+                f"Creating ontology class - "
+                f"name={class_data.get('class_name')}, "
+                f"scene_id={scene_id}"
+            )
+            
+            ontology_class = OntologyClass(
+                class_name=class_data.get("class_name"),
+                class_description=class_data.get("class_description"),
+                scene_id=scene_id
+            )
+            
+            self.db.add(ontology_class)
+            self.db.flush()  # 获取ID但不提交
+            
+            logger.info(
+                f"Ontology class created successfully - "
+                f"class_id={ontology_class.class_id}"
+            )
+            
+            return ontology_class
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to create ontology class: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def get_by_id(self, class_id: UUID) -> Optional[OntologyClass]:
+        """根据ID获取类型
+        
+        Args:
+            class_id: 类型ID
+            
+        Returns:
+            Optional[OntologyClass]: 类型对象，不存在则返回None
+            
+        Examples:
+            >>> repo = OntologyClassRepository(db)
+            >>> ontology_class = repo.get_by_id(class_id)
+        """
+        try:
+            logger.debug(f"Getting ontology class by ID: {class_id}")
+            
+            ontology_class = self.db.query(OntologyClass).filter(
+                OntologyClass.class_id == class_id
+            ).first()
+            
+            if ontology_class:
+                logger.debug(f"Ontology class found: {class_id}")
+            else:
+                logger.debug(f"Ontology class not found: {class_id}")
+            
+            return ontology_class
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to get ontology class by ID: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def get_by_name(self, class_name: str, scene_id: UUID) -> Optional[OntologyClass]:
+        """根据类型名称和场景ID获取类型（精确匹配）
+        
+        Args:
+            class_name: 类型名称
+            scene_id: 场景ID
+            
+        Returns:
+            Optional[OntologyClass]: 类型对象，不存在则返回None
+            
+        Examples:
+            >>> repo = OntologyClassRepository(db)
+            >>> ontology_class = repo.get_by_name("患者", scene_id)
+        """
+        try:
+            logger.debug(f"Getting ontology class by name: {class_name}, scene_id: {scene_id}")
+            
+            ontology_class = self.db.query(OntologyClass).filter(
+                OntologyClass.class_name == class_name,
+                OntologyClass.scene_id == scene_id
+            ).first()
+            
+            if ontology_class:
+                logger.debug(f"Ontology class found: {class_name}")
+            else:
+                logger.debug(f"Ontology class not found: {class_name}")
+            
+            return ontology_class
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to get ontology class by name: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def search_by_name(self, keyword: str, scene_id: UUID) -> List[OntologyClass]:
+        """根据关键词模糊搜索类型
+        
+        使用 LIKE 进行模糊匹配，支持中文和英文。
+        
+        Args:
+            keyword: 搜索关键词
+            scene_id: 场景ID
+            
+        Returns:
+            List[OntologyClass]: 匹配的类型列表
+            
+        Examples:
+            >>> repo = OntologyClassRepository(db)
+            >>> classes = repo.search_by_name("患者", scene_id)
+        """
+        try:
+            logger.debug(
+                f"Searching ontology classes by keyword - "
+                f"keyword={keyword}, scene_id={scene_id}"
+            )
+            
+            # 使用 ilike 进行不区分大小写的模糊匹配
+            classes = self.db.query(OntologyClass).filter(
+                OntologyClass.class_name.ilike(f"%{keyword}%"),
+                OntologyClass.scene_id == scene_id
+            ).order_by(
+                OntologyClass.created_at.desc()
+            ).all()
+            
+            logger.info(
+                f"Found {len(classes)} ontology classes matching keyword '{keyword}' "
+                f"in scene {scene_id}"
+            )
+            
+            return classes
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to search ontology classes by keyword: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def get_by_scene(self, scene_id: UUID) -> List[OntologyClass]:
+        """获取场景下的所有类型
+        
+        按创建时间倒序排列。
+        
+        Args:
+            scene_id: 场景ID
+            
+        Returns:
+            List[OntologyClass]: 类型列表
+            
+        Examples:
+            >>> repo = OntologyClassRepository(db)
+            >>> classes = repo.get_by_scene(scene_id)
+        """
+        try:
+            logger.debug(f"Getting ontology classes by scene: {scene_id}")
+            
+            classes = self.db.query(OntologyClass).filter(
+                OntologyClass.scene_id == scene_id
+            ).order_by(
+                OntologyClass.created_at.desc()
+            ).all()
+            
+            logger.info(
+                f"Found {len(classes)} ontology classes in scene {scene_id}"
+            )
+            
+            return classes
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to get ontology classes by scene: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def update(self, class_id: UUID, update_data: dict) -> Optional[OntologyClass]:
+        """更新类型信息
+        
+        Args:
+            class_id: 类型ID
+            update_data: 更新数据字典
+            
+        Returns:
+            Optional[OntologyClass]: 更新后的类型对象，不存在则返回None
+            
+        Raises:
+            Exception: 数据库操作失败
+            
+        Examples:
+            >>> repo = OntologyClassRepository(db)
+            >>> ontology_class = repo.update(
+            ...     class_id,
+            ...     {"class_name": "新名称"}
+            ... )
+        """
+        try:
+            logger.info(f"Updating ontology class: {class_id}")
+            
+            ontology_class = self.get_by_id(class_id)
+            if not ontology_class:
+                logger.warning(f"Ontology class not found for update: {class_id}")
+                return None
+            
+            # 更新字段
+            if "class_name" in update_data and update_data["class_name"] is not None:
+                ontology_class.class_name = update_data["class_name"]
+            
+            if "class_description" in update_data:
+                ontology_class.class_description = update_data["class_description"]
+            
+            self.db.flush()
+            
+            logger.info(f"Ontology class updated successfully: {class_id}")
+            
+            return ontology_class
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to update ontology class: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def delete(self, class_id: UUID) -> bool:
+        """删除类型
+        
+        Args:
+            class_id: 类型ID
+            
+        Returns:
+            bool: 删除成功返回True，类型不存在返回False
+            
+        Raises:
+            Exception: 数据库操作失败
+            
+        Examples:
+            >>> repo = OntologyClassRepository(db)
+            >>> success = repo.delete(class_id)
+        """
+        try:
+            logger.info(f"Deleting ontology class: {class_id}")
+            
+            ontology_class = self.get_by_id(class_id)
+            if not ontology_class:
+                logger.warning(f"Ontology class not found for delete: {class_id}")
+                return False
+            
+            self.db.delete(ontology_class)
+            self.db.flush()
+            
+            logger.info(f"Ontology class deleted successfully: {class_id}")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to delete ontology class: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def check_ownership(self, class_id: UUID, workspace_id: UUID) -> bool:
+        """检查类型是否属于指定工作空间（通过场景关联）
+        
+        Args:
+            class_id: 类型ID
+            workspace_id: 工作空间ID
+            
+        Returns:
+            bool: 属于返回True，否则返回False
+            
+        Examples:
+            >>> repo = OntologyClassRepository(db)
+            >>> is_owner = repo.check_ownership(class_id, workspace_id)
+        """
+        try:
+            logger.debug(
+                f"Checking class ownership - "
+                f"class_id={class_id}, workspace_id={workspace_id}"
+            )
+            
+            count = self.db.query(OntologyClass).join(
+                OntologyScene,
+                OntologyClass.scene_id == OntologyScene.scene_id
+            ).filter(
+                OntologyClass.class_id == class_id,
+                OntologyScene.workspace_id == workspace_id
+            ).count()
+            
+            is_owner = count > 0
+            
+            logger.debug(
+                f"Class ownership check result: {is_owner} - "
+                f"class_id={class_id}"
+            )
+            
+            return is_owner
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to check class ownership: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def get_scene_id_by_class(self, class_id: UUID) -> Optional[UUID]:
+        """根据类型ID获取所属场景ID
+        
+        Args:
+            class_id: 类型ID
+            
+        Returns:
+            Optional[UUID]: 场景ID，类型不存在则返回None
+            
+        Examples:
+            >>> repo = OntologyClassRepository(db)
+            >>> scene_id = repo.get_scene_id_by_class(class_id)
+        """
+        try:
+            logger.debug(f"Getting scene ID by class: {class_id}")
+            
+            ontology_class = self.get_by_id(class_id)
+            if not ontology_class:
+                logger.debug(f"Class not found: {class_id}")
+                return None
+            
+            logger.debug(
+                f"Found scene ID: {ontology_class.scene_id} for class: {class_id}"
+            )
+            
+            return ontology_class.scene_id
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to get scene ID by class: {str(e)}",
+                exc_info=True
+            )
+            raise

api/app/repositories/ontology_scene_repository.py

@@ -0,0 +1,394 @@
+# -*- coding: utf-8 -*-
+"""本体场景Repository层
+
+本模块提供本体场景的数据访问层实现。
+
+Classes:
+    OntologySceneRepository: 本体场景数据访问类
+"""
+
+import logging
+from typing import List, Optional
+from uuid import UUID
+
+from sqlalchemy.orm import Session, joinedload
+
+from app.core.logging_config import get_db_logger
+from app.models.ontology_scene import OntologyScene
+
+
+logger = get_db_logger()
+
+
+class OntologySceneRepository:
+    """本体场景Repository
+    
+    提供本体场景的CRUD操作和权限检查。
+    
+    Attributes:
+        db: SQLAlchemy数据库会话
+    """
+    
+    def __init__(self, db: Session):
+        """初始化Repository
+        
+        Args:
+            db: SQLAlchemy数据库会话
+        """
+        self.db = db
+    
+    def create(self, scene_data: dict, workspace_id: UUID) -> OntologyScene:
+        """创建本体场景
+        
+        Args:
+            scene_data: 场景数据字典，包含scene_name和scene_description
+            workspace_id: 所属工作空间ID
+            
+        Returns:
+            OntologyScene: 创建的场景对象
+            
+        Raises:
+            Exception: 数据库操作失败
+            
+        Examples:
+            >>> repo = OntologySceneRepository(db)
+            >>> scene = repo.create(
+            ...     {"scene_name": "医疗场景", "scene_description": "描述"},
+            ...     workspace_id
+            ... )
+        """
+        try:
+            logger.info(
+                f"Creating ontology scene - "
+                f"name={scene_data.get('scene_name')}, "
+                f"workspace_id={workspace_id}"
+            )
+            
+            scene = OntologyScene(
+                scene_name=scene_data.get("scene_name"),
+                scene_description=scene_data.get("scene_description"),
+                workspace_id=workspace_id
+            )
+            
+            self.db.add(scene)
+            self.db.flush()  # 获取ID但不提交
+            
+            logger.info(
+                f"Ontology scene created successfully - "
+                f"scene_id={scene.scene_id}"
+            )
+            
+            return scene
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to create ontology scene: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def get_by_id(self, scene_id: UUID) -> Optional[OntologyScene]:
+        """根据ID获取场景
+        
+        Args:
+            scene_id: 场景ID
+            
+        Returns:
+            Optional[OntologyScene]: 场景对象，不存在则返回None
+            
+        Examples:
+            >>> repo = OntologySceneRepository(db)
+            >>> scene = repo.get_by_id(scene_id)
+        """
+        try:
+            logger.debug(f"Getting ontology scene by ID: {scene_id}")
+            
+            scene = self.db.query(OntologyScene).filter(
+                OntologyScene.scene_id == scene_id
+            ).first()
+            
+            if scene:
+                logger.debug(f"Ontology scene found: {scene_id}")
+            else:
+                logger.debug(f"Ontology scene not found: {scene_id}")
+            
+            return scene
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to get ontology scene by ID: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def get_by_name(self, scene_name: str, workspace_id: UUID) -> Optional[OntologyScene]:
+        """根据场景名称和工作空间ID获取场景（精确匹配）
+        
+        Args:
+            scene_name: 场景名称
+            workspace_id: 工作空间ID
+            
+        Returns:
+            Optional[OntologyScene]: 场景对象，不存在则返回None
+            
+        Examples:
+            >>> repo = OntologySceneRepository(db)
+            >>> scene = repo.get_by_name("医疗场景", workspace_id)
+        """
+        try:
+            logger.debug(
+                f"Getting ontology scene by name - "
+                f"scene_name={scene_name}, workspace_id={workspace_id}"
+            )
+            
+            scene = self.db.query(OntologyScene).options(
+                joinedload(OntologyScene.classes)
+            ).filter(
+                OntologyScene.scene_name == scene_name,
+                OntologyScene.workspace_id == workspace_id
+            ).first()
+            
+            if scene:
+                logger.debug(f"Ontology scene found: {scene_name}")
+            else:
+                logger.debug(f"Ontology scene not found: {scene_name}")
+            
+            return scene
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to get ontology scene by name: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def search_by_name(self, keyword: str, workspace_id: UUID) -> List[OntologyScene]:
+        """根据关键词模糊搜索场景
+        
+        使用 LIKE 进行模糊匹配，支持中文和英文。
+        
+        Args:
+            keyword: 搜索关键词
+            workspace_id: 工作空间ID
+            
+        Returns:
+            List[OntologyScene]: 匹配的场景列表
+            
+        Examples:
+            >>> repo = OntologySceneRepository(db)
+            >>> scenes = repo.search_by_name("医疗", workspace_id)
+        """
+        try:
+            logger.debug(
+                f"Searching ontology scenes by keyword - "
+                f"keyword={keyword}, workspace_id={workspace_id}"
+            )
+            
+            # 使用 ilike 进行不区分大小写的模糊匹配
+            scenes = self.db.query(OntologyScene).options(
+                joinedload(OntologyScene.classes)
+            ).filter(
+                OntologyScene.scene_name.ilike(f"%{keyword}%"),
+                OntologyScene.workspace_id == workspace_id
+            ).order_by(
+                OntologyScene.updated_at.desc()
+            ).all()
+            
+            logger.info(
+                f"Found {len(scenes)} ontology scenes matching keyword '{keyword}' "
+                f"in workspace {workspace_id}"
+            )
+            
+            return scenes
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to search ontology scenes by keyword: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def get_by_workspace(self, workspace_id: UUID, page: Optional[int] = None, page_size: Optional[int] = None) -> tuple:
+        """获取工作空间下的所有场景（支持分页）
+        
+        使用joinedload预加载classes关系以统计数量。
+        
+        Args:
+            workspace_id: 工作空间ID
+            page: 页码（可选，从1开始）
+            page_size: 每页数量（可选）
+            
+        Returns:
+            tuple: (场景列表, 总数量)
+            
+        Examples:
+            >>> repo = OntologySceneRepository(db)
+            >>> scenes, total = repo.get_by_workspace(workspace_id)
+            >>> scenes, total = repo.get_by_workspace(workspace_id, page=1, page_size=10)
+        """
+        try:
+            logger.debug(f"Getting ontology scenes by workspace: {workspace_id}, page={page}, page_size={page_size}")
+            
+            # 构建基础查询
+            query = self.db.query(OntologyScene).options(
+                joinedload(OntologyScene.classes)
+            ).filter(
+                OntologyScene.workspace_id == workspace_id
+            ).order_by(
+                OntologyScene.updated_at.desc()
+            )
+            
+            # 获取总数
+            total = query.count()
+            
+            # 如果提供了分页参数，应用分页
+            if page is not None and page_size is not None:
+                offset = (page - 1) * page_size
+                query = query.offset(offset).limit(page_size)
+                logger.debug(f"Applying pagination: offset={offset}, limit={page_size}")
+            
+            scenes = query.all()
+            
+            logger.info(
+                f"Found {len(scenes)} ontology scenes (total: {total}) in workspace {workspace_id}"
+            )
+            
+            return scenes, total
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to get ontology scenes by workspace: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def update(self, scene_id: UUID, update_data: dict) -> Optional[OntologyScene]:
+        """更新场景信息
+        
+        Args:
+            scene_id: 场景ID
+            update_data: 更新数据字典
+            
+        Returns:
+            Optional[OntologyScene]: 更新后的场景对象，不存在则返回None
+            
+        Raises:
+            Exception: 数据库操作失败
+            
+        Examples:
+            >>> repo = OntologySceneRepository(db)
+            >>> scene = repo.update(
+            ...     scene_id,
+            ...     {"scene_name": "新名称"}
+            ... )
+        """
+        try:
+            logger.info(f"Updating ontology scene: {scene_id}")
+            
+            scene = self.get_by_id(scene_id)
+            if not scene:
+                logger.warning(f"Ontology scene not found for update: {scene_id}")
+                return None
+            
+            # 更新字段
+            if "scene_name" in update_data and update_data["scene_name"] is not None:
+                scene.scene_name = update_data["scene_name"]
+            
+            if "scene_description" in update_data:
+                scene.scene_description = update_data["scene_description"]
+            
+            self.db.flush()
+            
+            logger.info(f"Ontology scene updated successfully: {scene_id}")
+            
+            return scene
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to update ontology scene: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def delete(self, scene_id: UUID) -> bool:
+        """删除场景（级联删除类型）
+        
+        依赖数据库级联删除配置（ondelete="CASCADE"）。
+        
+        Args:
+            scene_id: 场景ID
+            
+        Returns:
+            bool: 删除成功返回True，场景不存在返回False
+            
+        Raises:
+            Exception: 数据库操作失败
+            
+        Examples:
+            >>> repo = OntologySceneRepository(db)
+            >>> success = repo.delete(scene_id)
+        """
+        try:
+            logger.info(f"Deleting ontology scene: {scene_id}")
+            
+            scene = self.get_by_id(scene_id)
+            if not scene:
+                logger.warning(f"Ontology scene not found for delete: {scene_id}")
+                return False
+            
+            self.db.delete(scene)
+            self.db.flush()
+            
+            logger.info(
+                f"Ontology scene deleted successfully (cascade): {scene_id}"
+            )
+            
+            return True
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to delete ontology scene: {str(e)}",
+                exc_info=True
+            )
+            raise
+    
+    def check_ownership(self, scene_id: UUID, workspace_id: UUID) -> bool:
+        """检查场景是否属于指定工作空间
+        
+        Args:
+            scene_id: 场景ID
+            workspace_id: 工作空间ID
+            
+        Returns:
+            bool: 属于返回True，否则返回False
+            
+        Examples:
+            >>> repo = OntologySceneRepository(db)
+            >>> is_owner = repo.check_ownership(scene_id, workspace_id)
+        """
+        try:
+            logger.debug(
+                f"Checking scene ownership - "
+                f"scene_id={scene_id}, workspace_id={workspace_id}"
+            )
+            
+            count = self.db.query(OntologyScene).filter(
+                OntologyScene.scene_id == scene_id,
+                OntologyScene.workspace_id == workspace_id
+            ).count()
+            
+            is_owner = count > 0
+            
+            logger.debug(
+                f"Scene ownership check result: {is_owner} - "
+                f"scene_id={scene_id}"
+            )
+            
+            return is_owner
+            
+        except Exception as e:
+            logger.error(
+                f"Failed to check scene ownership: {str(e)}",
+                exc_info=True
+            )
+            raise

api/app/repositories/prompt_optimizer_repository.py

@@ -4,7 +4,10 @@ from sqlalchemy.orm import Session
 
 from app.core.logging_config import get_db_logger
 from app.models.prompt_optimizer_model import (
-    PromptOptimizerSession, PromptOptimizerSessionHistory, RoleType
+    PromptOptimizerSession,
+    PromptOptimizerSessionHistory,
+    RoleType,
+    PromptHistory
 )
 
 db_logger = get_db_logger()
@@ -16,6 +19,12 @@ class PromptOptimizerSessionRepository:
     def __init__(self, db: Session):
         self.db = db
 
+    def get_session_by_id(self, session_id: uuid.UUID) -> PromptOptimizerSession | None:
+        session = self.db.query(PromptOptimizerSession).filter(
+            PromptOptimizerSession.id == session_id,
+        ).first()
+        return session
+
     def create_session(
             self,
             tenant_id: uuid.UUID,
@@ -38,12 +47,9 @@ class PromptOptimizerSessionRepository:
                 user_id=user_id,
             )
             self.db.add(session)
-            self.db.commit()
-            self.db.refresh(session)
-            db_logger.debug(f"Prompt optimization session created: ID:{session.id}")
             return session
         except Exception as e:
-            db_logger.error(f"Error creating prompt optimization session: user_id={user_id} - {str(e)}")
+            db_logger.error(f"Error creating prompt optimization session: - {str(e)}")
             raise
 
     def get_session_history(
@@ -71,10 +77,10 @@ class PromptOptimizerSessionRepository:
                 PromptOptimizerSession.id == session_id,
                 PromptOptimizerSession.user_id == user_id
             ).first()
-            
+
             if not session:
                 return []
-            
+
             history = self.db.query(PromptOptimizerSessionHistory).filter(
                 PromptOptimizerSessionHistory.session_id == session.id,
                 PromptOptimizerSessionHistory.user_id == user_id
@@ -104,11 +110,11 @@ class PromptOptimizerSessionRepository:
                 PromptOptimizerSession.user_id == user_id,
                 PromptOptimizerSession.tenant_id == tenant_id
             ).first()
-            
+
             if not session:
                 db_logger.error(f"Session {session_id} not found for user {user_id}")
                 raise ValueError(f"Session {session_id} not found for user {user_id}")
-            
+
             message = PromptOptimizerSessionHistory(
                 tenant_id=tenant_id,
                 session_id=session.id,
@@ -117,8 +123,199 @@ class PromptOptimizerSessionRepository:
                 content=content,
             )
             self.db.add(message)
-            self.db.commit()
+
             return message
         except Exception as e:
             db_logger.error(f"Error creating prompt optimization session history: session_id={session_id} - {str(e)}")
             raise
+
+    def get_first_user_message(self, session_id: uuid.UUID) -> str | None:
+        """
+        Get the first user message from a session.
+
+        Args:
+            session_id (uuid.UUID): The session ID.
+
+        Returns:
+            str | None: The content of the first user message, or None if not found.
+        """
+        try:
+            message = self.db.query(PromptOptimizerSessionHistory).filter(
+                PromptOptimizerSessionHistory.session_id == session_id,
+                PromptOptimizerSessionHistory.role == RoleType.USER.value
+            ).order_by(
+                PromptOptimizerSessionHistory.created_at.asc()
+            ).first()
+            
+            return message.content if message else None
+        except Exception as e:
+            db_logger.error(f"Error getting first user message: session_id={session_id} - {str(e)}")
+            raise
+
+
+class PromptReleaseRepository:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def get_prompt_by_session_id(self, session_id: uuid.UUID) -> PromptHistory | None:
+        prompt_obj = self.db.query(PromptHistory).filter(
+            PromptHistory.session_id == session_id,
+            PromptHistory.is_delete.is_(False)
+        ).first()
+        return prompt_obj
+
+    def create_prompt_release(
+            self,
+            tenant_id: uuid.UUID,
+            title: str,
+            session_id: uuid.UUID,
+            prompt: str,
+    ) -> PromptHistory:
+        try:
+            prompt_obj = PromptHistory(
+                tenant_id=tenant_id,
+                title=title,
+                session_id=session_id,
+                prompt=prompt,
+            )
+            self.db.add(prompt_obj)
+            return prompt_obj
+        except Exception as e:
+            db_logger.error(f"Error creating prompt release: session_id={session_id} - {str(e)}")
+            raise
+
+    def soft_delete_prompt(self, prompt_obj: PromptHistory) -> None:
+        """
+        Soft delete a prompt release by setting is_delete flag to True.
+
+        Args:
+            prompt_obj (PromptHistory): The prompt release object to delete.
+        """
+        try:
+            prompt_obj.is_delete = True
+            db_logger.debug(f"Soft deleted prompt release: id={prompt_obj.id}, session_id={prompt_obj.session_id}")
+        except Exception as e:
+            db_logger.error(f"Error soft deleting prompt release: id={prompt_obj.id} - {str(e)}")
+            raise
+
+    def get_prompt_by_id(self, prompt_id: uuid.UUID) -> PromptHistory | None:
+        """
+        Get a prompt release by its ID.
+
+        Args:
+            prompt_id (uuid.UUID): The prompt release ID.
+
+        Returns:
+            PromptHistory | None: The prompt release object or None if not found.
+        """
+        try:
+            prompt_obj = self.db.query(PromptHistory).filter(
+                PromptHistory.id == prompt_id
+            ).first()
+            return prompt_obj
+        except Exception as e:
+            db_logger.error(f"Error getting prompt release by id: id={prompt_id} - {str(e)}")
+            raise
+
+    def count_prompts(self, tenant_id: uuid.UUID) -> int:
+        """
+        Count total number of non-deleted prompts for a tenant.
+
+        Args:
+            tenant_id (uuid.UUID): The tenant ID.
+
+        Returns:
+            int: Total count of prompts.
+        """
+        try:
+            count = self.db.query(PromptHistory).filter(
+                PromptHistory.tenant_id == tenant_id,
+                PromptHistory.is_delete.is_(False)
+            ).count()
+            return count
+        except Exception as e:
+            db_logger.error(f"Error counting prompts: tenant_id={tenant_id} - {str(e)}")
+            raise
+
+    def get_prompts_paginated(
+            self,
+            tenant_id: uuid.UUID,
+            offset: int,
+            limit: int
+    ) -> list[PromptHistory]:
+        """
+        Get paginated list of prompt releases for a tenant.
+
+        Args:
+            tenant_id (uuid.UUID): The tenant ID.
+            offset (int): Number of records to skip.
+            limit (int): Maximum number of records to return.
+
+        Returns:
+            list[PromptHistory]: List of prompt releases.
+        """
+        try:
+            prompts = self.db.query(PromptHistory).filter(
+                PromptHistory.tenant_id == tenant_id,
+                PromptHistory.is_delete.is_(False)
+            ).order_by(
+                PromptHistory.created_at.desc()
+            ).offset(offset).limit(limit).all()
+            return prompts
+        except Exception as e:
+            db_logger.error(f"Error getting paginated prompts: tenant_id={tenant_id} - {str(e)}")
+            raise
+
+    def count_prompts_by_keyword(self, tenant_id: uuid.UUID, keyword: str) -> int:
+        """
+        Count total number of non-deleted prompts matching keyword for a tenant.
+
+        Args:
+            tenant_id (uuid.UUID): The tenant ID.
+            keyword (str): Search keyword for title.
+
+        Returns:
+            int: Total count of matching prompts.
+        """
+        try:
+            count = self.db.query(PromptHistory).filter(
+                PromptHistory.tenant_id == tenant_id,
+                PromptHistory.is_delete.is_(False),
+                PromptHistory.title.ilike(f"%{keyword}%")
+            ).count()
+            return count
+        except Exception as e:
+            db_logger.error(f"Error counting prompts by keyword: tenant_id={tenant_id}, keyword={keyword} - {str(e)}")
+            raise
+
+    def search_prompts_paginated(
+            self,
+            tenant_id: uuid.UUID,
+            keyword: str,
+            offset: int,
+            limit: int
+    ) -> list[PromptHistory]:
+        """
+        Search prompt releases by keyword in title with pagination.
+
+        Args:
+            tenant_id (uuid.UUID): The tenant ID.
+            keyword (str): Search keyword for title.
+            offset (int): Number of records to skip.
+            limit (int): Maximum number of records to return.
+
+        Returns:
+            list[PromptHistory]: List of matching prompt releases.
+        """
+        try:
+            prompts = self.db.query(PromptHistory).filter(
+                PromptHistory.tenant_id == tenant_id,
+                PromptHistory.is_delete.is_(False),
+                PromptHistory.title.ilike(f"%{keyword}%")
+            ).order_by(
+                PromptHistory.created_at.desc()
+            ).offset(offset).limit(limit).all()
+            return prompts
+        except Exception as e:
+            db_logger.error(f"Error searching prompts: tenant_id={tenant_id}, keyword={keyword} - {str(e)}")
+            raise