Merge pull request #352 from SuanmoSuanyangTechnology/fix/model_base

fix(model)

.gitignore

@@ -21,7 +21,6 @@ examples/
 
 # Temporary outputs
 .DS_Store
-.hypothesis/
 time.log
 celerybeat-schedule.db
 search_results.json
@@ -37,4 +36,5 @@ tika-server*.jar*
 cl100k_base.tiktoken
 libssl*.deb
 
-sandbox/lib/seccomp_redbear/target
+sandbox/lib/seccomp_python/target
+sandbox/lib/seccomp_nodejs/target

api/app/cache/__init__.py

@@ -2,7 +2,10 @@
 Cache 缓存模块
 
 提供各种缓存功能的统一入口
-注意：隐性记忆和情绪建议已迁移到数据库存储，不再使用Redis缓存
 """
+from .memory import EmotionMemoryCache, ImplicitMemoryCache
 
-__all__ = []
+__all__ = [
+    "EmotionMemoryCache",
+    "ImplicitMemoryCache",
+]

api/app/cache/memory/__init__.py

@@ -2,7 +2,11 @@
 Memory 缓存模块
 
 提供记忆系统相关的缓存功能
-注意：隐性记忆和情绪建议已迁移到数据库存储，不再使用Redis缓存
 """
+from .emotion_memory import EmotionMemoryCache
+from .implicit_memory import ImplicitMemoryCache
 
-__all__ = []
+__all__ = [
+    "EmotionMemoryCache",
+    "ImplicitMemoryCache",
+]

api/app/cache/memory/emotion_memory.py

@@ -0,0 +1,134 @@
+"""
+Emotion Suggestions Cache
+
+情绪个性化建议缓存模块
+用于缓存用户的情绪个性化建议数据
+"""
+import json
+import logging
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+from app.aioRedis import aio_redis
+
+logger = logging.getLogger(__name__)
+
+
+class EmotionMemoryCache:
+    """情绪建议缓存类"""
+    
+    # Key 前缀
+    PREFIX = "cache:memory:emotion_memory"
+    
+    @classmethod
+    def _get_key(cls, *parts: str) -> str:
+        """生成 Redis key
+        
+        Args:
+            *parts: key 的各个部分
+            
+        Returns:
+            完整的 Redis key
+        """
+        return ":".join([cls.PREFIX] + list(parts))
+    
+    @classmethod
+    async def set_emotion_suggestions(
+        cls,
+        user_id: str,
+        suggestions_data: Dict[str, Any],
+        expire: int = 86400
+    ) -> bool:
+        """设置用户情绪建议缓存
+        
+        Args:
+            user_id: 用户ID（end_user_id）
+            suggestions_data: 建议数据字典，包含：
+                - health_summary: 健康状态摘要
+                - suggestions: 建议列表
+                - generated_at: 生成时间（可选）
+            expire: 过期时间（秒），默认24小时（86400秒）
+            
+        Returns:
+            是否设置成功
+        """
+        try:
+            key = cls._get_key("suggestions", user_id)
+            
+            # 添加生成时间戳
+            if "generated_at" not in suggestions_data:
+                suggestions_data["generated_at"] = datetime.now().isoformat()
+            
+            # 添加缓存标记
+            suggestions_data["cached"] = True
+            
+            value = json.dumps(suggestions_data, ensure_ascii=False)
+            await aio_redis.set(key, value, ex=expire)
+            logger.info(f"设置情绪建议缓存成功: {key}, 过期时间: {expire}秒")
+            return True
+        except Exception as e:
+            logger.error(f"设置情绪建议缓存失败: {e}", exc_info=True)
+            return False
+    
+    @classmethod
+    async def get_emotion_suggestions(cls, user_id: str) -> Optional[Dict[str, Any]]:
+        """获取用户情绪建议缓存
+        
+        Args:
+            user_id: 用户ID（end_user_id）
+            
+        Returns:
+            建议数据字典，如果不存在或已过期返回 None
+        """
+        try:
+            key = cls._get_key("suggestions", user_id)
+            value = await aio_redis.get(key)
+            
+            if value:
+                data = json.loads(value)
+                logger.info(f"成功获取情绪建议缓存: {key}")
+                return data
+            
+            logger.info(f"情绪建议缓存不存在或已过期: {key}")
+            return None
+        except Exception as e:
+            logger.error(f"获取情绪建议缓存失败: {e}", exc_info=True)
+            return None
+    
+    @classmethod
+    async def delete_emotion_suggestions(cls, user_id: str) -> bool:
+        """删除用户情绪建议缓存
+        
+        Args:
+            user_id: 用户ID（end_user_id）
+            
+        Returns:
+            是否删除成功
+        """
+        try:
+            key = cls._get_key("suggestions", user_id)
+            result = await aio_redis.delete(key)
+            logger.info(f"删除情绪建议缓存: {key}, 结果: {result}")
+            return result > 0
+        except Exception as e:
+            logger.error(f"删除情绪建议缓存失败: {e}", exc_info=True)
+            return False
+    
+    @classmethod
+    async def get_suggestions_ttl(cls, user_id: str) -> int:
+        """获取情绪建议缓存的剩余过期时间
+        
+        Args:
+            user_id: 用户ID（end_user_id）
+            
+        Returns:
+            剩余秒数，-1表示永不过期，-2表示key不存在
+        """
+        try:
+            key = cls._get_key("suggestions", user_id)
+            ttl = await aio_redis.ttl(key)
+            logger.debug(f"情绪建议缓存TTL: {key} = {ttl}秒")
+            return ttl
+        except Exception as e:
+            logger.error(f"获取情绪建议缓存TTL失败: {e}")
+            return -2

api/app/cache/memory/implicit_memory.py

@@ -0,0 +1,136 @@
+"""
+Implicit Memory Profile Cache
+
+隐式记忆用户画像缓存模块
+用于缓存用户的完整画像数据（偏好标签、四维画像、兴趣领域、行为习惯）
+"""
+import json
+import logging
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+from app.aioRedis import aio_redis
+
+logger = logging.getLogger(__name__)
+
+
+class ImplicitMemoryCache:
+    """隐式记忆用户画像缓存类"""
+    
+    # Key 前缀
+    PREFIX = "cache:memory:implicit_memory"
+    
+    @classmethod
+    def _get_key(cls, *parts: str) -> str:
+        """生成 Redis key
+        
+        Args:
+            *parts: key 的各个部分
+            
+        Returns:
+            完整的 Redis key
+        """
+        return ":".join([cls.PREFIX] + list(parts))
+    
+    @classmethod
+    async def set_user_profile(
+        cls,
+        user_id: str,
+        profile_data: Dict[str, Any],
+        expire: int = 86400
+    ) -> bool:
+        """设置用户完整画像缓存
+        
+        Args:
+            user_id: 用户ID（end_user_id）
+            profile_data: 画像数据字典，包含：
+                - preferences: 偏好标签列表
+                - portrait: 四维画像对象
+                - interest_areas: 兴趣领域分布对象
+                - habits: 行为习惯列表
+                - generated_at: 生成时间（可选）
+            expire: 过期时间（秒），默认24小时（86400秒）
+            
+        Returns:
+            是否设置成功
+        """
+        try:
+            key = cls._get_key("profile", user_id)
+            
+            # 添加生成时间戳
+            if "generated_at" not in profile_data:
+                profile_data["generated_at"] = datetime.now().isoformat()
+            
+            # 添加缓存标记
+            profile_data["cached"] = True
+            
+            value = json.dumps(profile_data, ensure_ascii=False)
+            await aio_redis.set(key, value, ex=expire)
+            logger.info(f"设置用户画像缓存成功: {key}, 过期时间: {expire}秒")
+            return True
+        except Exception as e:
+            logger.error(f"设置用户画像缓存失败: {e}", exc_info=True)
+            return False
+    
+    @classmethod
+    async def get_user_profile(cls, user_id: str) -> Optional[Dict[str, Any]]:
+        """获取用户完整画像缓存
+        
+        Args:
+            user_id: 用户ID（end_user_id）
+            
+        Returns:
+            画像数据字典，如果不存在或已过期返回 None
+        """
+        try:
+            key = cls._get_key("profile", user_id)
+            value = await aio_redis.get(key)
+            
+            if value:
+                data = json.loads(value)
+                logger.info(f"成功获取用户画像缓存: {key}")
+                return data
+            
+            logger.info(f"用户画像缓存不存在或已过期: {key}")
+            return None
+        except Exception as e:
+            logger.error(f"获取用户画像缓存失败: {e}", exc_info=True)
+            return None
+    
+    @classmethod
+    async def delete_user_profile(cls, user_id: str) -> bool:
+        """删除用户完整画像缓存
+        
+        Args:
+            user_id: 用户ID（end_user_id）
+            
+        Returns:
+            是否删除成功
+        """
+        try:
+            key = cls._get_key("profile", user_id)
+            result = await aio_redis.delete(key)
+            logger.info(f"删除用户画像缓存: {key}, 结果: {result}")
+            return result > 0
+        except Exception as e:
+            logger.error(f"删除用户画像缓存失败: {e}", exc_info=True)
+            return False
+    
+    @classmethod
+    async def get_profile_ttl(cls, user_id: str) -> int:
+        """获取用户画像缓存的剩余过期时间
+        
+        Args:
+            user_id: 用户ID（end_user_id）
+            
+        Returns:
+            剩余秒数，-1表示永不过期，-2表示key不存在
+        """
+        try:
+            key = cls._get_key("profile", user_id)
+            ttl = await aio_redis.ttl(key)
+            logger.debug(f"用户画像缓存TTL: {key} = {ttl}秒")
+            return ttl
+        except Exception as e:
+            logger.error(f"获取用户画像缓存TTL失败: {e}")
+            return -2

api/app/celery_app.py

@@ -4,7 +4,6 @@ from datetime import timedelta
 from urllib.parse import quote
 
 from celery import Celery
-from celery.schedules import crontab
 
 from app.core.config import settings
 
@@ -77,14 +76,12 @@ celery_app.conf.update(
         # Document tasks → document_tasks queue (prefork worker)
         'app.core.rag.tasks.parse_document': {'queue': 'document_tasks'},
         'app.core.rag.tasks.build_graphrag_for_kb': {'queue': 'document_tasks'},
-        'app.core.rag.tasks.sync_knowledge_for_kb': {'queue': 'document_tasks'},
         
         # Beat/periodic tasks → periodic_tasks queue (dedicated periodic worker)
         'app.tasks.workspace_reflection_task': {'queue': 'periodic_tasks'},
         'app.tasks.regenerate_memory_cache': {'queue': 'periodic_tasks'},
         'app.tasks.run_forgetting_cycle_task': {'queue': 'periodic_tasks'},
-        'app.tasks.write_all_workspaces_memory_task': {'queue': 'periodic_tasks'},
-        'app.tasks.update_implicit_emotions_storage': {'queue': 'periodic_tasks'},
+        'app.controllers.memory_storage_controller.search_all': {'queue': 'periodic_tasks'},
     },
 )
 
@@ -92,44 +89,40 @@ celery_app.conf.update(
 celery_app.autodiscover_tasks(['app'])
 
 # Celery Beat schedule for periodic tasks
-memory_increment_schedule = timedelta(hours=settings.MEMORY_INCREMENT_INTERVAL_HOURS)
-memory_cache_regeneration_schedule = timedelta(hours=settings.MEMORY_CACHE_REGENERATION_HOURS)
-workspace_reflection_schedule = timedelta(seconds=settings.WORKSPACE_REFLECTION_INTERVAL_SECONDS)
-forgetting_cycle_schedule = timedelta(hours=settings.FORGETTING_CYCLE_INTERVAL_HOURS)
-implicit_emotions_update_schedule = crontab(
-    hour=settings.IMPLICIT_EMOTIONS_UPDATE_HOUR,
-    minute=settings.IMPLICIT_EMOTIONS_UPDATE_MINUTE,
-)
+# memory_increment_schedule = timedelta(hours=settings.MEMORY_INCREMENT_INTERVAL_HOURS)
+# memory_cache_regeneration_schedule = timedelta(hours=settings.MEMORY_CACHE_REGENERATION_HOURS)
+# workspace_reflection_schedule = timedelta(seconds=30)  # 每30秒运行一次settings.REFLECTION_INTERVAL_TIME
+# forgetting_cycle_schedule = timedelta(hours=24)  # 每24小时运行一次遗忘周期
 
-#构建定时任务配置
-beat_schedule_config = {
-    "run-workspace-reflection": {
-        "task": "app.tasks.workspace_reflection_task",
-        "schedule": workspace_reflection_schedule,
-        "args": (),
-    },
-    "regenerate-memory-cache": {
-        "task": "app.tasks.regenerate_memory_cache",
-        "schedule": memory_cache_regeneration_schedule,
-        "args": (),
-    },
-    "run-forgetting-cycle": {
-        "task": "app.tasks.run_forgetting_cycle_task",
-        "schedule": forgetting_cycle_schedule,
-        "kwargs": {
-            "config_id": None,  # 使用默认配置，可以通过环境变量配置
-        },
-    },
-    "write-all-workspaces-memory": {
-        "task": "app.tasks.write_all_workspaces_memory_task",
-        "schedule": memory_increment_schedule,
-        "args": (),
-    },
-    "update-implicit-emotions-storage": {
-        "task": "app.tasks.update_implicit_emotions_storage",
-        "schedule": implicit_emotions_update_schedule,
-        "args": (),
-    },
-}
+# 构建定时任务配置
+# beat_schedule_config = {
+#     "run-workspace-reflection": {
+#         "task": "app.tasks.workspace_reflection_task",
+#         "schedule": workspace_reflection_schedule,
+#         "args": (),
+#     },
+#     "regenerate-memory-cache": {
+#         "task": "app.tasks.regenerate_memory_cache",
+#         "schedule": memory_cache_regeneration_schedule,
+#         "args": (),
+#     },
+#     "run-forgetting-cycle": {
+#         "task": "app.tasks.run_forgetting_cycle_task",
+#         "schedule": forgetting_cycle_schedule,
+#         "kwargs": {
+#             "config_id": None,  # 使用默认配置，可以通过环境变量配置
+#         },
+#     },
+# }
 
-celery_app.conf.beat_schedule = beat_schedule_config
+# 如果配置了默认工作空间ID，则添加记忆总量统计任务
+# if settings.DEFAULT_WORKSPACE_ID:
+#     beat_schedule_config["write-total-memory"] = {
+#         "task": "app.controllers.memory_storage_controller.search_all",
+#         "schedule": memory_increment_schedule,
+#         "kwargs": {
+#             "workspace_id": settings.DEFAULT_WORKSPACE_ID,
+#         },
+#     }
+
+# celery_app.conf.beat_schedule = beat_schedule_config

api/app/controllers/__init__.py

@@ -19,18 +19,14 @@ from . import (
     implicit_memory_controller,
     knowledge_controller,
     knowledgeshare_controller,
-    mcp_market_controller,
-    mcp_market_config_controller,
     memory_agent_controller,
     memory_dashboard_controller,
     memory_episodic_controller,
     memory_explicit_controller,
     memory_forget_controller,
-    memory_perceptual_controller,
     memory_reflection_controller,
     memory_short_term_controller,
     memory_storage_controller,
-    memory_working_controller,
     model_controller,
     multi_agent_controller,
     prompt_optimizer_controller,
@@ -43,9 +39,13 @@ from . import (
     upload_controller,
     user_controller,
     user_memory_controllers,
+    workflow_controller,
     workspace_controller,
+    memory_forget_controller,
+    home_page_controller,
+    memory_perceptual_controller,
+    memory_working_controller,
     ontology_controller,
-    skill_controller
 )
 
 # 创建管理端 API 路由器
@@ -62,8 +62,6 @@ manager_router.include_router(model_controller.router)
 manager_router.include_router(file_controller.router)
 manager_router.include_router(document_controller.router)
 manager_router.include_router(knowledge_controller.router)
-manager_router.include_router(mcp_market_controller.router)
-manager_router.include_router(mcp_market_config_controller.router)
 manager_router.include_router(chunk_controller.router)
 manager_router.include_router(test_controller.router)
 manager_router.include_router(knowledgeshare_controller.router)
@@ -80,6 +78,7 @@ manager_router.include_router(release_share_controller.router)
 manager_router.include_router(public_share_controller.router)  # 公开路由（无需认证）
 manager_router.include_router(memory_dashboard_controller.router)
 manager_router.include_router(multi_agent_controller.router)
+manager_router.include_router(workflow_controller.router)
 manager_router.include_router(emotion_controller.router)
 manager_router.include_router(emotion_config_controller.router)
 manager_router.include_router(prompt_optimizer_controller.router)
@@ -93,6 +92,5 @@ manager_router.include_router(memory_perceptual_controller.router)
 manager_router.include_router(memory_working_controller.router)
 manager_router.include_router(file_storage_controller.router)
 manager_router.include_router(ontology_controller.router)
-manager_router.include_router(skill_controller.router)
 
 __all__ = ["manager_router"]

api/app/controllers/app_controller.py

@@ -22,7 +22,6 @@ from app.services import app_service, workspace_service
 from app.services.agent_config_helper import enrich_agent_config
 from app.services.app_service import AppService
 from app.services.workflow_service import WorkflowService, get_workflow_service
-from app.services.app_statistics_service import AppStatisticsService
 
 router = APIRouter(prefix="/apps", tags=["Apps"])
 logger = get_business_logger()
@@ -455,8 +454,7 @@ async def draft_run(
                         user_id=payload.user_id or str(current_user.id),
                         variables=payload.variables,
                         storage_type=storage_type,
-                        user_rag_memory_id=user_rag_memory_id,
-                        files=payload.files  # 传递多模态文件
+                        user_rag_memory_id=user_rag_memory_id
                 ):
                     yield event
 
@@ -477,8 +475,7 @@ async def draft_run(
                 "app_id": str(app_id),
                 "message_length": len(payload.message),
                 "has_conversation_id": bool(payload.conversation_id),
-                "has_variables": bool(payload.variables),
-                "has_files": bool(payload.files)
+                "has_variables": bool(payload.variables)
             }
         )
 
@@ -493,8 +490,7 @@ async def draft_run(
             user_id=payload.user_id or str(current_user.id),
             variables=payload.variables,
             storage_type=storage_type,
-            user_rag_memory_id=user_rag_memory_id,
-            files=payload.files  # 传递多模态文件
+            user_rag_memory_id=user_rag_memory_id
         )
 
         logger.debug(
@@ -802,8 +798,7 @@ async def draft_run_compare(
                     web_search=True,
                     memory=True,
                     parallel=payload.parallel,
-                    timeout=payload.timeout or 60,
-                    files=payload.files
+                    timeout=payload.timeout or 60
             ):
                 yield event
 
@@ -906,46 +901,15 @@ def get_app_statistics(
         - total_tokens: 总token消耗
     """
     workspace_id = current_user.current_workspace_id
+    
+    from app.services.app_statistics_service import AppStatisticsService
     stats_service = AppStatisticsService(db)
-
+    
     result = stats_service.get_app_statistics(
         app_id=app_id,
         workspace_id=workspace_id,
         start_date=start_date,
         end_date=end_date
     )
-
-    return success(data=result)
-
-
-@router.get("/workspace/api-statistics", summary="工作空间API调用统计")
-@cur_workspace_access_guard()
-def get_workspace_api_statistics(
-        start_date: int,
-        end_date: int,
-        db: Session = Depends(get_db),
-        current_user=Depends(get_current_user),
-):
-    """获取工作空间API调用统计
     
-    Args:
-        start_date: 开始时间戳（毫秒）
-        end_date: 结束时间戳（毫秒）
-    
-    Returns:
-        每日统计数据列表，每项包含：
-        - date: 日期
-        - total_calls: 当日总调用次数
-        - app_calls: 当日应用调用次数
-        - service_calls: 当日服务调用次数
-    """
-    workspace_id = current_user.current_workspace_id
-    stats_service = AppStatisticsService(db)
-
-    result = stats_service.get_workspace_api_statistics(
-        workspace_id=workspace_id,
-        start_date=start_date,
-        end_date=end_date
-    )
-
     return success(data=result)

api/app/controllers/auth_controller.py

@@ -61,7 +61,6 @@ async def login_for_access_token(
                 user = auth_service.register_user_with_invite(
                 db=db,
                 email=form_data.email,
-                username=form_data.username,
                 password=form_data.password,
                 invite_token=form_data.invite,
                 workspace_id=invite_info.workspace_id

api/app/controllers/emotion_controller.py

@@ -11,7 +11,6 @@ Routes:
 """
 
 from app.core.error_codes import BizCode
-from app.core.language_utils import get_language_from_header
 from app.core.logging_config import get_api_logger
 from app.core.response_utils import fail, success
 from app.dependencies import get_current_user, get_db
@@ -46,14 +45,11 @@ emotion_service = EmotionAnalyticsService()
 @router.post("/tags", response_model=ApiResponse)
 async def get_emotion_tags(
     request: EmotionTagsRequest,
-    language_type: str = Header(default=None, alias="X-Language-Type"),
+    language_type: str = Header(default="zh", alias="X-Language-Type"),
     current_user: User = Depends(get_current_user),
 ):
 
     try:
-        # 使用集中化的语言校验
-        language = get_language_from_header(language_type)
-        
         api_logger.info(
             f"用户 {current_user.username} 请求获取情绪标签统计",
             extra={
@@ -61,8 +57,7 @@ async def get_emotion_tags(
                 "emotion_type": request.emotion_type,
                 "start_date": request.start_date,
                 "end_date": request.end_date,
-                "limit": request.limit,
-                "language_type": language
+                "limit": request.limit
             }
         )
 
@@ -72,8 +67,7 @@ async def get_emotion_tags(
             emotion_type=request.emotion_type,
             start_date=request.start_date,
             end_date=request.end_date,
-            limit=request.limit,
-            language=language
+            limit=request.limit
         )
 
         api_logger.info(
@@ -103,14 +97,11 @@ async def get_emotion_tags(
 @router.post("/wordcloud", response_model=ApiResponse)
 async def get_emotion_wordcloud(
     request: EmotionWordcloudRequest,
-    language_type: str = Header(default=None, alias="X-Language-Type"),
+    language_type: str = Header(default="zh", alias="X-Language-Type"),
     current_user: User = Depends(get_current_user),
 ):
 
     try:
-        # 使用集中化的语言校验
-        language = get_language_from_header(language_type)
-        
         api_logger.info(
             f"用户 {current_user.username} 请求获取情绪词云数据",
             extra={
@@ -153,14 +144,11 @@ async def get_emotion_wordcloud(
 @router.post("/health", response_model=ApiResponse)
 async def get_emotion_health(
     request: EmotionHealthRequest,
-    language_type: str = Header(default=None, alias="X-Language-Type"),
+    language_type: str = Header(default="zh", alias="X-Language-Type"),
     current_user: User = Depends(get_current_user),
 ):
 
     try:
-        # 使用集中化的语言校验
-        language = get_language_from_header(language_type)
-        
         # 验证时间范围参数
         if request.time_range not in ["7d", "30d", "90d"]:
             raise HTTPException(
@@ -186,7 +174,7 @@ async def get_emotion_health(
             "情绪健康指数获取成功",
             extra={
                 "end_user_id": request.end_user_id,
-                "health_score": data.get("health_score") or 0,
+                "health_score": data.get("health_score", 0),
                 "level": data.get("level", "未知")
             }
         )
@@ -208,64 +196,14 @@ async def get_emotion_health(
 
 
 
-# @router.post("/check-data", response_model=ApiResponse)
-# async def check_emotion_data_exists(
-#     request: EmotionSuggestionsRequest,
-#     db: Session = Depends(get_db),
-#     current_user: User = Depends(get_current_user),
-# ):
-#     """检查用户情绪建议数据是否存在
-
-#     Args:
-#         request: 包含 end_user_id
-#         db: 数据库会话
-#         current_user: 当前用户
-
-#     Returns:
-#         数据存在状态
-#     """
-#     try:
-#         api_logger.info(
-#             f"检查用户情绪建议数据是否存在: {request.end_user_id}",
-#             extra={"end_user_id": request.end_user_id}
-#         )
-
-#         # 从数据库获取建议
-#         data = await emotion_service.get_cached_suggestions(
-#             end_user_id=request.end_user_id,
-#             db=db
-#         )
-
-#         if data is None:
-#             api_logger.info(f"用户 {request.end_user_id} 的情绪建议数据不存在")
-#             return fail(
-#                 BizCode.NOT_FOUND,
-#                 "情绪建议数据不存在，请点击右上角刷新进行初始化",
-#                 {"exists": False}
-#             )
-
-#         api_logger.info(f"用户 {request.end_user_id} 的情绪建议数据存在")
-#         return success(data={"exists": True}, msg="情绪建议数据已存在")
-
-#     except Exception as e:
-#         api_logger.error(
-#             f"检查情绪建议数据失败: {str(e)}",
-#             extra={"end_user_id": request.end_user_id},
-#             exc_info=True
-#         )
-#         raise HTTPException(
-#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-#             detail=f"检查情绪建议数据失败: {str(e)}"
-#         )
-
-
 @router.post("/suggestions", response_model=ApiResponse)
 async def get_emotion_suggestions(
     request: EmotionSuggestionsRequest,
+    language_type: str = Header(default="zh", alias="X-Language-Type"),
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
 ):
-    """获取个性化情绪建议（从数据库读取）
+    """获取个性化情绪建议（从缓存读取）
 
     Args:
         request: 包含 end_user_id 和可选的 config_id
@@ -273,42 +211,44 @@ async def get_emotion_suggestions(
         current_user: 当前用户
 
     Returns:
-        存储的个性化情绪建议响应
+        缓存的个性化情绪建议响应
     """
     try:
         api_logger.info(
-            f"用户 {current_user.username} 请求获取个性化情绪建议",
+            f"用户 {current_user.username} 请求获取个性化情绪建议（缓存）",
             extra={
                 "end_user_id": request.end_user_id,
                 "config_id": request.config_id
             }
         )
 
-        # 从数据库获取建议
+        # 从缓存获取建议
         data = await emotion_service.get_cached_suggestions(
             end_user_id=request.end_user_id,
             db=db
         )
 
         if data is None:
+            # 缓存不存在或已过期
             api_logger.info(
-                f"用户 {request.end_user_id} 的建议数据不存在",
+                f"用户 {request.end_user_id} 的建议缓存不存在或已过期",
                 extra={"end_user_id": request.end_user_id}
             )
-            return success(
-                data={"exists": False},
-                msg="情绪建议数据不存在，请点击右上角刷新进行初始化"
+            return fail(
+                BizCode.NOT_FOUND,
+                "建议缓存不存在或已过期，请右上角刷新生成新建议",
+                ""
             )
 
         api_logger.info(
-            "个性化建议获取成功",
+            "个性化建议获取成功（缓存）",
             extra={
                 "end_user_id": request.end_user_id,
                 "suggestions_count": len(data.get("suggestions", []))
             }
         )
 
-        return success(data=data, msg="个性化建议获取成功")
+        return success(data=data, msg="个性化建议获取成功（缓存）")
 
     except Exception as e:
         api_logger.error(
@@ -325,11 +265,11 @@ async def get_emotion_suggestions(
 @router.post("/generate_suggestions", response_model=ApiResponse)
 async def generate_emotion_suggestions(
     request: EmotionGenerateSuggestionsRequest,
-    language_type: str = Header(default=None, alias="X-Language-Type"),
+    language_type: str = Header(default="zh", alias="X-Language-Type"),
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
 ):
-    """生成个性化情绪建议（调用LLM并保存到数据库）
+    """生成个性化情绪建议（调用LLM并缓存）
 
     Args:
         request: 包含 end_user_id
@@ -340,9 +280,6 @@ async def generate_emotion_suggestions(
         新生成的个性化情绪建议响应
     """
     try:
-        # 使用集中化的语言校验
-        language = get_language_from_header(language_type)
-        
         api_logger.info(
             f"用户 {current_user.username} 请求生成个性化情绪建议",
             extra={
@@ -353,15 +290,15 @@ async def generate_emotion_suggestions(
         # 调用服务层生成建议
         data = await emotion_service.generate_emotion_suggestions(
             end_user_id=request.end_user_id,
-            db=db,
-            language=language
+            db=db
         )
 
-        # 保存到数据库
+        # 保存到缓存
         await emotion_service.save_suggestions_cache(
             end_user_id=request.end_user_id,
             suggestions_data=data,
-            db=db
+            db=db,
+            expires_hours=24
         )
 
         api_logger.info(
@@ -383,4 +320,4 @@ async def generate_emotion_suggestions(
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=f"生成个性化建议失败: {str(e)}"
-        )
+        )

api/app/controllers/file_storage_controller.py

@@ -29,7 +29,7 @@ from app.core.storage_exceptions import (
     StorageUploadError,
 )
 from app.db import get_db
-from app.dependencies import get_current_user, get_share_user_id, ShareTokenData
+from app.dependencies import get_current_user
 from app.models.file_metadata_model import FileMetadata
 from app.models.user_model import User
 from app.schemas.response_schema import ApiResponse
@@ -143,141 +143,6 @@ async def upload_file(
     )
 
 
-@router.post("/share/files", response_model=ApiResponse)
-async def upload_file_with_share_token(
-    file: UploadFile = File(...),
-    db: Session = Depends(get_db),
-    share_data: ShareTokenData = Depends(get_share_user_id),
-    storage_service: FileStorageService = Depends(get_file_storage_service),
-):
-    """
-    Upload a file to the configured storage backend using share_token authentication.
-    """
-    from app.services.release_share_service import ReleaseShareService
-    from app.models.app_model import App
-    from app.models.workspace_model import Workspace
-    
-    # Get share and release info from share_token
-    service = ReleaseShareService(db)
-    share_info = service.get_shared_release_info(share_token=share_data.share_token)
-    
-    # Get share object to access app_id
-    share = service.repo.get_by_share_token(share_data.share_token)
-    if not share:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Shared app not found"
-        )
-    
-    # Get app to access workspace_id
-    app = db.query(App).filter(
-        App.id == share.app_id,
-        App.is_active.is_(True)
-    ).first()
-    
-    if not app:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="App not found"
-        )
-    
-    # Get workspace to access tenant_id
-    workspace = db.query(Workspace).filter(
-        Workspace.id == app.workspace_id
-    ).first()
-    
-    if not workspace:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Workspace not found"
-        )
-    
-    tenant_id = workspace.tenant_id
-    workspace_id = app.workspace_id
-
-    api_logger.info(
-        f"Storage upload request (share): tenant_id={tenant_id}, workspace_id={workspace_id}, "
-        f"filename={file.filename}, share_token={share_data.share_token}"
-    )
-
-    # Read file contents
-    contents = await file.read()
-    file_size = len(contents)
-
-    # Validate file size
-    if file_size == 0:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="The file is empty."
-        )
-
-    if file_size > settings.MAX_FILE_SIZE:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"The file size exceeds the {settings.MAX_FILE_SIZE} byte limit"
-        )
-
-    # Extract file extension
-    _, file_extension = os.path.splitext(file.filename)
-    file_ext = file_extension.lower()
-
-    # Generate file_id and file_key
-    file_id = uuid.uuid4()
-    file_key = generate_file_key(
-        tenant_id=tenant_id,
-        workspace_id=workspace_id,
-        file_id=file_id,
-        file_ext=file_ext,
-    )
-
-    # Create file metadata record with pending status
-    file_metadata = FileMetadata(
-        id=file_id,
-        tenant_id=tenant_id,
-        workspace_id=workspace_id,
-        file_key=file_key,
-        file_name=file.filename,
-        file_ext=file_ext,
-        file_size=file_size,
-        content_type=file.content_type,
-        status="pending",
-    )
-    db.add(file_metadata)
-    db.commit()
-    db.refresh(file_metadata)
-
-    # Upload file to storage backend
-    try:
-        await storage_service.upload_file(
-            tenant_id=tenant_id,
-            workspace_id=workspace_id,
-            file_id=file_id,
-            file_ext=file_ext,
-            content=contents,
-            content_type=file.content_type,
-        )
-        # Update status to completed
-        file_metadata.status = "completed"
-        db.commit()
-        api_logger.info(f"File uploaded to storage (share): file_key={file_key}")
-    except StorageUploadError as e:
-        # Update status to failed
-        file_metadata.status = "failed"
-        db.commit()
-        api_logger.error(f"Storage upload failed (share): {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"File storage failed: {str(e)}"
-        )
-
-    api_logger.info(f"File upload successful (share): {file.filename} (file_id: {file_id})")
-
-    return success(
-        data={"file_id": str(file_id), "file_key": file_key},
-        msg="File upload successful"
-    )
-
-
 @router.get("/files/{file_id}", response_model=Any)
 async def download_file(
     file_id: uuid.UUID,

api/app/controllers/implicit_memory_controller.py

@@ -122,48 +122,6 @@ def validate_confidence_threshold(threshold: float) -> None:
         raise ValueError("confidence_threshold must be between 0.0 and 1.0")
 
 
-@router.get("/check-data/{end_user_id}", response_model=ApiResponse)
-@cur_workspace_access_guard()
-async def check_user_data_exists(
-    end_user_id: str,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-) -> ApiResponse:
-    """
-    检查用户画像数据是否存在
-    
-    Args:
-        end_user_id: 目标用户ID
-        
-    Returns:
-        数据存在状态
-    """
-    api_logger.info(f"检查用户画像数据是否存在: {end_user_id}")
-    
-    try:
-        # Validate inputs
-        validate_user_id(end_user_id)
-        
-        # Create service with user-specific config
-        service = ImplicitMemoryService(db=db, end_user_id=end_user_id)
-        
-        # Get cached profile
-        cached_profile = await service.get_cached_profile(end_user_id=end_user_id, db=db)
-        
-        if cached_profile is None:
-            api_logger.info(f"用户 {end_user_id} 的画像数据不存在")
-            return success(
-                data={"exists": False},
-                msg="画像数据不存在，请点击右上角刷新进行初始化"
-            )
-        
-        api_logger.info(f"用户 {end_user_id} 的画像数据存在")
-        return success(data={"exists": True}, msg="画像数据已存在")
-        
-    except Exception as e:
-        return handle_implicit_memory_error(e, "检查画像数据", end_user_id)
-
-
 @router.get("/preferences/{end_user_id}", response_model=ApiResponse)
 @cur_workspace_access_guard()
 async def get_preference_tags(
@@ -201,8 +159,12 @@ async def get_preference_tags(
         cached_profile = await service.get_cached_profile(end_user_id=end_user_id, db=db)
         
         if cached_profile is None:
-            api_logger.info(f"用户 {end_user_id} 的画像数据不存在")
-            return fail(BizCode.NOT_FOUND, "", "")
+            api_logger.info(f"用户 {end_user_id} 的画像缓存不存在或已过期")
+            return fail(
+                BizCode.NOT_FOUND,
+                "画像缓存不存在或已过期，请右上角刷新生成新画像",
+                ""
+            )
         
         # Extract preferences from cache
         preferences = cached_profile.get("preferences", [])
@@ -268,8 +230,12 @@ async def get_dimension_portrait(
         cached_profile = await service.get_cached_profile(end_user_id=end_user_id, db=db)
         
         if cached_profile is None:
-            api_logger.info(f"用户 {end_user_id} 的画像数据不存在")
-            return fail(BizCode.NOT_FOUND, "", "")
+            api_logger.info(f"用户 {end_user_id} 的画像缓存不存在或已过期")
+            return fail(
+                BizCode.NOT_FOUND,
+                "画像缓存不存在或已过期，请右上角刷新生成新画像",
+                ""
+            )
         
         # Extract portrait from cache
         portrait = cached_profile.get("portrait", {})
@@ -312,8 +278,12 @@ async def get_interest_area_distribution(
         cached_profile = await service.get_cached_profile(end_user_id=end_user_id, db=db)
         
         if cached_profile is None:
-            api_logger.info(f"用户 {end_user_id} 的画像数据不存在")
-            return fail(BizCode.NOT_FOUND, "", "")
+            api_logger.info(f"用户 {end_user_id} 的画像缓存不存在或已过期")
+            return fail(
+                BizCode.NOT_FOUND,
+                "画像缓存不存在或已过期，请右上角刷新生成新画像",
+                ""
+            )
         
         # Extract interest areas from cache
         interest_areas = cached_profile.get("interest_areas", {})
@@ -360,8 +330,12 @@ async def get_behavior_habits(
         cached_profile = await service.get_cached_profile(end_user_id=end_user_id, db=db)
         
         if cached_profile is None:
-            api_logger.info(f"用户 {end_user_id} 的画像数据不存在")
-            return fail(BizCode.NOT_FOUND, "", "")
+            api_logger.info(f"用户 {end_user_id} 的画像缓存不存在或已过期")
+            return fail(
+                BizCode.NOT_FOUND,
+                "画像缓存不存在或已过期，请右上角刷新生成新画像",
+                ""
+            )
         
         # Extract habits from cache
         habits = cached_profile.get("habits", [])

api/app/controllers/knowledge_controller.py

@@ -9,16 +9,13 @@ from sqlalchemy import or_
 from sqlalchemy.orm import Session
 
 from app.celery_app import celery_app
-from app.core.error_codes import BizCode
 from app.core.logging_config import get_api_logger
 from app.core.rag.common import settings
-from app.core.rag.integrations.feishu.client import FeishuAPIClient
-from app.core.rag.integrations.yuque.client import YuqueAPIClient
 from app.core.rag.llm.chat_model import Base
 from app.core.rag.nlp import rag_tokenizer, search
 from app.core.rag.prompts.generator import graph_entity_types
 from app.core.rag.vdb.elasticsearch.elasticsearch_vector import ElasticSearchVectorFactory
-from app.core.response_utils import success, fail
+from app.core.response_utils import success
 from app.db import get_db
 from app.dependencies import get_current_user
 from app.models import knowledge_model
@@ -487,99 +484,3 @@ async def rebuild_knowledge_graph(
     except Exception as e:
         api_logger.error(f"Failed to rebuild knowledge graph: knowledge_id={knowledge_id} - {str(e)}")
         raise
-
-
-@router.get("/check/yuque/auth", response_model=ApiResponse)
-async def check_yuque_auth(
-        yuque_user_id: str,
-        yuque_token: str,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    check yuque auth info
-    """
-    api_logger.info(f"check yuque auth info, username: {current_user.username}")
-
-    try:
-        api_client = YuqueAPIClient(
-            user_id=yuque_user_id,
-            token=yuque_token
-        )
-        async with api_client as client:
-            repos = await client.get_user_repos()
-            if repos:
-                return success(msg="Successfully auth yuque info")
-        return fail(BizCode.UNAUTHORIZED, msg="auth yuque info failed", error="user_id or token is incorrect")
-    except HTTPException:
-        raise
-    except Exception as e:
-        api_logger.error(f"auth yuque info failed: {str(e)}")
-        raise
-
-
-@router.get("/check/feishu/auth", response_model=ApiResponse)
-async def check_feishu_auth(
-        feishu_app_id: str,
-        feishu_app_secret: str,
-        feishu_folder_token: str,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    check feishu auth info
-    """
-    api_logger.info(f"check feishu auth info, username: {current_user.username}")
-
-    try:
-        api_client = FeishuAPIClient(
-            app_id=feishu_app_id,
-            app_secret=feishu_app_secret
-        )
-        async with api_client as client:
-            files = await client.list_all_folder_files(feishu_folder_token, recursive=True)
-            if files:
-                return success(msg="Successfully auth feishu info")
-        return fail(BizCode.UNAUTHORIZED, msg="auth feishu info failed", error="app_id or app_secret or feishu_folder_token is incorrect")
-    except HTTPException:
-        raise
-    except Exception as e:
-        api_logger.error(f"auth feishu info failed: {str(e)}")
-        raise
-
-
-@router.post("/{knowledge_id}/sync", response_model=ApiResponse)
-async def sync_knowledge(
-        knowledge_id: uuid.UUID,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    sync knowledge base information based on knowledge_id
-    """
-    api_logger.info(f"Obtain details of the knowledge base: knowledge_id={knowledge_id}, username: {current_user.username}")
-
-    try:
-        # 1. Query knowledge base information from the database
-        api_logger.debug(f"Query knowledge base: {knowledge_id}")
-        db_knowledge = knowledge_service.get_knowledge_by_id(db, knowledge_id=knowledge_id, current_user=current_user)
-        if not db_knowledge:
-            api_logger.warning(f"The knowledge base does not exist or access is denied: knowledge_id={knowledge_id}")
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="The knowledge base does not exist or access is denied"
-            )
-
-        # 2. sync knowledge
-        # from app.tasks import sync_knowledge_for_kb
-        # sync_knowledge_for_kb(kb_id)
-        task = celery_app.send_task("app.core.rag.tasks.sync_knowledge_for_kb", args=[knowledge_id])
-        result = {
-             "task_id": task.id
-        }
-        return success(data=result, msg="Task accepted. sync knowledge is being processed in the background.")
-    except HTTPException:
-        raise
-    except Exception as e:
-        api_logger.error(f"Failed to sync knowledge: knowledge_id={knowledge_id} - {str(e)}")
-        raise

api/app/controllers/mcp_market_config_controller.py

@@ -1,336 +0,0 @@
-import datetime
-import json
-from typing import Optional
-import uuid
-
-from fastapi import APIRouter, Depends, HTTPException, status, Query
-from fastapi.encoders import jsonable_encoder
-import requests
-from sqlalchemy import or_
-from sqlalchemy.orm import Session
-from modelscope.hub.errors import raise_for_http_status
-from modelscope.hub.mcp_api import MCPApi
-
-from app.core.logging_config import get_api_logger
-from app.core.response_utils import success, fail
-from app.db import get_db
-from app.dependencies import get_current_user
-from app.models import mcp_market_config_model
-from app.models.user_model import User
-from app.schemas import mcp_market_config_schema
-from app.schemas.response_schema import ApiResponse
-from app.services import mcp_market_config_service
-
-# Obtain a dedicated API logger
-api_logger = get_api_logger()
-
-router = APIRouter(
-    prefix="/mcp_market_configs",
-    tags=["mcp_market_configs"],
-    dependencies=[Depends(get_current_user)]  # Apply auth to all routes in this controller
-)
-
-
-@router.get("/mcp_servers", response_model=ApiResponse)
-async def get_mcp_servers(
-        mcp_market_config_id: uuid.UUID,
-        page: int = Query(1, gt=0),  # Default: 1, which must be greater than 0
-        pagesize: int = Query(20, gt=0, le=100),  # Default: 20 items per page, maximum: 100 items
-        keywords: Optional[str] = Query(None, description="Search keywords (Optional search query string,e.g. Chinese service name, English service name, author/owner username)"),
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    Query the mcp servers list in pages
-    - Support keyword search for name,author,owner
-    - Return paging metadata + mcp server list
-    """
-    api_logger.info(
-        f"Query mcp server list: tenant_id={current_user.tenant_id}, page={page}, pagesize={pagesize}, keywords={keywords}, username: {current_user.username}")
-
-    # 1. parameter validation
-    if page < 1 or pagesize < 1:
-        api_logger.warning(f"Error in paging parameters: page={page}, pagesize={pagesize}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="The paging parameter must be greater than 0"
-        )
-
-    # 2. Query mcp market config information from the database
-    api_logger.debug(f"Query mcp market config: {mcp_market_config_id}")
-    db_mcp_market_config = mcp_market_config_service.get_mcp_market_config_by_id(db,
-                                                                                 mcp_market_config_id=mcp_market_config_id,
-                                                                                 current_user=current_user)
-    if not db_mcp_market_config:
-        api_logger.warning(
-            f"The mcp market config does not exist or access is denied: mcp_market_config_id={mcp_market_config_id}")
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="The mcp market config does not exist or access is denied"
-        )
-
-    # 3. Execute paged query
-    api = MCPApi()
-    token = db_mcp_market_config.token
-    api.login(token)
-
-    body = {
-        'filter': {},
-        'page_number': page,
-        'page_size': pagesize,
-        'search': keywords
-    }
-
-    try:
-        cookies = api.get_cookies(token)
-        r = api.session.put(
-            url=api.mcp_base_url,
-            headers=api.builder_headers(api.headers),
-            json=body,
-            cookies=cookies)
-        raise_for_http_status(r)
-    except requests.exceptions.RequestException as e:
-        api_logger.error(f"mFailed to get MCP servers: {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to get MCP servers: {str(e)}"
-        )
-
-    data = api._handle_response(r)
-    total = data.get('total_count', 0)
-    mcp_server_list = data.get('mcp_server_list', [])
-    # items = [{
-    #     'name': item.get('name', ''),
-    #     'id': item.get('id', ''),
-    #     'description': item.get('description', '')
-    # } for item in mcp_server_list]
-
-    # 4. Return structured response
-    result = {
-        "items": mcp_server_list,
-        "page": {
-            "page": page,
-            "pagesize": pagesize,
-            "total": total,
-            "has_next": True if page * pagesize < total else False
-        }
-    }
-    return success(data=result, msg="Query of mcp servers list successful")
-
-
-@router.get("/mcp_server", response_model=ApiResponse)
-async def get_mcp_server(
-        mcp_market_config_id: uuid.UUID,
-        server_id: str,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    Get detailed information for a specific MCP Server
-    """
-    api_logger.info(
-        f"Query mcp server: tenant_id={current_user.tenant_id}, mcp_market_config_id={mcp_market_config_id}, server_id={server_id}, username: {current_user.username}")
-
-    # 1. Query mcp market config information from the database
-    api_logger.debug(f"Query mcp market config: {mcp_market_config_id}")
-    db_mcp_market_config = mcp_market_config_service.get_mcp_market_config_by_id(db,
-                                                                                 mcp_market_config_id=mcp_market_config_id,
-                                                                                 current_user=current_user)
-    if not db_mcp_market_config:
-        api_logger.warning(
-            f"The mcp market config does not exist or access is denied: mcp_market_config_id={mcp_market_config_id}")
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="The mcp market config does not exist or access is denied"
-        )
-
-    # 2. Get detailed information for a specific MCP Server
-    api = MCPApi()
-    token = db_mcp_market_config.token
-    api.login(token)
-
-    result = api.get_mcp_server(server_id=server_id)
-    return success(data=result, msg="Query of mcp servers list successful")
-
-
-@router.post("/mcp_market_config", response_model=ApiResponse)
-async def create_mcp_market_config(
-        create_data: mcp_market_config_schema.McpMarketConfigCreate,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    create mcp market config
-    """
-    api_logger.info(
-        f"Request to create a mcp market config: mcp_market_id={create_data.mcp_market_id}, tenant_id={current_user.tenant_id}, username: {current_user.username}")
-
-    try:
-        api_logger.debug(f"Start creating the mcp market config: {create_data.mcp_market_id}")
-        # 1. Check if the mcp market name already exists
-        db_mcp_market_config_exist = mcp_market_config_service.get_mcp_market_config_by_mcp_market_id(db, mcp_market_id=create_data.mcp_market_id, current_user=current_user)
-        if db_mcp_market_config_exist:
-            api_logger.warning(f"The mcp market id already exists: {create_data.mcp_market_id}")
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"The mcp market id already exists: {create_data.mcp_market_id}"
-            )
-        db_mcp_market_config = mcp_market_config_service.create_mcp_market_config(db=db, mcp_market_config=create_data, current_user=current_user)
-        api_logger.info(
-            f"The mcp market config has been successfully created: (ID: {db_mcp_market_config.id})")
-        return success(data=jsonable_encoder(mcp_market_config_schema.McpMarketConfig.model_validate(db_mcp_market_config)),
-                       msg="The mcp market config has been successfully created")
-    except Exception as e:
-        api_logger.error(f"The creation of the mcp market config failed: {create_data.mcp_market_id} - {str(e)}")
-        raise
-
-
-@router.get("/{mcp_market_config_id}", response_model=ApiResponse)
-async def get_mcp_market_config(
-        mcp_market_config_id: uuid.UUID,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    Retrieve mcp market config information based on mcp_market_config_id
-    """
-    api_logger.info(
-        f"Obtain details of the mcp market config: mcp_market_config_id={mcp_market_config_id}, username: {current_user.username}")
-
-    try:
-        # 1. Query mcp market config information from the database
-        api_logger.debug(f"Query mcp market config: {mcp_market_config_id}")
-        db_mcp_market_config = mcp_market_config_service.get_mcp_market_config_by_id(db, mcp_market_config_id=mcp_market_config_id, current_user=current_user)
-        if not db_mcp_market_config:
-            api_logger.warning(f"The mcp market config does not exist or access is denied: mcp_market_config_id={mcp_market_config_id}")
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="The mcp market config does not exist or access is denied"
-            )
-
-        api_logger.info(f"mcp market config query successful: (ID: {db_mcp_market_config.id})")
-        return success(data=jsonable_encoder(mcp_market_config_schema.McpMarketConfig.model_validate(db_mcp_market_config)),
-                       msg="Successfully obtained mcp market config information")
-    except HTTPException:
-        raise
-    except Exception as e:
-        api_logger.error(f"mcp market config query failed: mcp_market_config_id={mcp_market_config_id} - {str(e)}")
-        raise
-
-
-@router.get("/mcp_market_id/{mcp_market_id}", response_model=ApiResponse)
-async def get_mcp_market_config_by_mcp_market_id(
-        mcp_market_id: uuid.UUID,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    Retrieve mcp market config information based on mcp_market_id
-    """
-    api_logger.info(
-        f"Request to create a mcp market config: mcp_market_id={mcp_market_id}, tenant_id={current_user.tenant_id}, username: {current_user.username}")
-
-    try:
-        # 1. Query mcp market config information from the database
-        api_logger.debug(f"Query mcp market config: mcp_market_id={mcp_market_id}")
-        db_mcp_market_config = mcp_market_config_service.get_mcp_market_config_by_mcp_market_id(db, mcp_market_id=mcp_market_id, current_user=current_user)
-        if not db_mcp_market_config:
-            api_logger.warning(f"The mcp market config does not exist or access is denied: mcp_market_id={mcp_market_id}")
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="The mcp market config does not exist or access is denied"
-            )
-
-        api_logger.info(f"mcp market config query successful: (ID: {db_mcp_market_config.id})")
-        return success(data=jsonable_encoder(mcp_market_config_schema.McpMarketConfig.model_validate(db_mcp_market_config)),
-                       msg="Successfully obtained mcp market config information")
-    except HTTPException:
-        raise
-    except Exception as e:
-        api_logger.error(f"mcp market config query failed: mcp_market_id={mcp_market_id} - {str(e)}")
-        raise
-
-
-@router.put("/{mcp_market_config_id}", response_model=ApiResponse)
-async def update_mcp_market_config(
-        mcp_market_config_id: uuid.UUID,
-        update_data: mcp_market_config_schema.McpMarketConfigUpdate,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    # 1. Check if the mcp market config exists
-    api_logger.debug(f"Query the mcp market config to be updated: {mcp_market_config_id}")
-    db_mcp_market_config = mcp_market_config_service.get_mcp_market_config_by_id(db, mcp_market_config_id=mcp_market_config_id, current_user=current_user)
-
-    if not db_mcp_market_config:
-        api_logger.warning(
-            f"The mcp market config does not exist or you do not have permission to access it: mcp_market_config_id={mcp_market_config_id}")
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="The mcp market config does not exist or you do not have permission to access it"
-        )
-
-    # 2. Update fields (only update non-null fields)
-    api_logger.debug(f"Start updating the mcp market config fields: {mcp_market_config_id}")
-    update_dict = update_data.dict(exclude_unset=True)
-    updated_fields = []
-    for field, value in update_dict.items():
-        if hasattr(db_mcp_market_config, field):
-            old_value = getattr(db_mcp_market_config, field)
-            if old_value != value:
-                # update value
-                setattr(db_mcp_market_config, field, value)
-                updated_fields.append(f"{field}: {old_value} -> {value}")
-
-    if updated_fields:
-        api_logger.debug(f"updated fields: {', '.join(updated_fields)}")
-
-    # 3. Save to database
-    try:
-        db.commit()
-        db.refresh(db_mcp_market_config)
-        api_logger.info(f"The mcp market config has been successfully updated: (ID: {db_mcp_market_config.id})")
-    except Exception as e:
-        db.rollback()
-        api_logger.error(f"The mcp market config update failed: mcp_market_config_id={mcp_market_config_id} - {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"The mcp market config update failed: {str(e)}"
-        )
-
-    # 4. Return the updated mcp market config
-    return success(data=jsonable_encoder(mcp_market_config_schema.McpMarketConfig.model_validate(db_mcp_market_config)),
-                   msg="The mcp market config information updated successfully")
-
-
-@router.delete("/{mcp_market_config_id}", response_model=ApiResponse)
-async def delete_mcp_market_config(
-        mcp_market_config_id: uuid.UUID,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    delete mcp market config
-    """
-    api_logger.info(f"Request to delete mcp market config: mcp_market_config_id={mcp_market_config_id}, username: {current_user.username}")
-
-    try:
-        # 1. Check whether the mcp market config exists
-        api_logger.debug(f"Check whether the mcp market config exists: {mcp_market_config_id}")
-        db_mcp_market_config = mcp_market_config_service.get_mcp_market_config_by_id(db, mcp_market_config_id=mcp_market_config_id, current_user=current_user)
-
-        if not db_mcp_market_config:
-            api_logger.warning(
-                f"The mcp market config does not exist or you do not have permission to access it: mcp_market_config_id={mcp_market_config_id}")
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="The mcp market config does not exist or you do not have permission to access it"
-            )
-
-        # 2. Deleting mcp market config
-        mcp_market_config_service.delete_mcp_market_config_by_id(db, mcp_market_config_id=mcp_market_config_id, current_user=current_user)
-        api_logger.info(f"The mcp market config has been successfully deleted: (ID: {mcp_market_config_id})")
-        return success(msg="The mcp market config has been successfully deleted")
-    except Exception as e:
-        api_logger.error(f"Failed to delete from the mcp market config: mcp_market_config_id={mcp_market_config_id} - {str(e)}")
-        raise

api/app/controllers/mcp_market_controller.py

@@ -1,262 +0,0 @@
-import datetime
-import json
-from typing import Optional
-import uuid
-
-from fastapi import APIRouter, Depends, HTTPException, status, Query
-from fastapi.encoders import jsonable_encoder
-from sqlalchemy import or_
-from sqlalchemy.orm import Session
-
-from app.core.logging_config import get_api_logger
-from app.core.response_utils import success, fail
-from app.db import get_db
-from app.dependencies import get_current_user
-from app.models import mcp_market_model
-from app.models.user_model import User
-from app.schemas import mcp_market_schema
-from app.schemas.response_schema import ApiResponse
-from app.services import mcp_market_service
-
-# Obtain a dedicated API logger
-api_logger = get_api_logger()
-
-router = APIRouter(
-    prefix="/mcp_markets",
-    tags=["mcp_markets"],
-    dependencies=[Depends(get_current_user)]  # Apply auth to all routes in this controller
-)
-
-
-@router.get("/mcp_markets", response_model=ApiResponse)
-async def get_mcp_markets(
-        page: int = Query(1, gt=0),  # Default: 1, which must be greater than 0
-        pagesize: int = Query(20, gt=0, le=100),  # Default: 20 items per page, maximum: 100 items
-        orderby: Optional[str] = Query(None, description="Sort fields, such as: category, created_at"),
-        desc: Optional[bool] = Query(False, description="Is it descending order"),
-        keywords: Optional[str] = Query(None, description="Search keywords (mcp_market base name)"),
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    Query the mcp markets list in pages
-    - Support keyword search for name,description
-    - Support dynamic sorting
-    - Return paging metadata + mcp_market list
-    """
-    api_logger.info(
-        f"Query mcp market list: tenant_id={current_user.tenant_id}, page={page}, pagesize={pagesize}, keywords={keywords}, username: {current_user.username}")
-
-    # 1. parameter validation
-    if page < 1 or pagesize < 1:
-        api_logger.warning(f"Error in paging parameters: page={page}, pagesize={pagesize}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="The paging parameter must be greater than 0"
-        )
-
-    # 2. Construct query conditions
-    filters = []
-
-    # Keyword search (fuzzy matching of mcp market name,description)
-    if keywords:
-        api_logger.debug(f"Add keyword search criteria: {keywords}")
-        filters.append(
-            or_(
-                mcp_market_model.McpMarket.name.ilike(f"%{keywords}%"),
-                mcp_market_model.McpMarket.description.ilike(f"%{keywords}%")
-            )
-        )
-    # 3. Execute paged query
-    try:
-        api_logger.debug("Start executing mcp market paging query")
-        total, items = mcp_market_service.get_mcp_markets_paginated(
-            db=db,
-            filters=filters,
-            page=page,
-            pagesize=pagesize,
-            orderby=orderby,
-            desc=desc,
-            current_user=current_user
-        )
-        api_logger.info(f"mcp market query successful: total={total}, returned={len(items)} records")
-    except Exception as e:
-        api_logger.error(f"mcp market query failed: {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Query failed: {str(e)}"
-        )
-
-    # 4. Return structured response
-    result = {
-        "items": items,
-        "page": {
-            "page": page,
-            "pagesize": pagesize,
-            "total": total,
-            "has_next": True if page * pagesize < total else False
-        }
-    }
-    return success(data=jsonable_encoder(result), msg="Query of mcp market list successful")
-
-
-@router.post("/mcp_market", response_model=ApiResponse)
-async def create_mcp_market(
-        create_data: mcp_market_schema.McpMarketCreate,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    create mcp market
-    """
-    api_logger.info(
-        f"Request to create a mcp market: name={create_data.name}, tenant_id={current_user.tenant_id}, username: {current_user.username}")
-
-    try:
-        api_logger.debug(f"Start creating the mcp market: {create_data.name}")
-        # 1. Check if the mcp market name already exists
-        db_mcp_market_exist = mcp_market_service.get_mcp_market_by_name(db, name=create_data.name, current_user=current_user)
-        if db_mcp_market_exist:
-            api_logger.warning(f"The mcp market name already exists: {create_data.name}")
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"The mcp market name already exists: {create_data.name}"
-            )
-        db_mcp_market = mcp_market_service.create_mcp_market(db=db, mcp_market=create_data, current_user=current_user)
-        api_logger.info(
-            f"The mcp market has been successfully created: {db_mcp_market.name} (ID: {db_mcp_market.id})")
-        return success(data=jsonable_encoder(mcp_market_schema.McpMarket.model_validate(db_mcp_market)),
-                       msg="The mcp market has been successfully created")
-    except Exception as e:
-        api_logger.error(f"The creation of the mcp market failed: {create_data.name} - {str(e)}")
-        raise
-
-
-@router.get("/{mcp_market_id}", response_model=ApiResponse)
-async def get_mcp_market(
-        mcp_market_id: uuid.UUID,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    Retrieve mcp market information based on mcp_market_id
-    """
-    api_logger.info(
-        f"Obtain details of the mcp market: mcp_market_id={mcp_market_id}, username: {current_user.username}")
-
-    try:
-        # 1. Query mcp market information from the database
-        api_logger.debug(f"Query mcp market: {mcp_market_id}")
-        db_mcp_market = mcp_market_service.get_mcp_market_by_id(db, mcp_market_id=mcp_market_id, current_user=current_user)
-        if not db_mcp_market:
-            api_logger.warning(f"The mcp market does not exist or access is denied: mcp_market_id={mcp_market_id}")
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="The mcp market does not exist or access is denied"
-            )
-
-        api_logger.info(f"mcp market query successful: {db_mcp_market.name} (ID: {db_mcp_market.id})")
-        return success(data=jsonable_encoder(mcp_market_schema.McpMarket.model_validate(db_mcp_market)),
-                       msg="Successfully obtained mcp market information")
-    except HTTPException:
-        raise
-    except Exception as e:
-        api_logger.error(f"mcp market query failed: mcp_market_id={mcp_market_id} - {str(e)}")
-        raise
-
-
-@router.put("/{mcp_market_id}", response_model=ApiResponse)
-async def update_mcp_market(
-        mcp_market_id: uuid.UUID,
-        update_data: mcp_market_schema.McpMarketUpdate,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    # 1. Check if the mcp market exists
-    api_logger.debug(f"Query the mcp market to be updated: {mcp_market_id}")
-    db_mcp_market = mcp_market_service.get_mcp_market_by_id(db, mcp_market_id=mcp_market_id, current_user=current_user)
-
-    if not db_mcp_market:
-        api_logger.warning(
-            f"The mcp market does not exist or you do not have permission to access it: mcp_market_id={mcp_market_id}")
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="The mcp market does not exist or you do not have permission to access it"
-        )
-
-    # 2. not updating the name (name already exists)
-    update_dict = update_data.dict(exclude_unset=True)
-    if "name" in update_dict:
-        name = update_dict["name"]
-        if name != db_mcp_market.name:
-            # Check if the mcp market name already exists
-            db_mcp_market_exist = mcp_market_service.get_mcp_market_by_name(db, name=name, current_user=current_user)
-            if db_mcp_market_exist:
-                api_logger.warning(f"The mcp market name already exists: {name}")
-                raise HTTPException(
-                    status_code=status.HTTP_400_BAD_REQUEST,
-                    detail=f"The mcp market name already exists: {name}"
-                )
-    # 3. Update fields (only update non-null fields)
-    api_logger.debug(f"Start updating the mcp market fields: {mcp_market_id}")
-    updated_fields = []
-    for field, value in update_dict.items():
-        if hasattr(db_mcp_market, field):
-            old_value = getattr(db_mcp_market, field)
-            if old_value != value:
-                # update value
-                setattr(db_mcp_market, field, value)
-                updated_fields.append(f"{field}: {old_value} -> {value}")
-
-    if updated_fields:
-        api_logger.debug(f"updated fields: {', '.join(updated_fields)}")
-
-    # 4. Save to database
-    try:
-        db.commit()
-        db.refresh(db_mcp_market)
-        api_logger.info(f"The mcp market has been successfully updated: {db_mcp_market.name} (ID: {db_mcp_market.id})")
-    except Exception as e:
-        db.rollback()
-        api_logger.error(f"The mcp market update failed: mcp_market_id={mcp_market_id} - {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"The mcp market update failed: {str(e)}"
-        )
-
-    # 5. Return the updated mcp market
-    return success(data=jsonable_encoder(mcp_market_schema.McpMarket.model_validate(db_mcp_market)),
-                   msg="The mcp market information updated successfully")
-
-
-@router.delete("/{mcp_market_id}", response_model=ApiResponse)
-async def delete_mcp_market(
-        mcp_market_id: uuid.UUID,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    delete mcp market
-    """
-    api_logger.info(f"Request to delete mcp market: mcp_market_id={mcp_market_id}, username: {current_user.username}")
-
-    try:
-        # 1. Check whether the mcp market exists
-        api_logger.debug(f"Check whether the mcp market exists: {mcp_market_id}")
-        db_mcp_market = mcp_market_service.get_mcp_market_by_id(db, mcp_market_id=mcp_market_id, current_user=current_user)
-
-        if not db_mcp_market:
-            api_logger.warning(
-                f"The mcp market does not exist or you do not have permission to access it: mcp_market_id={mcp_market_id}")
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="The mcp market does not exist or you do not have permission to access it"
-            )
-
-        # 2. Deleting mcp market
-        mcp_market_service.delete_mcp_market_by_id(db, mcp_market_id=mcp_market_id, current_user=current_user)
-        api_logger.info(f"The mcp market has been successfully deleted: (ID: {mcp_market_id})")
-        return success(msg="The mcp market has been successfully deleted")
-    except Exception as e:
-        api_logger.error(f"Failed to delete from the mcp market: mcp_market_id={mcp_market_id} - {str(e)}")
-        raise

api/app/controllers/memory_agent_controller.py

@@ -2,7 +2,6 @@ from typing import List, Optional
 
 from app.celery_app import celery_app
 from app.core.error_codes import BizCode
-from app.core.language_utils import get_language_from_header
 from app.core.logging_config import get_api_logger
 from app.core.rag.llm.cv_model import QWenCV
 from app.core.response_utils import fail, success
@@ -119,7 +118,6 @@ async def download_log(
 @cur_workspace_access_guard()
 async def write_server(
     user_input: Write_UserInput,
-    language_type: str = Header(default=None, alias="X-Language-Type"),
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user)
 ):
@@ -128,17 +126,13 @@ async def write_server(
     
     Args:
         user_input: Write request containing message and end_user_id
-        language_type: 语言类型 ("zh" 中文, "en" 英文)，通过 X-Language-Type Header 传递
     
     Returns:
         Response with write operation status
     """
-    # 使用集中化的语言校验
-    language = get_language_from_header(language_type)
-    
     config_id = user_input.config_id
     workspace_id = current_user.current_workspace_id
-    api_logger.info(f"Write service: workspace_id={workspace_id}, config_id={config_id}, language_type={language}")
+    api_logger.info(f"Write service: workspace_id={workspace_id}, config_id={config_id}")
     
     # 获取 storage_type，如果为 None 则使用默认值
     storage_type = workspace_service.get_workspace_storage_type(
@@ -175,8 +169,7 @@ async def write_server(
             config_id,
             db,
             storage_type, 
-            user_rag_memory_id,
-            language
+            user_rag_memory_id
         )
 
         return success(data=result, msg="写入成功")
@@ -195,7 +188,6 @@ async def write_server(
 @cur_workspace_access_guard()
 async def write_server_async(
     user_input: Write_UserInput,
-    language_type: str = Header(default=None, alias="X-Language-Type"),
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user)
 ):
@@ -204,18 +196,14 @@ async def write_server_async(
     
     Args:
         user_input: Write request containing message and end_user_id
-        language_type: 语言类型 ("zh" 中文, "en" 英文)，通过 X-Language-Type Header 传递
     
     Returns:
         Task ID for tracking async operation
         Use GET /memory/write_result/{task_id} to check task status and get result
     """
-    # 使用集中化的语言校验
-    language = get_language_from_header(language_type)
-    
     config_id = user_input.config_id
     workspace_id = current_user.current_workspace_id
-    api_logger.info(f"Async write service: workspace_id={workspace_id}, config_id={config_id}, language_type={language}")
+    api_logger.info(f"Async write service: workspace_id={workspace_id}, config_id={config_id}")
 
     # 获取 storage_type，如果为 None 则使用默认值
     storage_type = workspace_service.get_workspace_storage_type(
@@ -240,7 +228,7 @@ async def write_server_async(
 
         task = celery_app.send_task(
             "app.core.memory.agent.write_message",
-            args=[user_input.end_user_id, messages_list, config_id, storage_type, user_rag_memory_id, language]
+            args=[user_input.end_user_id, messages_list, config_id, storage_type, user_rag_memory_id]
         )
         api_logger.info(f"Write task queued: {task.id}")
         
@@ -633,11 +621,12 @@ async def get_knowledge_type_stats_api(
     current_user: User = Depends(get_current_user)
 ):
     """
-    统计当前空间下各知识库类型的数量，包含 General | Web | Third-party | Folder。
+    统计当前空间下各知识库类型的数量，包含 General | Web | Third-party | Folder | memory。
     会对缺失类型补 0，返回字典形式。
     可选按状态过滤。
     - 知识库类型根据当前用户的 current_workspace_id 过滤
-    - 如果用户没有当前工作空间，对应的统计返回 0
+    - memory 是 Neo4j 中 Chunk 的数量，根据 end_user_id (end_user_id) 过滤
+    - 如果用户没有当前工作空间或未提供 end_user_id，对应的统计返回 0
     """
     api_logger.info(f"Knowledge type stats requested for workspace_id: {current_user.current_workspace_id}, end_user_id: {end_user_id}")
     try:
@@ -664,6 +653,7 @@ async def get_knowledge_type_stats_api(
 @router.get("/analytics/hot_memory_tags/by_user", response_model=ApiResponse)
 async def get_hot_memory_tags_by_user_api(
     end_user_id: Optional[str] = Query(None, description="用户ID（可选）"),
+    language_type: str = Header(default="zh", alias="X-Language-Type"),
     limit: int = Query(20, description="返回标签数量限制"),
     current_user: User = Depends(get_current_user),
     db: Session=Depends(get_db),
@@ -671,18 +661,28 @@ async def get_hot_memory_tags_by_user_api(
     """
     获取指定用户的热门记忆标签
     
-    注意：标签语言由写入时的 X-Language-Type 决定，查询时不进行翻译
-    
     返回格式：
     [
         {"name": "标签名", "frequency": 频次},
         ...
     ]
     """
+
+    workspace_id=current_user.current_workspace_id
+    workspace_repo = WorkspaceRepository(db)
+    workspace_models = workspace_repo.get_workspace_models_configs(workspace_id)
+
+    if workspace_models:
+        model_id = workspace_models.get("llm", None)
+    else:
+        model_id = None
+
     api_logger.info(f"Hot memory tags by user requested: end_user_id={end_user_id}")
     try:
         result = await memory_agent_service.get_hot_memory_tags_by_user(
             end_user_id=end_user_id,
+            language_type=language_type,
+            model_id=model_id,
             limit=limit
         )
         return success(data=result, msg="获取热门记忆标签成功")

api/app/controllers/memory_dashboard_controller.py

@@ -9,7 +9,6 @@ from app.schemas.response_schema import ApiResponse
 
 from app.services import memory_dashboard_service, memory_storage_service, workspace_service
 from app.services.memory_agent_service import get_end_users_connected_configs_batch
-from app.services.app_statistics_service import AppStatisticsService
 from app.core.logging_config import get_api_logger
 
 # 获取API专用日志器
@@ -470,8 +469,6 @@ async def get_chunk_insight(
 @router.get("/dashboard_data", response_model=ApiResponse)
 async def dashboard_data(
     end_user_id: Optional[str] = Query(None, description="可选的用户ID"),
-    start_date: Optional[int] = Query(None, description="开始时间戳（毫秒）"),
-    end_date: Optional[int] = Query(None, description="结束时间戳（毫秒）"),
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
 ):
@@ -506,15 +503,6 @@ async def dashboard_data(
     workspace_id = current_user.current_workspace_id
     api_logger.info(f"用户 {current_user.username} 请求获取工作空间 {workspace_id} 的dashboard整合数据")
     
-    # 如果没有提供时间范围，默认使用最近30天
-    if start_date is None or end_date is None:
-        from datetime import datetime, timedelta
-        end_dt = datetime.now()
-        start_dt = end_dt - timedelta(days=30)
-        end_date = int(end_dt.timestamp() * 1000)
-        start_date = int(start_dt.timestamp() * 1000)
-        api_logger.info(f"使用默认时间范围: {start_dt} 到 {end_dt}")
-    
     # 获取 storage_type，如果为 None 则使用默认值
     storage_type = workspace_service.get_workspace_storage_type(
         db=db,
@@ -575,22 +563,17 @@ async def dashboard_data(
             except Exception as e:
                 api_logger.warning(f"获取知识库类型统计失败: {str(e)}")
             
-            # 3. 获取API调用统计（total_api_call）
+            # 3. 获取API调用增量（total_api_call，转换为整数）
             try:
-                # 使用 AppStatisticsService 获取真实的API调用统计
-                app_stats_service = AppStatisticsService(db)
-                api_stats = app_stats_service.get_workspace_api_statistics(
+                api_increment = memory_dashboard_service.get_workspace_api_increment(
+                    db=db,
                     workspace_id=workspace_id,
-                    start_date=start_date,
-                    end_date=end_date
+                    current_user=current_user
                 )
-                # 计算总调用次数
-                total_api_calls = sum(item.get("total_calls", 0) for item in api_stats)
-                neo4j_data["total_api_call"] = total_api_calls
-                api_logger.info(f"成功获取API调用统计: {neo4j_data['total_api_call']}")
+                neo4j_data["total_api_call"] = api_increment
+                api_logger.info(f"成功获取API调用增量: {neo4j_data['total_api_call']}")
             except Exception as e:
-                api_logger.error(f"获取API调用统计失败: {str(e)}")
-                neo4j_data["total_api_call"] = 0
+                api_logger.warning(f"获取API调用增量失败: {str(e)}")
             
             result["neo4j_data"] = neo4j_data
             api_logger.info("成功获取neo4j_data")
@@ -619,23 +602,10 @@ async def dashboard_data(
                 total_kb = memory_dashboard_service.get_rag_total_kb(db, current_user)
                 rag_data["total_knowledge"] = total_kb
                 
-                # total_api_call: 使用 AppStatisticsService 获取真实的API调用统计
-                try:
-                    app_stats_service = AppStatisticsService(db)
-                    api_stats = app_stats_service.get_workspace_api_statistics(
-                        workspace_id=workspace_id,
-                        start_date=start_date,
-                        end_date=end_date
-                    )
-                    # 计算总调用次数
-                    total_api_calls = sum(item.get("total_calls", 0) for item in api_stats)
-                    rag_data["total_api_call"] = total_api_calls
-                    api_logger.info(f"成功获取RAG模式API调用统计: {rag_data['total_api_call']}")
-                except Exception as e:
-                    api_logger.warning(f"获取RAG模式API调用统计失败，使用默认值: {str(e)}")
-                    rag_data["total_api_call"] = 0
+                # total_api_call: 固定值
+                rag_data["total_api_call"] = 1024
                 
-                api_logger.info(f"成功获取RAG相关数据: memory={total_chunk}, app={len(apps_orm)}, knowledge={total_kb}, api_calls={rag_data['total_api_call']}")
+                api_logger.info(f"成功获取RAG相关数据: memory={total_chunk}, app={len(apps_orm)}, knowledge={total_kb}")
             except Exception as e:
                 api_logger.warning(f"获取RAG相关数据失败: {str(e)}")
             

api/app/controllers/memory_episodic_controller.py

@@ -3,10 +3,9 @@
 包含情景记忆总览和详情查询接口
 """
 
-from fastapi import APIRouter, Depends, Header
+from fastapi import APIRouter, Depends
 
 from app.core.error_codes import BizCode
-from app.core.language_utils import get_language_from_header
 from app.core.logging_config import get_api_logger
 from app.core.response_utils import fail, success
 from app.dependencies import get_current_user
@@ -15,7 +14,6 @@ from app.schemas.response_schema import ApiResponse
 from app.schemas.memory_episodic_schema import (
     EpisodicMemoryOverviewRequest,
     EpisodicMemoryDetailsRequest,
-    translate_episodic_type,
 )
 from app.services.memory_episodic_service import memory_episodic_service
 
@@ -86,7 +84,6 @@ async def get_episodic_memory_overview_api(
 @router.post("/details", response_model=ApiResponse)
 async def get_episodic_memory_details_api(
     request: EpisodicMemoryDetailsRequest,
-    language_type: str = Header(default=None, alias="X-Language-Type"),
     current_user: User = Depends(get_current_user),
 ) -> dict:
     """
@@ -114,11 +111,6 @@ async def get_episodic_memory_details_api(
             summary_id=request.summary_id
         )
         
-        # 根据语言参数翻译 episodic_type
-        language = get_language_from_header(language_type)
-        if "episodic_type" in result:
-            result["episodic_type"] = translate_episodic_type(result["episodic_type"], language)
-        
         api_logger.info(
             f"成功获取情景记忆详情: end_user_id={request.end_user_id}, summary_id={request.summary_id}"
         )

api/app/controllers/memory_reflection_controller.py

@@ -3,7 +3,6 @@ import time
 import uuid
 from uuid import UUID
 
-from app.core.language_utils import get_language_from_header
 from app.core.logging_config import get_api_logger
 from app.core.memory.storage_services.reflection_engine.self_reflexion import (
     ReflectionConfig,
@@ -104,18 +103,14 @@ async def start_workspace_reflection(
 ) -> dict:
     """启动工作空间中所有匹配应用的反思功能"""
     workspace_id = current_user.current_workspace_id
+    reflection_service = MemoryReflectionService(db)
 
     try:
         api_logger.info(f"用户 {current_user.username} 启动workspace反思，workspace_id: {workspace_id}")
 
-        # 使用独立的数据库会话来获取工作空间应用详情，避免事务失败
-        from app.db import get_db_context
-        with get_db_context() as query_db:
-            service = WorkspaceAppService(query_db)
-            result = service.get_workspace_apps_detailed(workspace_id)
-        
+        service = WorkspaceAppService(db)
+        result = service.get_workspace_apps_detailed(workspace_id)
         reflection_results = []
-        
         for data in result['apps_detailed_info']:
             # 跳过没有配置的应用
             if not data['memory_configs']:
@@ -137,36 +132,33 @@ async def start_workspace_reflection(
                     api_logger.debug(f"配置 {config_id_str} 没有匹配的release")
                     continue
 
-                # 为每个用户执行反思 - 使用独立的数据库会话
+                # 为每个用户执行反思
                 for user in end_users:
                     api_logger.info(f"为用户 {user['id']} 启动反思，config_id: {config_id_str}")
 
-                    # 为每个用户创建独立的数据库会话，避免事务失败影响其他用户
-                    with get_db_context() as user_db:
-                        try:
-                            reflection_service = MemoryReflectionService(user_db)
-                            reflection_result = await reflection_service.start_text_reflection(
-                                config_data=config,
-                                end_user_id=user['id']
-                            )
+                    try:
+                        reflection_result = await reflection_service.start_text_reflection(
+                            config_data=config,
+                            end_user_id=user['id']
+                        )
 
-                            reflection_results.append({
-                                "app_id": data['id'],
-                                "config_id": config_id_str,
-                                "end_user_id": user['id'],
-                                "reflection_result": reflection_result
-                            })
-                        except Exception as e:
-                            api_logger.error(f"用户 {user['id']} 反思失败: {str(e)}")
-                            reflection_results.append({
-                                "app_id": data['id'],
-                                "config_id": config_id_str,
-                                "end_user_id": user['id'],
-                                "reflection_result": {
-                                    "status": "错误",
-                                    "message": f"反思失败: {str(e)}"
-                                }
-                            })
+                        reflection_results.append({
+                            "app_id": data['id'],
+                            "config_id": config_id_str,
+                            "end_user_id": user['id'],
+                            "reflection_result": reflection_result
+                        })
+                    except Exception as e:
+                        api_logger.error(f"用户 {user['id']} 反思失败: {str(e)}")
+                        reflection_results.append({
+                            "app_id": data['id'],
+                            "config_id": config_id_str,
+                            "end_user_id": user['id'],
+                            "reflection_result": {
+                                "status": "错误",
+                                "message": f"反思失败: {str(e)}"
+                            }
+                        })
 
         return success(data=reflection_results, msg="反思配置成功")
 
@@ -219,13 +211,11 @@ async def start_reflection_configs(
 @router.get("/reflection/run")
 async def reflection_run(
     config_id: UUID|int,
-    language_type: str = Header(default=None, alias="X-Language-Type"),
+    language_type: str = Header(default="zh", alias="X-Language-Type"),
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
 ) -> dict:
     """Activate the reflection function for all matching applications in the workspace"""
-    # 使用集中化的语言校验
-    language = get_language_from_header(language_type)
 
     api_logger.info(f"用户 {current_user.username} 查询反思配置，config_id: {config_id}")
     config_id = resolve_config_id(config_id, db)

api/app/controllers/memory_short_term_controller.py

@@ -1,5 +1,4 @@
 from fastapi import APIRouter, Depends, HTTPException, status,Header
-from app.core.language_utils import get_language_from_header
 from app.core.logging_config import get_api_logger
 from app.core.response_utils import success
 from app.db import get_db
@@ -21,13 +20,10 @@ router = APIRouter(
 @router.get("/short_term")
 async def short_term_configs(
         end_user_id: str,
-        language_type:str = Header(default=None, alias="X-Language-Type"),
+        language_type:str = Header(default="zh", alias="X-Language-Type"),
         current_user: User = Depends(get_current_user),
         db: Session = Depends(get_db),
 ):
-    # 使用集中化的语言校验
-    language = get_language_from_header(language_type)
-    
     # 获取短期记忆数据
     short_term=ShortService(end_user_id)
     short_result=short_term.get_short_databasets()

api/app/controllers/memory_storage_controller.py

@@ -1,12 +1,8 @@
+import os
 from typing import Optional
 from uuid import UUID
 
-from fastapi import APIRouter, Depends, Query
-from fastapi.responses import StreamingResponse
-from sqlalchemy.orm import Session
-
 from app.core.error_codes import BizCode
-from app.core.language_utils import get_language_from_header
 from app.core.logging_config import get_api_logger
 from app.core.response_utils import fail, success
 from app.db import get_db
@@ -15,6 +11,7 @@ from app.models.user_model import User
 from app.schemas.memory_storage_schema import (
     ConfigKey,
     ConfigParamsCreate,
+    ConfigParamsDelete,
     ConfigPilotRun,
     ConfigUpdate,
     ConfigUpdateExtracted,
@@ -34,7 +31,7 @@ from app.services.memory_storage_service import (
     search_entity,
     search_statement,
 )
-from fastapi import APIRouter, Depends, Header
+from fastapi import APIRouter, Depends
 from fastapi.responses import StreamingResponse
 from sqlalchemy.orm import Session
 
@@ -75,9 +72,68 @@ async def get_storage_info(
         return fail(BizCode.INTERNAL_ERROR, "存储信息获取失败", str(e))
 
 
+# --- DB connection dependency ---
+_CONN: Optional[object] = None
 
 
+"""PostgreSQL 连接生成与管理（使用 psycopg2）。"""
+# 这个可以转移，可能是已经有的
+# PostgreSQL 数据库连接
+def _make_pgsql_conn() -> Optional[object]:  # 创建 PostgreSQL 数据库连接
+    host = os.getenv("DB_HOST")
+    user = os.getenv("DB_USER")
+    password = os.getenv("DB_PASSWORD")
+    database = os.getenv("DB_NAME")
+    port_str = os.getenv("DB_PORT")
+    try:
+        import psycopg2  # type: ignore
+        port = int(port_str) if port_str else 5432
+        conn = psycopg2.connect(
+            host=host or "localhost",
+            port=port,
+            user=user,
+            password=password,
+            dbname=database,
+        )
+        # 设置自动提交，避免显式事务管理
+        conn.autocommit = True
+        # 设置会话时区为中国标准时间（Asia/Shanghai），便于直接以本地时区展示
+        try:
+            cur = conn.cursor()
+            cur.execute("SET TIME ZONE 'Asia/Shanghai'")
+            cur.close()
+        except Exception:
+            # 时区设置失败不影响连接，仅记录但不抛出
+            pass
+        return conn
+    except Exception as e:
+        try:
+            print(f"[PostgreSQL] 连接失败: {e}")
+        except Exception:
+            pass
+        return None
 
+def get_db_conn() -> Optional[object]:  # 获取 PostgreSQL 数据库连接
+    global _CONN
+    if _CONN is None:
+        _CONN = _make_pgsql_conn()
+    return _CONN
+
+
+def reset_db_conn() -> bool:  # 重置 PostgreSQL 数据库连接
+    """Close and recreate the global DB connection."""
+    global _CONN
+    try:
+        if _CONN:
+            try:
+                _CONN.close()
+            except Exception:
+                pass
+        _CONN = _make_pgsql_conn()
+        return _CONN is not None
+    except Exception:
+        _CONN = None
+        return False
 
 
 @router.post("/create_config", response_model=ApiResponse)   # 创建配置文件，其他参数默认
@@ -85,7 +141,7 @@ def create_config(
     payload: ConfigParamsCreate,
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
-) -> dict:
+    ) -> dict:
     workspace_id = current_user.current_workspace_id
     # 检查用户是否已选择工作空间
     if workspace_id is None:
@@ -107,20 +163,9 @@ def create_config(
 @router.delete("/delete_config", response_model=ApiResponse)  # 删除数据库中的内容（按配置名称）
 def delete_config(
     config_id: UUID|int,
-    force: bool = Query(False, description="是否强制删除（即使有终端用户正在使用）"),
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
-) -> dict:
-    """删除记忆配置（带终端用户保护）
-    
-    - 检查是否为默认配置，默认配置不允许删除
-    - 检查是否有终端用户连接到该配置
-    - 如果有连接且 force=False，返回警告
-    - 如果 force=True，清除终端用户引用后删除配置
-    
-    Query Parameters:
-        force: 设置为 true 可强制删除（即使有终端用户正在使用）
-    """
+    ) -> dict:
     workspace_id = current_user.current_workspace_id
     config_id=resolve_config_id(config_id, db)
     # 检查用户是否已选择工作空间
@@ -128,62 +173,21 @@ def delete_config(
         api_logger.warning(f"用户 {current_user.username} 尝试删除配置但未选择工作空间")
         return fail(BizCode.INVALID_PARAMETER, "请先切换到一个工作空间", "current_workspace_id is None")
     
-    api_logger.info(
-        f"用户 {current_user.username} 在工作空间 {workspace_id} 请求删除配置: "
-        f"config_id={config_id}, force={force}"
-    )
-    
+    api_logger.info(f"用户 {current_user.username} 在工作空间 {workspace_id} 请求删除配置: {config_id}")
     try:
-        # 使用带保护的删除服务
-        from app.services.memory_config_service import MemoryConfigService
-        
-        config_service = MemoryConfigService(db)
-        result = config_service.delete_config(config_id=config_id, force=force)
-        
-        if result["status"] == "error":
-            api_logger.warning(
-                f"记忆配置删除被拒绝: config_id={config_id}, reason={result['message']}"
-            )
-            return fail(
-                code=BizCode.FORBIDDEN,
-                msg=result["message"],
-                data={"config_id": str(config_id), "is_default": result.get("is_default", False)}
-            )
-        
-        if result["status"] == "warning":
-            api_logger.warning(
-                f"记忆配置正在使用，无法删除: config_id={config_id}, "
-                f"connected_count={result['connected_count']}"
-            )
-            return fail(
-                code=BizCode.RESOURCE_IN_USE,
-                msg=result["message"],
-                data={
-                    "connected_count": result["connected_count"],
-                    "force_required": result["force_required"]
-                }
-            )
-        
-        api_logger.info(
-            f"记忆配置删除成功: config_id={config_id}, "
-            f"affected_users={result['affected_users']}"
-        )
-        return success(
-            msg=result["message"],
-            data={"affected_users": result["affected_users"]}
-        )
-        
+        svc = DataConfigService(db)
+        result = svc.delete(ConfigParamsDelete(config_id=config_id))
+        return success(data=result, msg="删除成功")
     except Exception as e:
-        api_logger.error(f"Delete config failed: {str(e)}", exc_info=True)
+        api_logger.error(f"Delete config failed: {str(e)}")
         return fail(BizCode.INTERNAL_ERROR, "删除配置失败", str(e))
 
-
 @router.post("/update_config", response_model=ApiResponse)  # 更新配置文件中name和desc
 def update_config(
     payload: ConfigUpdate,
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
-) -> dict:
+    ) -> dict:
     workspace_id = current_user.current_workspace_id
     payload.config_id = resolve_config_id(payload.config_id, db)
     # 检查用户是否已选择工作空间
@@ -211,7 +215,7 @@ def update_config_extracted(
     payload: ConfigUpdateExtracted,
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
-) -> dict:
+    ) -> dict:
     workspace_id = current_user.current_workspace_id
     payload.config_id = resolve_config_id(payload.config_id, db)
     # 检查用户是否已选择工作空间
@@ -238,7 +242,7 @@ def read_config_extracted(
     config_id: UUID | int,
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
-) -> dict:
+    ) -> dict:
     workspace_id = current_user.current_workspace_id
     config_id = resolve_config_id(config_id, db)
     # 检查用户是否已选择工作空间
@@ -259,7 +263,7 @@ def read_config_extracted(
 def read_all_config(
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
-) -> dict:
+    ) -> dict:
     workspace_id = current_user.current_workspace_id
     
     # 检查用户是否已选择工作空间
@@ -281,22 +285,17 @@ def read_all_config(
 @router.post("/pilot_run", response_model=None)
 async def pilot_run(
     payload: ConfigPilotRun,
-    language_type: str = Header(default=None, alias="X-Language-Type"),
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
 ) -> StreamingResponse:
-    # 使用集中化的语言校验
-    language = get_language_from_header(language_type)
-    
     api_logger.info(
         f"Pilot run requested: config_id={payload.config_id}, "
-        f"dialogue_text_length={len(payload.dialogue_text)}, "
-        f"custom_text_length={len(payload.custom_text) if payload.custom_text else 0}"
+        f"dialogue_text_length={len(payload.dialogue_text)}"
     )
     payload.config_id = resolve_config_id(payload.config_id, db)
     svc = DataConfigService(db)
     return StreamingResponse(
-        svc.pilot_run_stream(payload, language=language),
+        svc.pilot_run_stream(payload),
         media_type="text/event-stream",
         headers={
             "Cache-Control": "no-cache",
@@ -305,8 +304,9 @@ async def pilot_run(
         },
     )
 
-
-# ==================== Search & Analytics ====================
+"""
+以下为搜索与分析接口，直接挂载到同一 router，统一响应为 ApiResponse。
+"""
 
 @router.get("/search/kb_type_distribution", response_model=ApiResponse)
 async def get_kb_type_distribution(
@@ -446,9 +446,8 @@ async def get_hot_memory_tags_api(
     
     try:
         # 尝试从Redis缓存获取
-        import json
-
         from app.aioRedis import aio_redis_get, aio_redis_set
+        import json
         
         cached_result = await aio_redis_get(cache_key)
         if cached_result:

api/app/controllers/model_controller.py

@@ -328,7 +328,7 @@ async def update_composite_model(
     
     try:
         if model_data.type is not None:
-            raise BusinessException("不允许更改模型类型", BizCode.INVALID_PARAMETER)
+            raise BusinessException("不允许更改模型类型和供应商", BizCode.INVALID_PARAMETER)
         result_orm = await ModelConfigService.update_composite_model(db=db, model_id=model_id, model_data=model_data, tenant_id=current_user.tenant_id)
         api_logger.info(f"组合模型更新成功: {result_orm.name} (ID: {model_id})")
         
@@ -368,9 +368,6 @@ def update_model(
     更新模型配置
     """
     api_logger.info(f"更新模型配置请求: model_id={model_id}, 用户: {current_user.username}, tenant_id={current_user.tenant_id}")
-
-    if model_data.type is not None or model_data.provider is not None:
-        raise BusinessException("不允许更改模型类型和供应商", BizCode.INVALID_PARAMETER)
     
     try:
         api_logger.debug(f"开始更新模型配置: model_id={model_id}")

api/app/controllers/ontology_controller.py

@@ -4,14 +4,13 @@
 
 Endpoints:
     POST /api/memory/ontology/extract - 提取本体类
-    POST /api/memory/ontology/export - 按场景导出OWL文件
-    POST /api/memory/ontology/import - 导入OWL文件到指定场景
+    POST /api/memory/ontology/export - 导出OWL文件
     POST /api/memory/ontology/scene - 创建本体场景
     PUT /api/memory/ontology/scene/{scene_id} - 更新本体场景
     DELETE /api/memory/ontology/scene/{scene_id} - 删除本体场景
     GET /api/memory/ontology/scene/{scene_id} - 获取单个场景
     GET /api/memory/ontology/scenes - 获取场景列表
-    POST /api/memory/ontology/class - 创建本体类型（支持批量）
+    POST /api/memory/ontology/class - 创建本体类型
     PUT /api/memory/ontology/class/{class_id} - 更新本体类型
     DELETE /api/memory/ontology/class/{class_id} - 删除本体类型
     GET /api/memory/ontology/class/{class_id} - 获取单个类型
@@ -20,26 +19,23 @@ Endpoints:
 
 import logging
 import tempfile
-import io
-from typing import Dict, Optional, List
-from urllib.parse import quote
+from typing import Dict, Optional
 
-from fastapi import APIRouter, Depends, HTTPException, File, UploadFile, Form, Header
-from fastapi.responses import StreamingResponse
+from fastapi import APIRouter, Depends, HTTPException, Header
 from sqlalchemy.orm import Session
 
-from app.core.config import settings
 from app.core.error_codes import BizCode
-from app.core.language_utils import get_language_from_header
 from app.core.logging_config import get_api_logger
 from app.core.response_utils import fail, success
 from app.db import get_db
 from app.dependencies import get_current_user
 from app.models.user_model import User
-from app.core.memory.models.ontology_scenario_models import OntologyClass
+from app.services.memory_base_service import Translation_English
+from app.core.memory.models.ontology_models import OntologyClass
+from typing import List
 from app.schemas.ontology_schemas import (
-    ExportBySceneRequest,
-    ExportBySceneResponse,
+    ExportRequest,
+    ExportResponse,
     ExtractionRequest,
     ExtractionResponse,
     SceneCreateRequest,
@@ -50,7 +46,6 @@ from app.schemas.ontology_schemas import (
     ClassUpdateRequest,
     ClassResponse,
     ClassListResponse,
-    ImportOwlResponse,
 )
 from app.schemas.response_schema import ApiResponse
 from app.services.ontology_service import OntologyService
@@ -69,6 +64,72 @@ router = APIRouter(
 )
 
 
+async def translate_ontology_classes(
+    classes: List[OntologyClass], 
+    model_id: str
+) -> List[OntologyClass]:
+    """翻译本体类列表
+    
+    将本体类的中文字段翻译为英文，包括：
+    - name_chinese: 中文名称
+    - description: 描述
+    - examples: 示例列表
+    
+    Args:
+        classes: 本体类列表
+        model_id: LLM模型ID，用于翻译
+        
+    Returns:
+        List[OntologyClass]: 翻译后的本体类列表
+    """
+    translated_classes = []
+    
+    for ontology_class in classes:
+        # 创建类的副本，避免修改原对象
+        translated_class = ontology_class.model_copy(deep=True)
+        
+        # 翻译 name_chinese 字段
+        if translated_class.name_chinese:
+            try:
+                translated_class.name_chinese = await Translation_English(
+                    model_id, 
+                    translated_class.name_chinese
+                )
+            except Exception as e:
+                logger.warning(f"Failed to translate name_chinese: {e}")
+                # 保留原文
+        
+        # 翻译 description 字段
+        if translated_class.description:
+            try:
+                translated_class.description = await Translation_English(
+                    model_id, 
+                    translated_class.description
+                )
+            except Exception as e:
+                logger.warning(f"Failed to translate description: {e}")
+                # 保留原文
+        
+        # 翻译 examples 列表
+        if translated_class.examples:
+            translated_examples = []
+            for example in translated_class.examples:
+                try:
+                    translated_example = await Translation_English(
+                        model_id, 
+                        example
+                    )
+                    translated_examples.append(translated_example)
+                except Exception as e:
+                    logger.warning(f"Failed to translate example: {e}")
+                    translated_examples.append(example)  # 保留原文
+            translated_class.examples = translated_examples
+        
+        translated_classes.append(translated_class)
+    
+    return translated_classes
+
+
 def _get_ontology_service(
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
@@ -183,7 +244,7 @@ def _get_ontology_service(
 @router.post("/extract", response_model=ApiResponse)
 async def extract_ontology(
     request: ExtractionRequest,
-    language_type: str = Header(default=None, alias="X-Language-Type"),
+    language_type: str = Header(default="zh", alias="X-Language-Type"),
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user)
 ):
@@ -192,25 +253,50 @@ async def extract_ontology(
     从场景描述中提取符合OWL规范的本体类。
     提取结果仅返回给前端，不会自动保存到数据库。
     前端可以从返回结果中选择需要的类型，然后调用 /class 接口创建类型。
+    支持中英文切换，通过 X-Language-Type Header 指定语言。
     
     Args:
         request: 提取请求,包含scenario、domain、llm_id和scene_id
-        language_type: 语言类型 Header (zh/en)
+        language_type: 语言类型，'zh'（中文）或 'en'（英文），默认 'zh'
         db: 数据库会话
         current_user: 当前用户
+        
+    Returns:
+        ApiResponse: 包含提取结果的响应
+        
+    Response format:
+        {
+            "code": 200,
+            "msg": "本体提取成功",
+            "data": {
+                "classes": [
+                    {
+                        "id": "147d9db50b524a9e909e01a753d3acdd",
+                        "name": "Patient",
+                        "name_chinese": "患者",
+                        "description": "在医疗机构中接受诊疗、护理或健康管理的个体",
+                        "examples": ["糖尿病患者", "术后康复患者", "门诊初诊患者"],
+                        "parent_class": null,
+                        "entity_type": "Person",
+                        "domain": "Healthcare"
+                    },
+                    ...
+                ],
+                "domain": "Healthcare",
+                "extracted_count": 7
+            }
+        }
     """
     api_logger.info(
         f"Ontology extraction requested by user {current_user.id}, "
         f"scenario_length={len(request.scenario)}, "
         f"domain={request.domain}, "
         f"llm_id={request.llm_id}, "
-        f"scene_id={request.scene_id}"
+        f"scene_id={request.scene_id}, "
+        f"language_type={language_type}"
     )
     
     try:
-        # 使用集中化的语言校验
-        language = get_language_from_header(language_type)
-        
         # 获取当前工作空间ID
         workspace_id = current_user.current_workspace_id
         if not workspace_id:
@@ -224,22 +310,36 @@ async def extract_ontology(
             llm_id=request.llm_id
         )
         
-        # 调用服务层执行提取
+        # 调用服务层执行提取，传入scene_id和workspace_id
         result = await service.extract_ontology(
             scenario=request.scenario,
             domain=request.domain,
             scene_id=request.scene_id,
-            workspace_id=workspace_id,
-            language=language
+            workspace_id=workspace_id
         )
         
-        # 根据语言类型统一 name 字段
-        # zh: name 使用 name_chinese（中文名）
-        # en: name 保持原值（英文 PascalCase）
-        if language == "zh":
-            for cls in result.classes:
-                if cls.name_chinese:
-                    cls.name = cls.name_chinese
+        # ===== 新增：翻译逻辑 =====
+        # 如果需要英文，则翻译数据
+        if language_type != 'zh':
+            api_logger.info(f"Translating extraction result to English")
+            
+            # 翻译 classes 列表
+            result.classes = await translate_ontology_classes(
+                result.classes, 
+                request.llm_id
+            )
+            
+            # 翻译 domain 字段
+            if result.domain:
+                try:
+                    result.domain = await Translation_English(
+                        request.llm_id, 
+                        result.domain
+                    )
+                except Exception as e:
+                    logger.warning(f"Failed to translate domain: {e}")
+                    # 保留原文
+        # ===== 翻译逻辑结束 =====
         
         # 构建响应
         response = ExtractionResponse(
@@ -250,7 +350,7 @@ async def extract_ontology(
         
         api_logger.info(
             f"Ontology extraction completed, extracted {len(result.classes)} classes, "
-            f"scene_id={request.scene_id}, language={language}"
+            f"saved to scene {request.scene_id}, language={language_type}"
         )
         
         return success(data=response.model_dump(), msg="本体提取成功")
@@ -271,6 +371,146 @@ async def extract_ontology(
         return fail(BizCode.INTERNAL_ERROR, "本体提取失败", str(e))
 
 
+@router.post("/export", response_model=ApiResponse)
+async def export_owl(
+    request: ExportRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """导出OWL文件
+    
+    将提取的本体类导出为OWL文件,支持多种格式。
+    导出操作不需要LLM,只使用OWL验证器和Owlready2库。
+    
+    Args:
+        request: 导出请求,包含classes、format和include_metadata
+        db: 数据库会话
+        current_user: 当前用户
+        
+    Returns:
+        ApiResponse: 包含OWL文件内容的响应
+        
+    Supported formats:
+        - rdfxml: 标准OWL RDF/XML格式(完整)
+        - turtle: Turtle格式(可读性好)
+        - ntriples: N-Triples格式(简单)
+        - json: JSON格式(简化,只包含类信息)
+        
+    Response format:
+        {
+            "code": 200,
+            "msg": "OWL文件导出成功",
+            "data": {
+                "owl_content": "...",
+                "format": "rdfxml",
+                "classes_count": 7
+            }
+        }
+    """
+    api_logger.info(
+        f"OWL export requested by user {current_user.id}, "
+        f"classes_count={len(request.classes)}, "
+        f"format={request.format}, "
+        f"include_metadata={request.include_metadata}"
+    )
+    
+    try:
+        # 验证格式
+        valid_formats = ["rdfxml", "turtle", "ntriples", "json"]
+        if request.format not in valid_formats:
+            api_logger.warning(f"Invalid export format: {request.format}")
+            return fail(
+                BizCode.BAD_REQUEST,
+                "不支持的导出格式",
+                f"format必须是以下之一: {', '.join(valid_formats)}"
+            )
+        
+        # JSON格式直接导出,不需要OWL验证
+        if request.format == "json":
+            owl_validator = OWLValidator()
+            owl_content = owl_validator.export_to_owl(
+                world=None,
+                format="json",
+                classes=request.classes
+            )
+            
+            response = ExportResponse(
+                owl_content=owl_content,
+                format=request.format,
+                classes_count=len(request.classes)
+            )
+            
+            api_logger.info(
+                f"JSON export completed, content_length={len(owl_content)}"
+            )
+            
+            return success(data=response.model_dump(), msg="OWL文件导出成功")
+        
+        # 创建临时文件路径
+        with tempfile.NamedTemporaryFile(
+            mode='w',
+            suffix='.owl',
+            delete=False
+        ) as tmp_file:
+            output_path = tmp_file.name
+        
+        # 导出操作不需要LLM,直接使用OWL验证器
+        owl_validator = OWLValidator()
+        
+        # 验证本体类
+        logger.debug("Validating ontology classes")
+        is_valid, errors, world = owl_validator.validate_ontology_classes(
+            classes=request.classes,
+        )
+        
+        if not is_valid:
+            logger.warning(
+                f"OWL validation found {len(errors)} issues during export: {errors}"
+            )
+            # 继续导出,但记录警告
+        
+        if not world:
+            error_msg = "Failed to create OWL world for export"
+            logger.error(error_msg)
+            return fail(BizCode.INTERNAL_ERROR, "创建OWL世界失败", error_msg)
+        
+        # 导出OWL文件
+        logger.info(f"Exporting to {request.format} format")
+        owl_content = owl_validator.export_to_owl(
+            world=world,
+            output_path=output_path,
+            format=request.format,
+            classes=request.classes
+        )
+        
+        # 构建响应
+        response = ExportResponse(
+            owl_content=owl_content,
+            format=request.format,
+            classes_count=len(request.classes)
+        )
+        
+        api_logger.info(
+            f"OWL export completed, format={request.format}, "
+            f"content_length={len(owl_content)}"
+        )
+        
+        return success(data=response.model_dump(), msg="OWL文件导出成功")
+        
+    except ValueError as e:
+        # 验证错误 (400)
+        api_logger.warning(f"Validation error in export: {str(e)}")
+        return fail(BizCode.BAD_REQUEST, "请求参数无效", str(e))
+        
+    except RuntimeError as e:
+        # 运行时错误 (500)
+        api_logger.error(f"Runtime error in export: {str(e)}", exc_info=True)
+        return fail(BizCode.INTERNAL_ERROR, "OWL文件导出失败", str(e))
+        
+    except Exception as e:
+        # 未知错误 (500)
+        api_logger.error(f"Unexpected error in export: {str(e)}", exc_info=True)
+        return fail(BizCode.INTERNAL_ERROR, "OWL文件导出失败", str(e))
 
 
 # ==================== 本体场景管理接口 ====================
@@ -763,370 +1003,3 @@ async def get_class(
     """
     from app.controllers.ontology_secondary_routes import get_class_handler
     return await get_class_handler(class_id, db, current_user)
-
-
-# ==================== OWL 导入接口 ====================
-
-@router.post("/import", response_model=ApiResponse)
-async def import_owl_file(
-    scene_name: str = Form(..., description="场景名称"),
-    scene_description: Optional[str] = Form(None, description="场景描述（可选）"),
-    file: UploadFile = File(..., description="OWL/TTL文件"),
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """导入 OWL/TTL 文件并创建新场景
-    
-    上传 OWL 或 TTL 文件，解析其中定义的本体类型（owl:Class），
-    解析成功后创建新场景，并将类型保存到该场景的 ontology_class 表中。
-    
-    文件格式根据文件扩展名自动识别：
-    - .owl, .rdf, .xml -> rdfxml 格式
-    - .ttl -> turtle 格式
-    
-    Args:
-        scene_name: 场景名称（表单字段）
-        scene_description: 场景描述（表单字段，可选）
-        file: 上传的文件（支持 .owl, .ttl, .rdf, .xml）
-        db: 数据库会话
-        current_user: 当前用户
-        
-    Returns:
-        ApiResponse: 包含导入结果
-    """
-    from app.repositories.ontology_scene_repository import OntologySceneRepository
-    from app.repositories.ontology_class_repository import OntologyClassRepository
-    
-    # 根据文件扩展名确定格式
-    filename = file.filename.lower() if file.filename else ""
-    if filename.endswith('.ttl'):
-        owl_format = "turtle"
-        file_type = "ttl"
-    elif filename.endswith(('.owl', '.rdf', '.xml')):
-        owl_format = "rdfxml"
-        file_type = "owl"
-    else:
-        return fail(
-            BizCode.BAD_REQUEST,
-            "文件格式不支持",
-            f"不支持的文件格式: {filename}，支持的格式: .owl, .ttl, .rdf, .xml"
-        )
-    
-    api_logger.info(
-        f"OWL import requested by user {current_user.id}, "
-        f"scene_name={scene_name}, "
-        f"filename={file.filename}, "
-        f"format={owl_format}"
-    )
-    
-    try:
-        # 获取当前工作空间ID
-        workspace_id = current_user.current_workspace_id
-        if not workspace_id:
-            api_logger.warning(f"User {current_user.id} has no current workspace")
-            return fail(BizCode.BAD_REQUEST, "请求参数无效", "当前用户没有工作空间")
-        
-        # 1. 验证场景名称不为空
-        if not scene_name or not scene_name.strip():
-            return fail(BizCode.BAD_REQUEST, "请求参数无效", "场景名称不能为空")
-        
-        scene_name = scene_name.strip()
-        
-        # 2. 检查场景名称是否已存在
-        scene_repo = OntologySceneRepository(db)
-        existing_scene = scene_repo.get_by_name(scene_name, workspace_id)
-        if existing_scene:
-            api_logger.warning(f"Scene name already exists: {scene_name}")
-            return fail(
-                BizCode.BAD_REQUEST,
-                "场景名称已存在",
-                f"工作空间下已存在名为 '{scene_name}' 的场景"
-            )
-        
-        # 3. 读取文件内容
-        try:
-            content = await file.read()
-            owl_content = content.decode('utf-8')
-        except UnicodeDecodeError:
-            return fail(
-                BizCode.BAD_REQUEST,
-                f"{file_type}文件导入失败",
-                "文件编码错误，请确保文件使用 UTF-8 编码"
-            )
-        
-        # 4. 解析 OWL 内容（先解析，成功后再创建场景）
-        owl_validator = OWLValidator()
-        parsed_classes = owl_validator.parse_owl_content(
-            owl_content=owl_content,
-            format=owl_format
-        )
-        
-        if not parsed_classes:
-            api_logger.warning("No classes found in OWL content")
-            return fail(
-                BizCode.BAD_REQUEST,
-                "未找到本体类型",
-                "文件中没有定义任何本体类型（owl:Class）"
-            )
-        
-        # 5. 文件解析成功，创建场景
-        scene = scene_repo.create(
-            scene_data={
-                "scene_name": scene_name,
-                "scene_description": scene_description
-            },
-            workspace_id=workspace_id
-        )
-        scene_uuid = scene.scene_id
-        
-        api_logger.info(f"Scene created for import: {scene_uuid}")
-        
-        # 6. 批量创建类型（去重同一批次内的重复类型）
-        class_repo = OntologyClassRepository(db)
-        created_items = []
-        existing_names = set()
-        skipped_count = 0
-        
-        for cls in parsed_classes:
-            class_name = cls["name"]
-            class_description = cls.get("description")
-            
-            # 检查同一批次内是否重复
-            if class_name in existing_names:
-                skipped_count += 1
-                api_logger.debug(f"Skipping duplicate class in batch: {class_name}")
-                continue
-            
-            # 创建类型
-            ontology_class = class_repo.create(
-                class_data={
-                    "class_name": class_name,
-                    "class_description": class_description
-                },
-                scene_id=scene_uuid
-            )
-            
-            # 添加到已存在集合，防止同一批次内重复
-            existing_names.add(class_name)
-            
-            created_items.append(ClassResponse(
-                class_id=ontology_class.class_id,
-                class_name=ontology_class.class_name,
-                class_description=ontology_class.class_description,
-                scene_id=ontology_class.scene_id,
-                created_at=ontology_class.created_at,
-                updated_at=ontology_class.updated_at
-            ))
-        
-        # 7. 提交事务
-        db.commit()
-        
-        # 8. 构建响应
-        response = ImportOwlResponse(
-            scene_id=scene_uuid,
-            scene_name=scene.scene_name,
-            imported_count=len(created_items),
-            skipped_count=skipped_count,
-            items=created_items
-        )
-        
-        api_logger.info(
-            f"{file_type} import completed, "
-            f"scene_id={scene_uuid}, "
-            f"scene_name={scene_name}, "
-            f"format={owl_format}, "
-            f"imported={len(created_items)}, "
-            f"skipped={skipped_count}"
-        )
-        
-        return success(data=response.model_dump(), msg=f"{file_type}文件导入成功")
-        
-    except ValueError as e:
-        db.rollback()
-        api_logger.warning(f"Validation error in import: {str(e)}")
-        return fail(BizCode.BAD_REQUEST, f"{file_type}文件导入失败", str(e))
-        
-    except Exception as e:
-        db.rollback()
-        api_logger.error(f"Unexpected error in import: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, f"{file_type}文件导入失败", str(e))
-
-# ==================== OWL 导出接口 ====================        
-@router.post("/export")
-async def export_owl_by_scene(
-    request: ExportBySceneRequest,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """按场景导出OWL/TTL文件
-    
-    根据scene_id从数据库查询该场景下的所有本体类型，并导出为文件下载。
-    
-    Args:
-        request: 导出请求，包含 scene_id 和 format
-        db: 数据库会话
-        current_user: 当前用户
-        
-    Returns:
-        StreamingResponse: 文件流响应，浏览器会直接下载文件
-    """
-    from uuid import UUID
-    from app.repositories.ontology_scene_repository import OntologySceneRepository
-    from app.repositories.ontology_class_repository import OntologyClassRepository
-    
-    api_logger.info(
-        f"OWL export by scene requested by user {current_user.id}, "
-        f"scene_id={request.scene_id}, "
-        f"format={request.format}"
-    )
-    
-    try:
-        # 验证格式参数
-        valid_formats = ["rdfxml", "turtle"]
-        owl_format = request.format.lower() if request.format else "rdfxml"
-        if owl_format not in valid_formats:
-            api_logger.warning(f"Invalid format: {request.format}")
-            return fail(
-                BizCode.BAD_REQUEST,
-                "格式参数无效",
-                f"不支持的格式: {request.format}，支持的格式: rdfxml, turtle"
-            )
-        
-        # 获取当前工作空间ID
-        workspace_id = current_user.current_workspace_id
-        if not workspace_id:
-            api_logger.warning(f"User {current_user.id} has no current workspace")
-            return fail(BizCode.BAD_REQUEST, "请求参数无效", "当前用户没有工作空间")
-        
-        # 1. 查询场景信息
-        scene_repo = OntologySceneRepository(db)
-        scene = scene_repo.get_by_id(request.scene_id)
-        
-        if not scene:
-            api_logger.warning(f"Scene not found: {request.scene_id}")
-            return fail(BizCode.NOT_FOUND, "场景不存在", f"找不到场景: {request.scene_id}")
-        
-        # 验证场景属于当前工作空间
-        if scene.workspace_id != workspace_id:
-            api_logger.warning(
-                f"Scene {request.scene_id} does not belong to workspace {workspace_id}"
-            )
-            return fail(BizCode.FORBIDDEN, "无权访问", "该场景不属于当前工作空间")
-        
-        # 2. 查询场景下的所有本体类型
-        class_repo = OntologyClassRepository(db)
-        ontology_classes_db = class_repo.get_classes_by_scene(request.scene_id)
-        
-        if not ontology_classes_db:
-            api_logger.warning(f"No classes found in scene: {request.scene_id}")
-            return fail(BizCode.BAD_REQUEST, "场景为空", "该场景下没有定义任何本体类型")
-        
-        # 3. 将数据库模型转换为OWL导出所需的OntologyClass格式
-        ontology_classes: List[OntologyClass] = []
-        for db_class in ontology_classes_db:
-            owl_class = OntologyClass(
-                id=str(db_class.class_id),
-                name=db_class.class_name,
-                name_chinese=db_class.class_name if _is_chinese(db_class.class_name) else None,
-                description=db_class.class_description or "",
-                examples=[],
-                parent_class=None,
-                entity_type="Concept",
-                domain=scene.scene_name
-            )
-            ontology_classes.append(owl_class)
-        
-        # 4. 确定文件名、扩展名和 MIME 类型
-        file_ext = ".ttl" if owl_format == "turtle" else ".owl"
-        filename = _sanitize_filename(scene.scene_name) + file_ext
-        media_type = "text/turtle" if owl_format == "turtle" else "application/rdf+xml"
-        file_type = "ttl" if owl_format == "turtle" else "owl"
-        
-        # 5. 导出OWL文件
-        with tempfile.NamedTemporaryFile(
-            mode='w',
-            suffix='.owl',
-            delete=False
-        ) as tmp_file:
-            output_path = tmp_file.name
-        
-        owl_validator = OWLValidator()
-        
-        # 验证本体类
-        is_valid, errors, world = owl_validator.validate_ontology_classes(
-            classes=ontology_classes,
-        )
-        
-        if not is_valid:
-            logger.warning(
-                f"OWL validation found {len(errors)} issues during export: {errors}"
-            )
-        
-        if not world:
-            error_msg = "Failed to create OWL world for export"
-            logger.error(error_msg)
-            return fail(BizCode.INTERNAL_ERROR, "创建OWL世界失败", error_msg)
-        
-        # 导出OWL文件（使用请求指定的格式）
-        owl_content = owl_validator.export_to_owl(
-            world=world,
-            output_path=output_path,
-            format=owl_format,
-            classes=ontology_classes
-        )
-        
-        api_logger.info(
-            f"{file_type} export by scene completed, "
-            f"scene={scene.scene_name}, "
-            f"filename={filename}, "
-            f"format={owl_format}, "
-            f"classes_count={len(ontology_classes)}"
-        )
-        
-        # 6. 返回文件流响应
-        # filename 使用 ASCII 安全的默认名，filename* 使用 UTF-8 编码的实际名称
-        ascii_filename = f"ontology{file_ext}"
-        encoded_filename = quote(filename)
-        return StreamingResponse(
-            io.BytesIO(owl_content.encode('utf-8')),
-            media_type=media_type,
-            headers={
-                "Content-Disposition": f"attachment; filename=\"{ascii_filename}\"; filename*=UTF-8''{encoded_filename}"
-            }
-        )
-        
-    except ValueError as e:
-        api_logger.warning(f"Validation error in export by scene: {str(e)}")
-        file_type = "ttl" if (request.format and request.format.lower() == "turtle") else "owl"
-        return fail(BizCode.BAD_REQUEST, "请求参数无效", str(e))
-        
-    except RuntimeError as e:
-        api_logger.error(f"Runtime error in export by scene: {str(e)}", exc_info=True)
-        file_type = "ttl" if (request.format and request.format.lower() == "turtle") else "owl"
-        return fail(BizCode.INTERNAL_ERROR, f"{file_type}文件导出失败", str(e))
-        
-    except Exception as e:
-        api_logger.error(f"Unexpected error in export by scene: {str(e)}", exc_info=True)
-        file_type = "ttl" if (request.format and request.format.lower() == "turtle") else "owl"
-        return fail(BizCode.INTERNAL_ERROR, f"{file_type}文件导出失败", str(e))
-
-
-def _is_chinese(text: str) -> bool:
-    """检查文本是否包含中文字符"""
-    for char in text:
-        if '\u4e00' <= char <= '\u9fff':
-            return True
-    return False
-
-
-def _sanitize_filename(name: str) -> str:
-    """清理文件名，移除不合法字符"""
-    import re
-    # 移除或替换不合法的文件名字符
-    sanitized = re.sub(r'[<>:"/\\|?*]', '_', name)
-    # 移除前后空格
-    sanitized = sanitized.strip()
-    # 如果为空，使用默认名称
-    if not sanitized:
-        sanitized = "ontology_export"
-    return sanitized

api/app/controllers/prompt_optimizer_controller.py

@@ -120,8 +120,7 @@ async def get_prompt_opt(
                     session_id=session_id,
                     user_id=current_user.id,
                     current_prompt=data.current_prompt,
-                    user_require=data.message,
-                    skill=data.skill
+                    user_require=data.message
             ):
                 # chunk 是 prompt 的增量内容
                 yield f"event:message\ndata: {json.dumps(chunk)}\n\n"

api/app/controllers/public_share_controller.py

@@ -438,8 +438,7 @@ async def chat(
                         memory=payload.memory,
                         storage_type=storage_type,
                         user_rag_memory_id=user_rag_memory_id,
-                        workspace_id=workspace_id,
-                        files=payload.files  # 传递多模态文件
+                        workspace_id=workspace_id
                 ):
                     yield event
 
@@ -476,8 +475,7 @@ async def chat(
             memory=payload.memory,
             storage_type=storage_type,
             user_rag_memory_id=user_rag_memory_id,
-            workspace_id=workspace_id,
-            files=payload.files  # 传递多模态文件
+            workspace_id=workspace_id
         )
         return success(data=conversation_schema.ChatResponse(**result).model_dump(mode="json"))
     elif app_type == AppType.MULTI_AGENT:
@@ -580,7 +578,6 @@ async def chat(
                         conversation_id=conversation.id,  # 使用已创建的会话 ID
                         user_id=end_user_id,  # 转换为字符串
                         variables=payload.variables,
-                        files=payload.files,
                         config=config,
                         web_search=payload.web_search,
                         memory=payload.memory,
@@ -588,8 +585,7 @@ async def chat(
                         user_rag_memory_id=user_rag_memory_id,
                         app_id=release.app_id,
                         workspace_id=workspace_id,
-                        release_id=release.id,
-                        public=True
+                        release_id=release.id
                 ):
                     event_type = event.get("event", "message")
                     event_data = event.get("data", {})

api/app/controllers/service/app_api_controller.py

@@ -12,6 +12,7 @@ from app.core.exceptions import BusinessException
 from app.core.logging_config import get_business_logger
 from app.core.response_utils import success
 from app.db import get_db
+from app.dependencies import get_app_or_workspace
 from app.models.app_model import App
 from app.models.app_model import AppType
 from app.repositories import knowledge_repository
@@ -20,10 +21,9 @@ from app.schemas import AppChatRequest, conversation_schema
 from app.schemas.api_key_schema import ApiKeyAuth
 from app.services import workspace_service
 from app.services.app_chat_service import AppChatService, get_app_chat_service
-from app.services.app_service import get_app_service, AppService
 from app.services.conversation_service import ConversationService, get_conversation_service
-from app.utils.app_config_utils import workflow_config_4_app_release, \
-    agent_config_4_app_release, multi_agent_config_4_app_release
+from app.utils.app_config_utils import dict_to_multi_agent_config, workflow_config_4_app_release, agent_config_4_app_release, multi_agent_config_4_app_release
+from app.services.app_service import get_app_service, AppService
 
 router = APIRouter(prefix="/app", tags=["V1 - App API"])
 logger = get_business_logger()
@@ -34,7 +34,6 @@ async def list_apps():
     """列出可访问的应用（占位）"""
     return success(data=[], msg="App API - Coming Soon")
 
-
 # /v1/app/chat
 
 # @router.post("/chat")
@@ -74,17 +73,16 @@ def _checkAppConfig(app: App):
     else:
         raise BusinessException("不支持的应用类型", BizCode.AGENT_CONFIG_MISSING)
 
-
 @router.post("/chat")
 @require_api_key(scopes=["app"])
 async def chat(
-        request: Request,
-        api_key_auth: ApiKeyAuth = None,
-        db: Session = Depends(get_db),
-        conversation_service: Annotated[ConversationService, Depends(get_conversation_service)] = None,
-        app_chat_service: Annotated[AppChatService, Depends(get_app_chat_service)] = None,
-        app_service: Annotated[AppService, Depends(get_app_service)] = None,
-        message: str = Body(..., description="聊天消息内容"),
+    request:Request,
+    api_key_auth: ApiKeyAuth = None,
+    db: Session = Depends(get_db),
+    conversation_service: Annotated[ConversationService, Depends(get_conversation_service)] = None,
+    app_chat_service: Annotated[AppChatService, Depends(get_app_chat_service)] = None,
+    app_service: Annotated[AppService, Depends(get_app_service)] = None,
+    message: str = Body(..., description="聊天消息内容"),
 ):
     body = await request.json()
     payload = AppChatRequest(**body)
@@ -100,8 +98,8 @@ async def chat(
         original_user_id=other_id  # Save original user_id to other_id
     )
     end_user_id = str(new_end_user.id)
-    web_search = True
-    memory = True
+    web_search=True
+    memory=True
     # 提前验证和准备（在流式响应开始前完成）
     storage_type = workspace_service.get_workspace_storage_type_without_auth(
         db=db,
@@ -148,17 +146,16 @@ async def chat(
         if payload.stream:
             async def event_generator():
                 async for event in app_chat_service.agnet_chat_stream(
-                        message=payload.message,
-                        conversation_id=conversation.id,  # 使用已创建的会话 ID
-                        user_id=end_user_id,  # 转换为字符串
-                        variables=payload.variables,
-                        web_search=web_search,
-                        config=agent_config,
-                        memory=memory,
-                        storage_type=storage_type,
-                        user_rag_memory_id=user_rag_memory_id,
-                        workspace_id=workspace_id,
-                        files=payload.files  # 传递多模态文件
+                    message=payload.message,
+                    conversation_id=conversation.id,  # 使用已创建的会话 ID
+                    user_id= end_user_id,  # 转换为字符串
+                    variables=payload.variables,
+                    web_search=web_search,
+                    config=agent_config,
+                    memory=memory,
+                    storage_type=storage_type,
+                    user_rag_memory_id=user_rag_memory_id,
+                    workspace_id=workspace_id
                 ):
                     yield event
 
@@ -178,13 +175,12 @@ async def chat(
             conversation_id=conversation.id,  # 使用已创建的会话 ID
             user_id=end_user_id,  # 转换为字符串
             variables=payload.variables,
-            config=agent_config,
+            config= agent_config,
             web_search=web_search,
             memory=memory,
             storage_type=storage_type,
             user_rag_memory_id=user_rag_memory_id,
-            workspace_id=workspace_id,
-            files=payload.files  # 传递多模态文件
+            workspace_id=workspace_id
         )
         return success(data=conversation_schema.ChatResponse(**result).model_dump(mode="json"))
     elif app_type == AppType.MULTI_AGENT:
@@ -194,15 +190,15 @@ async def chat(
             async def event_generator():
                 async for event in app_chat_service.multi_agent_chat_stream(
 
-                        message=payload.message,
-                        conversation_id=conversation.id,  # 使用已创建的会话 ID
-                        user_id=end_user_id,  # 转换为字符串
-                        variables=payload.variables,
-                        config=config,
-                        web_search=web_search,
-                        memory=memory,
-                        storage_type=storage_type,
-                        user_rag_memory_id=user_rag_memory_id
+                    message=payload.message,
+                    conversation_id=conversation.id,  # 使用已创建的会话 ID
+                    user_id=end_user_id,  # 转换为字符串
+                    variables=payload.variables,
+                    config=config,
+                    web_search=web_search,
+                    memory=memory,
+                    storage_type=storage_type,
+                    user_rag_memory_id=user_rag_memory_id
                 ):
                     yield event
 
@@ -236,19 +232,19 @@ async def chat(
         if payload.stream:
             async def event_generator():
                 async for event in app_chat_service.workflow_chat_stream(
-                        message=payload.message,
-                        conversation_id=conversation.id,  # 使用已创建的会话 ID
-                        user_id=end_user_id,  # 转换为字符串
-                        variables=payload.variables,
-                        files=payload.files,
-                        config=config,
-                        web_search=web_search,
-                        memory=memory,
-                        storage_type=storage_type,
-                        user_rag_memory_id=user_rag_memory_id,
-                        app_id=app.id,
-                        workspace_id=workspace_id,
-                        release_id=app.current_release.id,
+
+                    message=payload.message,
+                    conversation_id=conversation.id,  # 使用已创建的会话 ID
+                    user_id=end_user_id,  # 转换为字符串
+                    variables=payload.variables,
+                    config=config,
+                    web_search=web_search,
+                    memory=memory,
+                    storage_type=storage_type,
+                    user_rag_memory_id=user_rag_memory_id,
+                    app_id=app.id,
+                    workspace_id=workspace_id,
+                    release_id=app.current_release.id,
                 ):
                     event_type = event.get("event", "message")
                     event_data = event.get("data", {})
@@ -298,3 +294,4 @@ async def chat(
         from app.core.exceptions import BusinessException
         from app.core.error_codes import BizCode
         raise BusinessException(f"不支持的应用类型: {app_type}", BizCode.APP_TYPE_NOT_SUPPORTED)
+

api/app/controllers/service/rag_api_knowledge_controller.py

@@ -246,73 +246,3 @@ async def rebuild_knowledge_graph(
                                                               db=db,
                                                               current_user=current_user)
 
-
-@router.get("/check/yuque/auth", response_model=ApiResponse)
-@require_api_key(scopes=["rag"])
-async def check_yuque_auth(
-    yuque_user_id: str,
-    yuque_token: str,
-    request: Request,
-    api_key_auth: ApiKeyAuth = None,
-    db: Session = Depends(get_db),
-):
-    """
-    check yuque auth info
-    """
-    api_key = api_key_service.ApiKeyService.get_api_key(db, api_key_auth.api_key_id, api_key_auth.workspace_id)
-    current_user = api_key.creator
-    current_user.current_workspace_id = api_key_auth.workspace_id
-
-    api_logger.info(f"check yuque auth info, username: {current_user.username}")
-
-    return await knowledge_controller.check_yuque_auth(yuque_user_id=yuque_user_id,
-                                                       yuque_token=yuque_token,
-                                                       db=db,
-                                                       current_user=current_user)
-
-
-@router.get("/check/feishu/auth", response_model=ApiResponse)
-@require_api_key(scopes=["rag"])
-async def check_feishu_auth(
-    feishu_app_id: str,
-    feishu_app_secret: str,
-    feishu_folder_token: str,
-    request: Request,
-    api_key_auth: ApiKeyAuth = None,
-    db: Session = Depends(get_db),
-):
-    """
-    check feishu auth info
-    """
-    api_key = api_key_service.ApiKeyService.get_api_key(db, api_key_auth.api_key_id, api_key_auth.workspace_id)
-    current_user = api_key.creator
-    current_user.current_workspace_id = api_key_auth.workspace_id
-
-    api_logger.info(f"check feishu auth info, username: {current_user.username}")
-
-    return await knowledge_controller.check_feishu_auth(feishu_app_id=feishu_app_id,
-                                                        feishu_app_secret=feishu_app_secret,
-                                                        feishu_folder_token=feishu_folder_token,
-                                                        db=db,
-                                                        current_user=current_user)
-
-
-@router.post("/{knowledge_id}/sync", response_model=ApiResponse)
-@require_api_key(scopes=["rag"])
-async def sync_knowledge(
-    knowledge_id: uuid.UUID,
-    request: Request,
-    api_key_auth: ApiKeyAuth = None,
-    db: Session = Depends(get_db),
-):
-    """
-    sync knowledge base information based on knowledge_id
-    """
-    api_key = api_key_service.ApiKeyService.get_api_key(db, api_key_auth.api_key_id, api_key_auth.workspace_id)
-    current_user = api_key.creator
-    current_user.current_workspace_id = api_key_auth.workspace_id
-
-    return await knowledge_controller.sync_knowledge(knowledge_id=knowledge_id,
-                                                     db=db,
-                                                     current_user=current_user)
-

api/app/controllers/skill_controller.py

@@ -1,85 +0,0 @@
-"""Skill Controller - 技能市场管理"""
-from fastapi import APIRouter, Depends, Query
-from sqlalchemy.orm import Session
-from typing import Optional
-import uuid
-
-from app.db import get_db
-from app.dependencies import get_current_user
-from app.models import User
-from app.schemas import skill_schema
-from app.schemas.response_schema import PageData, PageMeta
-from app.services.skill_service import SkillService
-from app.core.response_utils import success
-
-router = APIRouter(prefix="/skills", tags=["Skills"])
-
-
-@router.post("", summary="创建技能")
-def create_skill(
-    data: skill_schema.SkillCreate,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """创建技能 - 可以关联现有工具（内置、MCP、自定义）"""
-    tenant_id = current_user.tenant_id
-    skill = SkillService.create_skill(db, data, tenant_id)
-    return success(data=skill_schema.Skill.model_validate(skill), msg="技能创建成功")
-
-
-@router.get("", summary="技能列表")
-def list_skills(
-    search: Optional[str] = Query(None, description="搜索关键词"),
-    is_active: Optional[bool] = Query(None, description="是否激活"),
-    is_public: Optional[bool] = Query(None, description="是否公开"),
-    page: int = Query(1, ge=1, description="页码"),
-    pagesize: int = Query(10, ge=1, le=100, description="每页数量"),
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """技能市场列表 - 包含本工作空间和公开的技能"""
-    tenant_id = current_user.tenant_id
-    skills, total = SkillService.list_skills(
-        db, tenant_id, search, is_active, is_public, page, pagesize
-    )
-    
-    items = [skill_schema.Skill.model_validate(s) for s in skills]
-    meta = PageMeta(page=page, pagesize=pagesize, total=total, hasnext=(page * pagesize) < total)
-    return success(data=PageData(page=meta, items=items), msg="技能市场列表获取成功")
-
-
-@router.get("/{skill_id}", summary="获取技能详情")
-def get_skill(
-    skill_id: uuid.UUID,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """获取技能详情"""
-    tenant_id = current_user.tenant_id
-    skill = SkillService.get_skill(db, skill_id, tenant_id)
-    return success(data=skill_schema.Skill.model_validate(skill), msg="获取技能详情成功")
-
-
-@router.put("/{skill_id}", summary="更新技能")
-def update_skill(
-    skill_id: uuid.UUID,
-    data: skill_schema.SkillUpdate,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """更新技能"""
-    tenant_id = current_user.tenant_id
-    skill = SkillService.update_skill(db, skill_id, data, tenant_id)
-    return success(data=skill_schema.Skill.model_validate(skill), msg="技能更新成功")
-
-
-@router.delete("/{skill_id}", summary="删除技能")
-def delete_skill(
-    skill_id: uuid.UUID,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """删除技能"""
-    tenant_id = current_user.tenant_id
-    SkillService.delete_skill(db, skill_id, tenant_id)
-    return success(msg="技能删除成功")

api/app/controllers/user_controller.py

@@ -2,23 +2,15 @@ from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 import uuid
 
-from app.core.error_codes import BizCode
-from app.core.exceptions import BusinessException
 from app.db import get_db
 from app.dependencies import get_current_user, get_current_superuser
 from app.models.user_model import User
 from app.schemas import user_schema
-from app.schemas.user_schema import (
-    ChangePasswordRequest,
-    AdminChangePasswordRequest,
-    SendEmailCodeRequest,
-    VerifyEmailCodeRequest,
-    VerifyPasswordRequest)
+from app.schemas.user_schema import ChangePasswordRequest, AdminChangePasswordRequest
 from app.schemas.response_schema import ApiResponse
 from app.services import user_service
 from app.core.logging_config import get_api_logger
 from app.core.response_utils import success
-from app.core.security import verify_password
 
 # 获取API专用日志器
 api_logger = get_api_logger()
@@ -100,7 +92,7 @@ def get_current_user_info(
             result_schema.current_workspace_name = current_workspace.name
         
         for ws in result.workspaces:
-            if ws.workspace_id == current_user.current_workspace_id and ws.is_active:
+            if ws.workspace_id == current_user.current_workspace_id:
                 result_schema.role = ws.role
                 break
     
@@ -128,7 +120,6 @@ def get_tenant_superusers(
     return success(data=superusers_schema, msg="租户超管列表获取成功")
 
 
-
 @router.get("/{user_id}", response_model=ApiResponse)
 def get_user_info_by_id(
     user_id: uuid.UUID,
@@ -189,54 +180,4 @@ async def admin_change_password(
         return success(msg="密码修改成功")
     else:
         api_logger.info(f"管理员密码重置成功: 用户 {request.user_id}, 随机密码已生成")
-        return success(data=generated_password, msg="密码重置成功")
-
-
-@router.post("/verify_pwd", response_model=ApiResponse)
-def verify_pwd(
-    request: VerifyPasswordRequest,
-    current_user: User = Depends(get_current_user),
-):
-    """验证当前用户密码"""
-    api_logger.info(f"用户验证密码请求: {current_user.username}")
-    
-    is_valid = verify_password(request.password, current_user.hashed_password)
-    api_logger.info(f"用户密码验证结果: {current_user.username}, valid={is_valid}")
-    if not is_valid:
-        raise BusinessException("密码验证失败", code=BizCode.VALIDATION_FAILED)
-    return success(data={"valid": is_valid}, msg="验证完成")
-
-
-@router.post("/send-email-code", response_model=ApiResponse)
-async def send_email_code(
-    request: SendEmailCodeRequest,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-):
-    """发送邮箱验证码"""
-    api_logger.info(f"用户请求发送邮箱验证码: {current_user.username}, email={request.email}")
-    
-    await user_service.send_email_code_method(db=db, email=request.email, user_id=current_user.id)
-    
-    api_logger.info(f"邮箱验证码已发送: {current_user.username}")
-    return success(msg="验证码已发送到您的邮箱，请查收")
-
-
-@router.put("/change-email", response_model=ApiResponse)
-async def change_email(
-    request: VerifyEmailCodeRequest,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-):
-    """验证验证码并修改邮箱"""
-    api_logger.info(f"用户修改邮箱: {current_user.username}, new_email={request.new_email}")
-
-    await user_service.verify_and_change_email(
-        db=db,
-        user_id=current_user.id,
-        new_email=request.new_email,
-        code=request.code
-    )
-    
-    api_logger.info(f"用户邮箱修改成功: {current_user.username}")
-    return success(msg="邮箱修改成功")
+        return success(data=generated_password, msg="密码重置成功")

api/app/controllers/user_memory_controllers.py

@@ -8,11 +8,11 @@ from sqlalchemy.orm import Session
 from fastapi import APIRouter, Depends,Header
 
 from app.db import get_db
-from app.core.language_utils import get_language_from_header
 from app.core.logging_config import get_api_logger
 from app.core.response_utils import success, fail
 from app.core.error_codes import BizCode
 from app.core.api_key_utils import timestamp_to_datetime
+from app.services.memory_base_service import Translation_English
 from app.services.user_memory_service import (
     UserMemoryService,
     analytics_memory_types,
@@ -45,6 +45,7 @@ router = APIRouter(
 @router.get("/analytics/memory_insight/report", response_model=ApiResponse)
 async def get_memory_insight_report_api(
     end_user_id: str,
+    language_type: str = Header(default="zh", alias="X-Language-Type"),
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
 ) -> dict:
@@ -54,10 +55,18 @@ async def get_memory_insight_report_api(
     此接口仅查询数据库中已缓存的记忆洞察数据，不执行生成操作。
     如需生成新的洞察报告，请使用专门的生成接口。
     """
+    workspace_id = current_user.current_workspace_id
+    workspace_repo = WorkspaceRepository(db)
+    workspace_models = workspace_repo.get_workspace_models_configs(workspace_id)
+
+    if workspace_models:
+        model_id = workspace_models.get("llm", None)
+    else:
+        model_id = None
     api_logger.info(f"记忆洞察报告查询请求: end_user_id={end_user_id}, user={current_user.username}")
     try:
         # 调用服务层获取缓存数据
-        result = await user_memory_service.get_cached_memory_insight(db, end_user_id)
+        result = await user_memory_service.get_cached_memory_insight(db, end_user_id,model_id,language_type)
 
         if result["is_cached"]:
             api_logger.info(f"成功返回缓存的记忆洞察报告: end_user_id={end_user_id}")
@@ -73,7 +82,7 @@ async def get_memory_insight_report_api(
 @router.get("/analytics/user_summary", response_model=ApiResponse)
 async def get_user_summary_api(
     end_user_id: str,
-    language_type: str = Header(default=None, alias="X-Language-Type"),
+    language_type: str = Header(default="zh", alias="X-Language-Type"),
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
 ) -> dict:
@@ -82,14 +91,7 @@ async def get_user_summary_api(
 
     此接口仅查询数据库中已缓存的用户摘要数据，不执行生成操作。
     如需生成新的用户摘要，请使用专门的生成接口。
-    
-    语言控制：
-    - 使用 X-Language-Type Header 指定语言
-    - 如果未传 Header，默认使用中文 (zh)
     """
-    # 使用集中化的语言校验
-    language = get_language_from_header(language_type)
-    
     workspace_id = current_user.current_workspace_id
     workspace_repo = WorkspaceRepository(db)
     workspace_models = workspace_repo.get_workspace_models_configs(workspace_id)
@@ -101,7 +103,7 @@ async def get_user_summary_api(
     api_logger.info(f"用户摘要查询请求: end_user_id={end_user_id}, user={current_user.username}")
     try:
         # 调用服务层获取缓存数据
-        result = await user_memory_service.get_cached_user_summary(db, end_user_id,model_id,language)
+        result = await user_memory_service.get_cached_user_summary(db, end_user_id,model_id,language_type)
 
         if result["is_cached"]:
             api_logger.info(f"成功返回缓存的用户摘要: end_user_id={end_user_id}")
@@ -117,7 +119,6 @@ async def get_user_summary_api(
 @router.post("/analytics/generate_cache", response_model=ApiResponse)
 async def generate_cache_api(
     request: GenerateCacheRequest,
-    language_type: str = Header(default=None, alias="X-Language-Type"),
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
 ) -> dict:
@@ -126,14 +127,7 @@ async def generate_cache_api(
 
     - 如果提供 end_user_id，只为该用户生成
     - 如果不提供，为当前工作空间的所有用户生成
-    
-    语言控制：
-    - 使用 X-Language-Type Header 指定语言 ("zh" 中文, "en" 英文)
-    - 如果未传 Header，默认使用中文 (zh)
     """
-    # 使用集中化的语言校验
-    language = get_language_from_header(language_type)
-    
     workspace_id = current_user.current_workspace_id
 
     # 检查用户是否已选择工作空间
@@ -145,7 +139,7 @@ async def generate_cache_api(
 
     api_logger.info(
         f"缓存生成请求: user={current_user.username}, workspace={workspace_id}, "
-        f"end_user_id={end_user_id if end_user_id else '全部用户'}, language={language}"
+        f"end_user_id={end_user_id if end_user_id else '全部用户'}"
     )
 
     try:
@@ -154,10 +148,10 @@ async def generate_cache_api(
             api_logger.info(f"开始为单个用户生成缓存: end_user_id={end_user_id}")
 
             # 生成记忆洞察
-            insight_result = await user_memory_service.generate_and_cache_insight(db, end_user_id, workspace_id, language=language)
+            insight_result = await user_memory_service.generate_and_cache_insight(db, end_user_id, workspace_id)
 
             # 生成用户摘要
-            summary_result = await user_memory_service.generate_and_cache_summary(db, end_user_id, workspace_id, language=language)
+            summary_result = await user_memory_service.generate_and_cache_summary(db, end_user_id, workspace_id)
 
             # 构建响应
             result = {
@@ -191,7 +185,7 @@ async def generate_cache_api(
             # 为整个工作空间生成
             api_logger.info(f"开始为工作空间 {workspace_id} 批量生成缓存")
 
-            result = await user_memory_service.generate_cache_for_workspace(db, workspace_id, language=language)
+            result = await user_memory_service.generate_cache_for_workspace(db, workspace_id)
 
             # 记录统计信息
             api_logger.info(
@@ -391,13 +385,10 @@ async def update_end_user_profile(
             return fail(BizCode.INTERNAL_ERROR, "用户信息更新失败", error_msg)
 
 @router.get("/memory_space/timeline_memories", response_model=ApiResponse)
-async def memory_space_timeline_of_shared_memories(id: str, label: str,language_type: str = Header(default=None, alias="X-Language-Type"),
+async def memory_space_timeline_of_shared_memories(id: str, label: str,language_type: str = Header(default="zh", alias="X-Language-Type"),
                                       current_user: User = Depends(get_current_user),
                                       db: Session = Depends(get_db),
                                       ):
-    # 使用集中化的语言校验
-    language = get_language_from_header(language_type)
-    
     workspace_id=current_user.current_workspace_id
     workspace_repo = WorkspaceRepository(db)
     workspace_models = workspace_repo.get_workspace_models_configs(workspace_id)
@@ -407,7 +398,7 @@ async def memory_space_timeline_of_shared_memories(id: str, label: str,language_
     else:
         model_id = None
     MemoryEntity = MemoryEntityService(id, label)
-    timeline_memories_result = await MemoryEntity.get_timeline_memories_server(model_id, language)
+    timeline_memories_result = await MemoryEntity.get_timeline_memories_server(model_id, language_type)
 
     return success(data=timeline_memories_result, msg="共同记忆时间线")
 @router.get("/memory_space/relationship_evolution", response_model=ApiResponse)

api/app/controllers/workflow_controller.py

@@ -0,0 +1,610 @@
+"""
+工作流 API 控制器
+"""
+
+import logging
+import uuid
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Path, Query
+from sqlalchemy.orm import Session
+
+from app.db import get_db
+from app.dependencies import get_current_user, cur_workspace_access_guard
+
+from app.models.user_model import User
+from app.models.app_model import App
+from app.services.workflow_service import WorkflowService, get_workflow_service
+from app.schemas.workflow_schema import (
+    WorkflowConfigCreate,
+    WorkflowConfigUpdate,
+    WorkflowConfig,
+    WorkflowValidationResponse,
+    WorkflowExecution,
+    WorkflowNodeExecution,
+    WorkflowExecutionRequest,
+    WorkflowExecutionResponse
+)
+from app.core.response_utils import success, fail
+from app.core.exceptions import BusinessException
+from app.core.error_codes import BizCode
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/apps", tags=["workflow"])
+
+
+# ==================== 工作流配置管理 ====================
+
+@router.post("/{app_id}/workflow")
+@cur_workspace_access_guard()
+async def create_workflow_config(
+        app_id: Annotated[uuid.UUID, Path(description="应用 ID")],
+        config: WorkflowConfigCreate,
+        db: Annotated[Session, Depends(get_db)],
+        current_user: Annotated[User, Depends(get_current_user)],
+        service: Annotated[WorkflowService, Depends(get_workflow_service)]
+):
+    """创建工作流配置
+
+    创建或更新应用的工作流配置。配置会进行基础验证，但允许保存不完整的配置（草稿）。
+    """
+    try:
+        # 验证应用是否存在且属于当前工作空间
+        app = db.query(App).filter(
+            App.id == app_id,
+            App.workspace_id == current_user.current_workspace_id,
+            App.is_active.is_(True)
+        ).first()
+
+        if not app:
+            return fail(
+                code=BizCode.NOT_FOUND,
+                msg="应用不存在或无权访问"
+            )
+
+        # 验证应用类型
+        if app.type != "workflow":
+            return fail(
+                code=BizCode.INVALID_PARAMETER,
+                msg=f"应用类型必须为 workflow，当前为 {app.type}"
+            )
+
+        # 创建工作流配置
+        workflow_config = service.create_workflow_config(
+            app_id=app_id,
+            nodes=[node.model_dump() for node in config.nodes],
+            edges=[edge.model_dump() for edge in config.edges],
+            variables=[var.model_dump() for var in config.variables],
+            execution_config=config.execution_config.model_dump(),
+            triggers=[trigger.model_dump() for trigger in config.triggers],
+            validate=True  # 进行基础验证
+        )
+
+        return success(
+            data=WorkflowConfig.model_validate(workflow_config),
+            msg="工作流配置创建成功"
+        )
+
+    except BusinessException as e:
+        logger.warning(f"创建工作流配置失败: {e.message}")
+        return fail(code=e.error_code, msg=e.message)
+    except Exception as e:
+        logger.error(f"创建工作流配置异常: {e}", exc_info=True)
+        return fail(
+            code=BizCode.INTERNAL_ERROR,
+            msg=f"创建工作流配置失败: {str(e)}"
+        )
+
+
+#
+# @router.get("/{app_id}/workflow")
+# async def get_workflow_config(
+#     app_id: Annotated[uuid.UUID, Path(description="应用 ID")],
+#     db: Annotated[Session, Depends(get_db)],
+#     current_user: Annotated[User, Depends(get_current_user)]
+#
+# ):
+#     """获取工作流配置
+#
+#     获取应用的工作流配置详情。
+#     """
+#     try:
+#         # 验证应用是否存在且属于当前工作空间
+#         app = db.query(App).filter(
+#             App.id == app_id,
+#             App.workspace_id == current_user.current_workspace_id,
+#             App.is_active == True
+#         ).first()
+#
+#         if not app:
+#             return fail(
+#                 code=BizCode.NOT_FOUND,
+#                 msg="应用不存在或无权访问"
+#             )
+#
+#         # 获取工作流配置
+#         service = WorkflowService(db)
+#         workflow_config = service.get_workflow_config(app_id)
+#
+#         if not workflow_config:
+#             return fail(
+#                 code=BizCode.NOT_FOUND,
+#                 msg="工作流配置不存在"
+#             )
+#
+#         return success(
+#             data=WorkflowConfig.model_validate(workflow_config)
+#         )
+#
+#     except Exception as e:
+#         logger.error(f"获取工作流配置异常: {e}", exc_info=True)
+#         return fail(
+#             code=BizCode.INTERNAL_ERROR,
+#             msg=f"获取工作流配置失败: {str(e)}"
+#         )
+
+
+# @router.put("/{app_id}/workflow")
+# async def update_workflow_config(
+#     app_id: Annotated[uuid.UUID, Path(description="应用 ID")],
+#     config: WorkflowConfigUpdate,
+#     db: Annotated[Session, Depends(get_db)],
+#     current_user: Annotated[User, Depends(get_current_user)],
+#     service: Annotated[WorkflowService, Depends(get_workflow_service)]
+# ):
+#     """更新工作流配置
+
+#     更新应用的工作流配置。可以部分更新，未提供的字段保持不变。
+#     """
+#     try:
+#         # 验证应用是否存在且属于当前工作空间
+#         app = db.query(App).filter(
+#             App.id == app_id,
+#             App.workspace_id == current_user.current_workspace_id,
+#             App.is_active == True
+#         ).first()
+
+#         if not app:
+#             return fail(
+#                 code=BizCode.NOT_FOUND,
+#                 msg="应用不存在或无权访问"
+#             )
+
+#         # 更新工作流配置
+#         workflow_config = service.update_workflow_config(
+#             app_id=app_id,
+#             nodes=[node.model_dump() for node in config.nodes] if config.nodes else None,
+#             edges=[edge.model_dump() for edge in config.edges] if config.edges else None,
+#             variables=[var.model_dump() for var in config.variables] if config.variables else None,
+#             execution_config=config.execution_config.model_dump() if config.execution_config else None,
+#             triggers=[trigger.model_dump() for trigger in config.triggers] if config.triggers else None,
+#             validate=True
+#         )
+
+#         return success(
+#             data=WorkflowConfig.model_validate(workflow_config),
+#             msg="工作流配置更新成功"
+#         )
+
+#     except BusinessException as e:
+#         logger.warning(f"更新工作流配置失败: {e.message}")
+#         return fail(code=e.error_code, msg=e.message)
+#     except Exception as e:
+#         logger.error(f"更新工作流配置异常: {e}", exc_info=True)
+#         return fail(
+#             code=BizCode.INTERNAL_ERROR,
+#             msg=f"更新工作流配置失败: {str(e)}"
+#         )
+
+
+@router.delete("/{app_id}/workflow")
+async def delete_workflow_config(
+        app_id: Annotated[uuid.UUID, Path(description="应用 ID")],
+        db: Annotated[Session, Depends(get_db)],
+        current_user: Annotated[User, Depends(get_current_user)],
+        service: Annotated[WorkflowService, Depends(get_workflow_service)]
+):
+    """删除工作流配置
+
+    删除应用的工作流配置。
+    """
+    try:
+        # 验证应用是否存在且属于当前工作空间
+        app = db.query(App).filter(
+            App.id == app_id,
+            App.workspace_id == current_user.current_workspace_id,
+            App.is_active.is_(True)
+        ).first()
+
+        if not app:
+            return fail(
+                code=BizCode.NOT_FOUND,
+                msg="应用不存在或无权访问"
+            )
+
+        # 删除工作流配置
+        deleted = service.delete_workflow_config(app_id)
+
+        if not deleted:
+            return fail(
+                code=BizCode.NOT_FOUND,
+                msg="工作流配置不存在"
+            )
+
+        return success(msg="工作流配置删除成功")
+
+    except Exception as e:
+        logger.error(f"删除工作流配置异常: {e}", exc_info=True)
+        return fail(
+            code=BizCode.INTERNAL_ERROR,
+            msg=f"删除工作流配置失败: {str(e)}"
+        )
+
+
+@router.post("/{app_id}/workflow/validate")
+async def validate_workflow_config(
+        app_id: Annotated[uuid.UUID, Path(description="应用 ID")],
+        db: Annotated[Session, Depends(get_db)],
+        current_user: Annotated[User, Depends(get_current_user)],
+        service: Annotated[WorkflowService, Depends(get_workflow_service)],
+        for_publish: Annotated[bool, Query(description="是否为发布验证")] = False
+):
+    """验证工作流配置
+
+    验证工作流配置是否有效。可以选择是否进行发布级别的严格验证。
+    """
+    try:
+        # 验证应用是否存在且属于当前工作空间
+        app = db.query(App).filter(
+            App.id == app_id,
+            App.workspace_id == current_user.current_workspace_id,
+            App.is_active.is_(True)
+        ).first()
+
+        if not app:
+            return fail(
+                code=BizCode.NOT_FOUND,
+                msg="应用不存在或无权访问"
+            )
+
+        # 验证工作流配置
+
+        if for_publish:
+            is_valid, errors = service.validate_workflow_config_for_publish(app_id)
+        else:
+            workflow_config = service.get_workflow_config(app_id)
+            if not workflow_config:
+                return fail(
+                    code=BizCode.NOT_FOUND,
+                    msg="工作流配置不存在"
+                )
+
+            from app.core.workflow.validator import validate_workflow_config as validate_config
+            config_dict = {
+                "nodes": workflow_config.nodes,
+                "edges": workflow_config.edges,
+                "variables": workflow_config.variables,
+                "execution_config": workflow_config.execution_config,
+                "triggers": workflow_config.triggers
+            }
+            is_valid, errors = validate_config(config_dict, for_publish=False)
+
+        return success(
+            data=WorkflowValidationResponse(
+                is_valid=is_valid,
+                errors=errors,
+                warnings=[]
+            )
+        )
+
+    except BusinessException as e:
+        logger.warning(f"验证工作流配置失败: {e.message}")
+        return fail(code=e.error_code, msg=e.message)
+    except Exception as e:
+        logger.error(f"验证工作流配置异常: {e}", exc_info=True)
+        return fail(
+            code=BizCode.INTERNAL_ERROR,
+            msg=f"验证工作流配置失败: {str(e)}"
+        )
+
+
+# ==================== 工作流执行管理 ====================
+
+@router.get("/{app_id}/workflow/executions")
+async def get_workflow_executions(
+        app_id: Annotated[uuid.UUID, Path(description="应用 ID")],
+        db: Annotated[Session, Depends(get_db)],
+        current_user: Annotated[User, Depends(get_current_user)],
+        service: Annotated[WorkflowService, Depends(get_workflow_service)],
+        limit: Annotated[int, Query(ge=1, le=100)] = 50,
+        offset: Annotated[int, Query(ge=0)] = 0
+):
+    """获取工作流执行记录列表
+
+    获取应用的工作流执行历史记录。
+    """
+    try:
+        # 验证应用是否存在且属于当前工作空间
+        app = db.query(App).filter(
+            App.id == app_id,
+            App.workspace_id == current_user.current_workspace_id,
+            App.is_active.is_(True)
+        ).first()
+
+        if not app:
+            return fail(
+                code=BizCode.NOT_FOUND,
+                msg="应用不存在或无权访问"
+            )
+
+        # 获取执行记录
+        executions = service.get_executions_by_app(app_id, limit, offset)
+
+        # 获取统计信息
+        statistics = service.get_execution_statistics(app_id)
+
+        return success(
+            data={
+                "executions": [WorkflowExecution.model_validate(e) for e in executions],
+                "statistics": statistics,
+                "pagination": {
+                    "limit": limit,
+                    "offset": offset,
+                    "total": statistics["total"]
+                }
+            }
+        )
+
+    except Exception as e:
+        logger.error(f"获取工作流执行记录异常: {e}", exc_info=True)
+        return fail(
+            code=BizCode.INTERNAL_ERROR,
+            msg=f"获取工作流执行记录失败: {str(e)}"
+        )
+
+
+@router.get("/workflow/executions/{execution_id}")
+async def get_workflow_execution(
+        execution_id: Annotated[str, Path(description="执行 ID")],
+        db: Annotated[Session, Depends(get_db)],
+        current_user: Annotated[User, Depends(get_current_user)],
+        service: Annotated[WorkflowService, Depends(get_workflow_service)]
+):
+    """获取工作流执行详情
+
+    获取单个工作流执行的详细信息，包括所有节点的执行记录。
+    """
+    try:
+        # 获取执行记录
+        execution = service.get_execution(execution_id)
+
+        if not execution:
+            return fail(
+                code=BizCode.NOT_FOUND,
+                msg="执行记录不存在"
+            )
+
+        # 验证应用是否属于当前工作空间
+        app = db.query(App).filter(
+            App.id == execution.app_id,
+            App.workspace_id == current_user.current_workspace_id,
+            App.is_active.is_(True)
+        ).first()
+
+        if not app:
+            return fail(
+                code=BizCode.NOT_FOUND,
+                msg="无权访问该执行记录"
+            )
+
+        # 获取节点执行记录
+        node_executions = service.node_execution_repo.get_by_execution_id(execution.id)
+
+        return success(
+            data={
+                "execution": WorkflowExecution.model_validate(execution),
+                "node_executions": [
+                    WorkflowNodeExecution.model_validate(ne) for ne in node_executions
+                ]
+            }
+        )
+
+    except Exception as e:
+        logger.error(f"获取工作流执行详情异常: {e}", exc_info=True)
+        return fail(
+            code=BizCode.INTERNAL_ERROR,
+            msg=f"获取工作流执行详情失败: {str(e)}"
+        )
+
+
+# ==================== 工作流执行 ====================
+@router.post("/{app_id}/workflow/run")
+async def run_workflow(
+        app_id: Annotated[uuid.UUID, Path(description="应用 ID")],
+        request: WorkflowExecutionRequest,
+        db: Annotated[Session, Depends(get_db)],
+        current_user: Annotated[User, Depends(get_current_user)],
+        service: Annotated[WorkflowService, Depends(get_workflow_service)]
+):
+    """执行工作流
+
+    执行工作流并返回结果。支持流式和非流式两种模式。
+
+    **非流式模式**：等待工作流执行完成后返回完整结果。
+
+    **流式模式**：实时返回执行过程中的事件（节点开始、节点完成、工作流完成等）。
+    """
+    try:
+        # 验证应用是否存在且属于当前工作空间
+        app = db.query(App).filter(
+            App.id == app_id,
+            App.workspace_id == current_user.current_workspace_id,
+            App.is_active.is_(True)
+        ).first()
+
+        if not app:
+            return fail(
+                code=BizCode.NOT_FOUND,
+                msg="应用不存在或无权访问"
+            )
+
+        # 验证应用类型
+        if app.type != "workflow":
+            return fail(
+                code=BizCode.INVALID_PARAMETER,
+                msg=f"应用类型必须为 workflow，当前为 {app.type}"
+            )
+
+        # 准备输入数据
+        input_data = {
+            "message": request.message or "",
+            "variables": request.variables
+        }
+
+        # 执行工作流
+
+        if request.stream:
+            # 流式执行
+            from fastapi.responses import StreamingResponse
+            import json
+
+            async def event_generator():
+                """生成 SSE 事件
+                
+                SSE 格式：
+                event: <event_type>
+                data: <json_data>
+                
+                支持的事件类型：
+                - workflow_start: 工作流开始
+                - workflow_end: 工作流结束
+                - node_start: 节点开始执行
+                - node_end: 节点执行完成
+                - node_chunk: 中间节点的流式输出
+                - message: 最终消息的流式输出（End 节点及其相邻节点）
+                """
+                try:
+                    async for event in await service.run_workflow(
+                            app_id=app_id,
+                            input_data=input_data,
+                            triggered_by=current_user.id,
+                            conversation_id=uuid.UUID(request.conversation_id) if request.conversation_id else None,
+                            stream=True
+                    ):
+                        # 提取事件类型和数据
+                        event_type = event.get("event", "message")
+                        event_data = event.get("data", {})
+
+                        # 转换为标准 SSE 格式（字符串）
+                        # event: <type>
+                        # data: <json>
+                        sse_message = f"event: {event_type}\ndata: {json.dumps(event_data)}\n\n"
+                        yield sse_message
+
+                except Exception as e:
+                    logger.error(f"流式执行异常: {e}", exc_info=True)
+                    # 发送错误事件
+                    sse_error = f"event: error\ndata: {json.dumps({'error': str(e)})}\n\n"
+                    yield sse_error
+
+            return StreamingResponse(
+                event_generator(),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                    "X-Accel-Buffering": "no"  # 禁用 nginx 缓冲
+                }
+            )
+        else:
+            # 非流式执行
+            result = await service.run_workflow(
+                app_id=app_id,
+                input_data=input_data,
+                triggered_by=current_user.id,
+                conversation_id=uuid.UUID(request.conversation_id) if request.conversation_id else None,
+                stream=False
+            )
+
+            return success(
+                data=WorkflowExecutionResponse(
+                    execution_id=result["execution_id"],
+                    status=result["status"],
+                    output=result.get("output"),
+                    output_data=result.get("output_data"),
+                    error_message=result.get("error_message"),
+                    elapsed_time=result.get("elapsed_time"),
+                    token_usage=result.get("token_usage")
+                ),
+                msg="工作流执行完成"
+            )
+
+    except BusinessException as e:
+        logger.warning(f"执行工作流失败: {e.message}")
+        return fail(code=e.error_code, msg=e.message)
+    except Exception as e:
+        logger.error(f"执行工作流异常: {e}", exc_info=True)
+        return fail(
+            code=BizCode.INTERNAL_ERROR,
+            msg=f"执行工作流失败: {str(e)}"
+        )
+
+
+@router.post("/workflow/executions/{execution_id}/cancel")
+async def cancel_workflow_execution(
+        execution_id: Annotated[str, Path(description="执行 ID")],
+        db: Annotated[Session, Depends(get_db)],
+        current_user: Annotated[User, Depends(get_current_user)],
+        service: Annotated[WorkflowService, Depends(get_workflow_service)]
+):
+    """取消工作流执行
+
+    取消正在运行的工作流执行。
+
+    **注意**：当前版本仅更新状态为 cancelled，实际的执行取消功能待实现。
+    """
+    try:
+        # 获取执行记录
+        execution = service.get_execution(execution_id)
+
+        if not execution:
+            return fail(
+                code=BizCode.NOT_FOUND,
+                msg="执行记录不存在"
+            )
+
+        # 验证应用是否属于当前工作空间
+        app = db.query(App).filter(
+            App.id == execution.app_id,
+            App.workspace_id == current_user.current_workspace_id,
+            App.is_active.is_(True)
+        ).first()
+
+        if not app:
+            return fail(
+                code=BizCode.NOT_FOUND,
+                msg="无权访问该执行记录"
+            )
+
+        # 检查执行状态
+        if execution.status not in ["pending", "running"]:
+            return fail(
+                code=BizCode.INVALID_PARAMETER,
+                msg=f"无法取消状态为 {execution.status} 的执行"
+            )
+
+        # 更新状态为 cancelled
+        service.update_execution_status(execution_id, "cancelled")
+
+        return success(msg="工作流执行已取消")
+
+    except BusinessException as e:
+        logger.warning(f"取消工作流执行失败: {e.message}")
+        return fail(code=e.code, msg=e.message)
+    except Exception as e:
+        logger.error(f"取消工作流执行异常: {e}", exc_info=True)
+        return fail(
+            code=BizCode.INTERNAL_ERROR,
+            msg=f"取消工作流执行失败: {str(e)}"
+        )

api/app/core/__init__.py

@@ -1,4 +0,0 @@
-# -*- coding: UTF-8 -*-
-# Author: Eternity
-# @Email: 1533512157@qq.com
-# @Time : 2026/2/9 16:24

api/app/core/agent/agent_middleware.py

@@ -1,162 +0,0 @@
-"""Agent Middleware - 动态技能过滤"""
-import uuid
-from typing import List, Dict, Any, Optional
-from langchain_core.runnables import RunnablePassthrough
-
-from app.services.skill_service import SkillService
-from app.repositories.skill_repository import SkillRepository
-
-
-class AgentMiddleware:
-    """Agent 中间件 - 用于动态过滤和加载技能"""
-    
-    def __init__(self, skills: Optional[dict] = None):
-        """
-        初始化中间件
-        
-        Args:
-            skills: 技能配置字典 {"enabled": bool, "all_skills": bool, "skill_ids": [...]}
-        """
-        self.skills = skills or {}
-        self.enabled = self.skills.get('enabled', False)
-        self.all_skills = self.skills.get('all_skills', False)
-        self.skill_ids = self.skills.get('skill_ids', [])
-
-    @staticmethod
-    def filter_tools(
-        tools: List, 
-        message: str = "", 
-        skill_configs: Dict[str, Any] = None,
-        tool_to_skill_map: Dict[str, str] = None
-    ) -> tuple[List, List[str]]:
-        """
-        根据消息内容和技能配置动态过滤工具
-        
-        Args:
-            tools: 所有可用工具列表
-            message: 用户消息（可用于智能过滤）
-            skill_configs: 技能配置字典 {skill_id: {"keywords": [...], "enabled": True, "prompt": "..."}}
-            tool_to_skill_map: 工具到技能的映射 {tool_name: skill_id}
-        
-        Returns:
-            (过滤后的工具列表, 激活的技能ID列表)
-        """
-        if not tools:
-            return [], []
-        
-        # 如果没有技能配置，返回所有工具
-        if not skill_configs:
-            return tools, []
-        
-        # 基于关键词匹配激活技能
-        activated_skill_ids = []
-        message_lower = message.lower()
-        
-        for skill_id, config in skill_configs.items():
-            if not config.get('enabled', True):
-                continue
-            
-            keywords = config.get('keywords', [])
-            # 如果没有关键词限制，或消息包含关键词，则激活该技能
-            if not keywords or any(kw.lower() in message_lower for kw in keywords):
-                activated_skill_ids.append(skill_id)
-        
-        # 如果没有工具映射关系，返回所有工具
-        if not tool_to_skill_map:
-            return tools, activated_skill_ids
-        
-        # 根据激活的技能过滤工具
-        filtered_tools = []
-        for tool in tools:
-            tool_name = getattr(tool, 'name', str(id(tool)))
-            # 如果工具不属于任何skill（base_tools），或者工具所属的skill被激活，则保留
-            if tool_name not in tool_to_skill_map or tool_to_skill_map[tool_name] in activated_skill_ids:
-                filtered_tools.append(tool)
-        
-        return filtered_tools, activated_skill_ids
-    
-    def load_skill_tools(self, db, tenant_id: uuid.UUID, base_tools: List = None) -> tuple[List, Dict[str, Any], Dict[str, str]]:
-        """
-        加载技能关联的工具
-        
-        Args:
-            db: 数据库会话
-            tenant_id: 租户id
-            base_tools: 基础工具列表
-        
-        Returns:
-            (工具列表, 技能配置字典, 工具到技能的映射 {tool_name: skill_id})
-        """
-
-        tools_dict = {}
-        tool_to_skill_map = {}  # 工具名称到技能ID的映射
-        
-        if base_tools:
-            for tool in base_tools:
-                tool_name = getattr(tool, 'name', str(id(tool)))
-                tools_dict[tool_name] = tool
-                # base_tools 不属于任何 skill，不加入映射
-
-        skill_configs = {}
-        skill_ids_to_load = []
-        
-        # 如果启用技能且 all_skills 为 True，加载租户下所有激活的技能
-        if self.enabled and self.all_skills:
-            skills, _ = SkillRepository.list_skills(db, tenant_id, is_active=True, page=1, pagesize=1000)
-            skill_ids_to_load = [str(skill.id) for skill in skills]
-        elif self.enabled and self.skill_ids:
-            skill_ids_to_load = self.skill_ids
-        
-        if skill_ids_to_load:
-            for skill_id in skill_ids_to_load:
-                try:
-                    skill = SkillRepository.get_by_id(db, uuid.UUID(skill_id), tenant_id)
-                    if skill and skill.is_active:
-                        # 保存技能配置（包含prompt）
-                        config = skill.config or {}
-                        config['prompt'] = skill.prompt
-                        config['name'] = skill.name
-                        skill_configs[skill_id] = config
-                except Exception:
-                    continue
-            
-            # 加载技能工具并获取映射关系
-            skill_tools, skill_tool_map = SkillService.load_skill_tools(db, skill_ids_to_load, tenant_id)
-            
-            # 只添加不冲突的 skill_tools
-            for tool in skill_tools:
-                tool_name = getattr(tool, 'name', str(id(tool)))
-                if tool_name not in tools_dict:
-                    tools_dict[tool_name] = tool
-                    # 复制映射关系
-                    if tool_name in skill_tool_map:
-                        tool_to_skill_map[tool_name] = skill_tool_map[tool_name]
-        
-        return list(tools_dict.values()), skill_configs, tool_to_skill_map
-
-    @staticmethod
-    def get_active_prompts(activated_skill_ids: List[str], skill_configs: Dict[str, Any]) -> str:
-        """
-        根据激活的技能ID获取对应的提示词
-        
-        Args:
-            activated_skill_ids: 被激活的技能ID列表
-            skill_configs: 技能配置字典
-        
-        Returns:
-            合并后的提示词
-        """
-        prompts = []
-        for skill_id in activated_skill_ids:
-            config = skill_configs.get(skill_id, {})
-            prompt = config.get('prompt')
-            name = config.get('name', 'Skill')
-            if prompt:
-                prompts.append(f"# {name}\n{prompt}")
-        
-        return "\n\n".join(prompts) if prompts else ""
-
-    @staticmethod
-    def create_runnable():
-        """创建可运行的中间件"""
-        return RunnablePassthrough()

api/app/core/agent/langchain_agent.py

@@ -37,9 +37,7 @@ class LangChainAgent:
         max_tokens: int = 2000,
         system_prompt: Optional[str] = None,
         tools: Optional[Sequence[BaseTool]] = None,
-        streaming: bool = False,
-        max_iterations: Optional[int] = None,  # 最大迭代次数（None 表示自动计算）
-        max_tool_consecutive_calls: int = 3  # 单个工具最大连续调用次数
+        streaming: bool = False
     ):
         """初始化 LangChain Agent
 
@@ -52,36 +50,13 @@ class LangChainAgent:
             max_tokens: 最大 token 数
             system_prompt: 系统提示词
             tools: 工具列表（可选，框架自动走 ReAct 循环）
-            streaming: 是否启用流式输出
-            max_iterations: 最大迭代次数（None 表示自动计算：基础 5 次 + 每个工具 2 次）
-            max_tool_consecutive_calls: 单个工具最大连续调用次数（默认 3 次）
+            streaming: 是否启用流式输出（默认 True）
         """
         self.model_name = model_name
         self.provider = provider
+        self.system_prompt = system_prompt or "你是一个专业的AI助手"
         self.tools = tools or []
         self.streaming = streaming
-        self.max_tool_consecutive_calls = max_tool_consecutive_calls
-        
-        # 工具调用计数器：记录每个工具的连续调用次数
-        self.tool_call_counter: Dict[str, int] = {}
-        self.last_tool_called: Optional[str] = None
-        
-        # 根据工具数量动态调整最大迭代次数
-        # 基础值 + 每个工具额外的调用机会
-        if max_iterations is None:
-            # 自动计算：基础 5 次 + 每个工具 2 次额外机会
-            self.max_iterations = 5 + len(self.tools) * 2
-        else:
-            self.max_iterations = max_iterations
-        
-        self.system_prompt = system_prompt or "你是一个专业的AI助手"
-        
-        logger.debug(
-            f"Agent 迭代次数配置: max_iterations={self.max_iterations}, "
-            f"tool_count={len(self.tools)}, "
-            f"max_tool_consecutive_calls={self.max_tool_consecutive_calls}, "
-            f"auto_calculated={max_iterations is None}"
-        )
 
         # 创建 RedBearLLM（支持多提供商）
         model_config = RedBearModelConfig(
@@ -105,14 +80,11 @@ class LangChainAgent:
         if streaming and hasattr(self._underlying_llm, 'streaming'):
             self._underlying_llm.streaming = True
 
-        # 包装工具以跟踪连续调用次数
-        wrapped_tools = self._wrap_tools_with_tracking(self.tools) if self.tools else None
-
         # 使用 create_agent 创建 agent graph（LangChain 1.x 标准方式）
         # 无论是否有工具，都使用 agent 统一处理
         self.agent = create_agent(
             model=self.llm,
-            tools=wrapped_tools,
+            tools=self.tools if self.tools else None,
             system_prompt=self.system_prompt
         )
 
@@ -124,91 +96,17 @@ class LangChainAgent:
                 "has_api_base": bool(api_base),
                 "temperature": temperature,
                 "streaming": streaming,
-                "max_iterations": self.max_iterations,
-                "max_tool_consecutive_calls": self.max_tool_consecutive_calls,
                 "tool_count": len(self.tools),
                 "tool_names": [tool.name for tool in self.tools] if self.tools else [],
                 # "tool_count": len(self.tools)
             }
         )
 
-    def _wrap_tools_with_tracking(self, tools: Sequence[BaseTool]) -> List[BaseTool]:
-        """包装工具以跟踪连续调用次数
-        
-        Args:
-            tools: 原始工具列表
-            
-        Returns:
-            List[BaseTool]: 包装后的工具列表
-        """
-        from langchain_core.tools import StructuredTool
-        from functools import wraps
-        
-        wrapped_tools = []
-        
-        for original_tool in tools:
-            tool_name = original_tool.name
-            original_func = original_tool.func if hasattr(original_tool, 'func') else None
-            
-            if not original_func:
-                # 如果无法获取原始函数，直接使用原工具
-                wrapped_tools.append(original_tool)
-                continue
-            
-            # 创建包装函数
-            def make_wrapped_func(tool_name, original_func):
-                """创建包装函数的工厂函数，避免闭包问题"""
-                @wraps(original_func)
-                def wrapped_func(*args, **kwargs):
-                    """包装后的工具函数，跟踪连续调用次数"""
-                    # 检查是否是连续调用同一个工具
-                    if self.last_tool_called == tool_name:
-                        self.tool_call_counter[tool_name] = self.tool_call_counter.get(tool_name, 0) + 1
-                    else:
-                        # 切换到新工具，重置计数器
-                        self.tool_call_counter[tool_name] = 1
-                        self.last_tool_called = tool_name
-                    
-                    current_count = self.tool_call_counter[tool_name]
-                    
-                    logger.debug(
-                        f"工具调用: {tool_name}, 连续调用次数: {current_count}/{self.max_tool_consecutive_calls}"
-                    )
-                    
-                    # 检查是否超过最大连续调用次数
-                    if current_count > self.max_tool_consecutive_calls:
-                        logger.warning(
-                            f"工具 '{tool_name}' 连续调用次数已达上限 ({self.max_tool_consecutive_calls})，"
-                            f"返回提示信息"
-                        )
-                        return (
-                            f"工具 '{tool_name}' 已连续调用 {self.max_tool_consecutive_calls} 次，"
-                            f"未找到有效结果。请尝试其他方法或直接回答用户的问题。"
-                        )
-                    
-                    # 调用原始工具函数
-                    return original_func(*args, **kwargs)
-                
-                return wrapped_func
-            
-            # 使用 StructuredTool 创建新工具
-            wrapped_tool = StructuredTool(
-                name=original_tool.name,
-                description=original_tool.description,
-                func=make_wrapped_func(tool_name, original_func),
-                args_schema=original_tool.args_schema if hasattr(original_tool, 'args_schema') else None
-            )
-            
-            wrapped_tools.append(wrapped_tool)
-        
-        return wrapped_tools
-
     def _prepare_messages(
         self,
         message: str,
         history: Optional[List[Dict[str, str]]] = None,
-        context: Optional[str] = None,
-        files: Optional[List[Dict[str, Any]]] = None
+        context: Optional[str] = None
     ) -> List[BaseMessage]:
         """准备消息列表
 
@@ -216,7 +114,6 @@ class LangChainAgent:
             message: 用户消息
             history: 历史消息列表
             context: 上下文信息
-            files: 多模态文件内容列表（已处理）
 
         Returns:
             List[BaseMessage]: 消息列表
@@ -239,46 +136,8 @@ class LangChainAgent:
         if context:
             user_content = f"参考信息：\n{context}\n\n用户问题：\n{user_content}"
 
-        # 构建用户消息（支持多模态）
-        if files and len(files) > 0:
-            content_parts = self._build_multimodal_content(user_content, files)
-            messages.append(HumanMessage(content=content_parts))
-        else:
-            # 纯文本消息
-            messages.append(HumanMessage(content=user_content))
-
+        messages.append(HumanMessage(content=user_content))
         return messages
-    
-    def _build_multimodal_content(self, text: str, files: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """
-        构建多模态消息内容
-        
-        Args:
-            text: 文本内容
-            files: 文件列表（已由 MultimodalService 处理为对应 provider 的格式）
-            
-        Returns:
-            List[Dict]: 消息内容列表
-        """
-        # 根据 provider 使用不同的文本格式
-        if self.provider.lower() in ["bedrock", "anthropic"]:
-            # Anthropic/Bedrock: {"type": "text", "text": "..."}
-            content_parts = [{"type": "text", "text": text}]
-        else:
-            # 通义千问等: {"text": "..."}
-            content_parts = [{"text": text}]
-        
-        # 添加文件内容
-        # MultimodalService 已经根据 provider 返回了正确格式，直接使用
-        content_parts.extend(files)
-        
-        logger.debug(
-            f"构建多模态消息: provider={self.provider}, "
-            f"parts={len(content_parts)}, "
-            f"files={len(files)}"
-        )
-        
-        return content_parts
 
     async def chat(
             self,
@@ -289,8 +148,7 @@ class LangChainAgent:
             config_id: Optional[str] = None,  # 添加这个参数
             storage_type: Optional[str] = None,
             user_rag_memory_id: Optional[str] = None,
-            memory_flag: Optional[bool] = True,
-            files: Optional[List[Dict[str, Any]]] = None  # 新增：多模态文件
+            memory_flag: Optional[bool] = True
     ) -> Dict[str, Any]:
         """执行对话
 
@@ -325,8 +183,8 @@ class LangChainAgent:
         logger.info(f'写入类型{storage_type,str(end_user_id), message, str(user_rag_memory_id)}')
         print(f'写入类型{storage_type,str(end_user_id), message, str(user_rag_memory_id)}')
         try:
-            # 准备消息列表（支持多模态）
-            messages = self._prepare_messages(message, history, context, files)
+            # 准备消息列表
+            messages = self._prepare_messages(message, history, context)
 
             logger.debug(
                 "准备调用 LangChain Agent",
@@ -334,81 +192,23 @@ class LangChainAgent:
                     "has_context": bool(context),
                     "has_history": bool(history),
                     "has_tools": bool(self.tools),
-                    "has_files": bool(files),
-                    "message_count": len(messages),
-                    "max_iterations": self.max_iterations
+                    "message_count": len(messages)
                 }
             )
 
             # 统一使用 agent.invoke 调用
-            # 通过 recursion_limit 限制最大迭代次数，防止工具调用死循环
-            try:
-                result = await self.agent.ainvoke(
-                    {"messages": messages},
-                    config={"recursion_limit": self.max_iterations}
-                )
-            except RecursionError as e:
-                logger.warning(
-                    f"Agent 达到最大迭代次数限制 ({self.max_iterations})，可能存在工具调用循环",
-                    extra={"error": str(e)}
-                )
-                # 返回一个友好的错误提示
-                return {
-                    "content": f"抱歉，我在处理您的请求时遇到了问题。已达到最大处理步骤限制（{self.max_iterations}次）。请尝试简化您的问题或稍后再试。",
-                    "model": self.model_name,
-                    "elapsed_time": time.time() - start_time,
-                    "usage": {
-                        "prompt_tokens": 0,
-                        "completion_tokens": 0,
-                        "total_tokens": 0
-                    }
-                }
+            result = await self.agent.ainvoke({"messages": messages})
 
             # 获取最后的 AI 消息
             output_messages = result.get("messages", [])
             content = ""
-            
-            logger.debug(f"输出消息数量: {len(output_messages)}")
             total_tokens = 0
             for msg in reversed(output_messages):
                 if isinstance(msg, AIMessage):
-                    logger.debug(f"找到 AI 消息，content 类型: {type(msg.content)}")
-                    logger.debug(f"AI 消息内容: {msg.content}")
-                    
-                    # 处理多模态响应：content 可能是字符串或列表
-                    if isinstance(msg.content, str):
-                        content = msg.content
-                        logger.debug(f"提取字符串内容，长度: {len(content)}")
-                    elif isinstance(msg.content, list):
-                        # 多模态响应：提取文本部分
-                        logger.debug(f"多模态响应，列表长度: {len(msg.content)}")
-                        text_parts = []
-                        for item in msg.content:
-                            logger.debug(f"处理项: {item}")
-                            if isinstance(item, dict):
-                                # 通义千问格式: {"text": "..."}
-                                if "text" in item:
-                                    text = item.get("text", "")
-                                    text_parts.append(text)
-                                    logger.debug(f"提取文本: {text[:100]}...")
-                                # OpenAI 格式: {"type": "text", "text": "..."}
-                                elif item.get("type") == "text":
-                                    text = item.get("text", "")
-                                    text_parts.append(text)
-                                    logger.debug(f"提取文本: {text[:100]}...")
-                            elif isinstance(item, str):
-                                text_parts.append(item)
-                                logger.debug(f"提取字符串: {item[:100]}...")
-                        content = "".join(text_parts)
-                        logger.debug(f"合并后内容长度: {len(content)}")
-                    else:
-                        content = str(msg.content)
-                        logger.debug(f"转换为字符串: {content[:100]}...")
+                    content = msg.content
                     response_meta = msg.response_metadata if hasattr(msg, 'response_metadata') else None
                     total_tokens = response_meta.get("token_usage", {}).get("total_tokens", 0) if response_meta else 0
                     break
-            
-            logger.info(f"最终提取的内容长度: {len(content)}")
 
             elapsed_time = time.time() - start_time
             if memory_flag:
@@ -447,8 +247,7 @@ class LangChainAgent:
         config_id: Optional[str] = None,
         storage_type:Optional[str] = None,
         user_rag_memory_id:Optional[str] = None,
-        memory_flag: Optional[bool] = True,
-        files: Optional[List[Dict[str, Any]]] = None  # 新增：多模态文件
+        memory_flag: Optional[bool] = True
     ) -> AsyncGenerator[str, None]:
         """执行流式对话
 
@@ -485,11 +284,11 @@ class LangChainAgent:
 
             # 注意：不在这里写入用户消息，等 AI 回复后一起写入
         try:
-            # 准备消息列表（支持多模态）
-            messages = self._prepare_messages(message, history, context, files)
+            # 准备消息列表
+            messages = self._prepare_messages(message, history, context)
 
             logger.debug(
-                f"准备流式调用，has_tools={bool(self.tools)}, has_files={bool(files)}, message_count={len(messages)}"
+                f"准备流式调用，has_tools={bool(self.tools)}, message_count={len(messages)}"
             )
 
             chunk_count = 0
@@ -501,8 +300,7 @@ class LangChainAgent:
             try:
                 async for event in self.agent.astream_events(
                     {"messages": messages},
-                    version="v2",
-                    config={"recursion_limit": self.max_iterations}
+                    version="v2"
                 ):
                     chunk_count += 1
                     kind = event.get("event")
@@ -511,70 +309,20 @@ class LangChainAgent:
                     if kind == "on_chat_model_stream":
                         # LLM 流式输出
                         chunk = event.get("data", {}).get("chunk")
-                        if chunk and hasattr(chunk, "content"):
-                            # 处理多模态响应：content 可能是字符串或列表
-                            chunk_content = chunk.content
-                            if isinstance(chunk_content, str) and chunk_content:
-                                full_content += chunk_content
-                                yield chunk_content
-                                yielded_content = True
-                            elif isinstance(chunk_content, list):
-                                # 多模态响应：提取文本部分
-                                for item in chunk_content:
-                                    if isinstance(item, dict):
-                                        # 通义千问格式: {"text": "..."}
-                                        if "text" in item:
-                                            text = item.get("text", "")
-                                            if text:
-                                                full_content += text
-                                                yield text
-                                                yielded_content = True
-                                        # OpenAI 格式: {"type": "text", "text": "..."}
-                                        elif item.get("type") == "text":
-                                            text = item.get("text", "")
-                                            if text:
-                                                full_content += text
-                                                yield text
-                                                yielded_content = True
-                                    elif isinstance(item, str):
-                                        full_content += item
-                                        yield item
-                                        yielded_content = True
+                        full_content+=chunk.content
+                        if chunk and hasattr(chunk, "content") and chunk.content:
+                            yield chunk.content
+                            yielded_content = True
                     
                     elif kind == "on_llm_stream":
                         # 另一种 LLM 流式事件
                         chunk = event.get("data", {}).get("chunk")
                         if chunk:
-                            if hasattr(chunk, "content"):
-                                chunk_content = chunk.content
-                                if isinstance(chunk_content, str) and chunk_content:
-                                    full_content += chunk_content
-                                    yield chunk_content
-                                    yielded_content = True
-                                elif isinstance(chunk_content, list):
-                                    # 多模态响应：提取文本部分
-                                    for item in chunk_content:
-                                        if isinstance(item, dict):
-                                            # 通义千问格式: {"text": "..."}
-                                            if "text" in item:
-                                                text = item.get("text", "")
-                                                if text:
-                                                    full_content += text
-                                                    yield text
-                                                    yielded_content = True
-                                            # OpenAI 格式: {"type": "text", "text": "..."}
-                                            elif item.get("type") == "text":
-                                                text = item.get("text", "")
-                                                if text:
-                                                    full_content += text
-                                                    yield text
-                                                    yielded_content = True
-                                        elif isinstance(item, str):
-                                            full_content += item
-                                            yield item
-                                            yielded_content = True
+                            if hasattr(chunk, "content") and chunk.content:
+                                full_content+=chunk.content
+                                yield chunk.content
+                                yielded_content = True
                             elif isinstance(chunk, str):
-                                full_content += chunk
                                 yield chunk
                                 yielded_content = True
                     

api/app/core/config.py

@@ -193,29 +193,16 @@ class Settings:
     CELERY_BROKER: int = int(os.getenv("CELERY_BROKER", "1"))
     CELERY_BACKEND: int = int(os.getenv("CELERY_BACKEND", "2"))
 
-    # SMTP Email Configuration
-    SMTP_SERVER: str = os.getenv("SMTP_SERVER", "smtp.gmail.com")
-    SMTP_PORT: int = int(os.getenv("SMTP_PORT", "587"))
-    SMTP_USER: str = os.getenv("SMTP_USER", "")
-    SMTP_PASSWORD: str = os.getenv("SMTP_PASSWORD", "")
-
     REFLECTION_INTERVAL_SECONDS: float = float(os.getenv("REFLECTION_INTERVAL_SECONDS", "300"))
     HEALTH_CHECK_SECONDS: float = float(os.getenv("HEALTH_CHECK_SECONDS", "600"))
     MEMORY_INCREMENT_INTERVAL_HOURS: float = float(os.getenv("MEMORY_INCREMENT_INTERVAL_HOURS", "24"))
+    DEFAULT_WORKSPACE_ID: Optional[str] = os.getenv("DEFAULT_WORKSPACE_ID", None)
     REFLECTION_INTERVAL_TIME: Optional[str] = int(os.getenv("REFLECTION_INTERVAL_TIME", 30))
 
     # Memory Cache Regeneration Configuration
     MEMORY_CACHE_REGENERATION_HOURS: int = int(os.getenv("MEMORY_CACHE_REGENERATION_HOURS", "24"))
 
-    # Periodic Task Schedule Configuration
-    # workspace_reflection: 每隔多少秒执行一次
-    WORKSPACE_REFLECTION_INTERVAL_SECONDS: int = int(os.getenv("WORKSPACE_REFLECTION_INTERVAL_SECONDS", "30"))
-    # forgetting_cycle: 每隔多少小时执行一次
-    FORGETTING_CYCLE_INTERVAL_HOURS: int = int(os.getenv("FORGETTING_CYCLE_INTERVAL_HOURS", "24"))
-    # implicit_emotions_update: 每天几点执行（小时，0-23）
-    IMPLICIT_EMOTIONS_UPDATE_HOUR: int = int(os.getenv("IMPLICIT_EMOTIONS_UPDATE_HOUR", "2"))
-    # implicit_emotions_update: 每天几分执行（分钟，0-59）
-    IMPLICIT_EMOTIONS_UPDATE_MINUTE: int = int(os.getenv("IMPLICIT_EMOTIONS_UPDATE_MINUTE", "0"))    # Memory Module Configuration (internal)
+    # Memory Module Configuration (internal)
     MEMORY_OUTPUT_DIR: str = os.getenv("MEMORY_OUTPUT_DIR", "logs/memory-output")
     MEMORY_CONFIG_DIR: str = os.getenv("MEMORY_CONFIG_DIR", "app/core/memory")
 
@@ -228,34 +215,9 @@ class Settings:
     # official environment system version
     SYSTEM_VERSION: str = os.getenv("SYSTEM_VERSION", "v0.2.1")
 
-    # model square loading
-    LOAD_MODEL: bool = os.getenv("LOAD_MODEL", "false").lower() == "true"
-
     # workflow config
     WORKFLOW_NODE_TIMEOUT: int = int(os.getenv("WORKFLOW_NODE_TIMEOUT", 600))
 
-    # ========================================================================
-    # General Ontology Type Configuration
-    # ========================================================================
-    # 通用本体文件路径列表（逗号分隔）
-    GENERAL_ONTOLOGY_FILES: str = os.getenv("GENERAL_ONTOLOGY_FILES", "General_purpose_entity.ttl")
-    
-    # 是否启用通用本体类型功能
-    ENABLE_GENERAL_ONTOLOGY_TYPES: bool = os.getenv("ENABLE_GENERAL_ONTOLOGY_TYPES", "true").lower() == "true"
-    
-    # Prompt 中最大类型数量
-    MAX_ONTOLOGY_TYPES_IN_PROMPT: int = int(os.getenv("MAX_ONTOLOGY_TYPES_IN_PROMPT", "50"))
-    
-    # 核心通用类型列表（逗号分隔）
-    CORE_GENERAL_TYPES: str = os.getenv(
-        "CORE_GENERAL_TYPES",
-        "Person,Organization,Company,GovernmentAgency,Place,Location,City,Country,Building,"
-        "Event,SportsEvent,SocialEvent,Work,Book,Film,Software,Concept,TopicalConcept,AcademicSubject"
-    )
-    
-    # 实验模式开关（允许通过 API 动态切换本体配置）
-    ONTOLOGY_EXPERIMENT_MODE: bool = os.getenv("ONTOLOGY_EXPERIMENT_MODE", "true").lower() == "true"
-
     def get_memory_output_path(self, filename: str = "") -> str:
         """
         Get the full path for memory module output files.

api/app/core/error_codes.py

@@ -46,7 +46,6 @@ class BizCode(IntEnum):
     RESOURCE_ALREADY_EXISTS = 5002
     VERSION_ALREADY_EXISTS = 5003
     STATE_CONFLICT = 5004
-    RESOURCE_IN_USE = 5005
 
     # 应用发布（6xxx）
     PUBLISH_FAILED = 6001
@@ -126,7 +125,6 @@ HTTP_MAPPING = {
     BizCode.RESOURCE_ALREADY_EXISTS: 409,
     BizCode.VERSION_ALREADY_EXISTS: 409,
     BizCode.STATE_CONFLICT: 409,
-    BizCode.RESOURCE_IN_USE: 409,
     BizCode.PUBLISH_FAILED: 500,
     BizCode.NO_DRAFT_TO_PUBLISH: 400,
     BizCode.ROLLBACK_TARGET_NOT_FOUND: 400,

api/app/core/language_utils.py

@@ -1,82 +0,0 @@
-# -*- coding: utf-8 -*-
-"""语言处理工具模块
-
-本模块提供集中化的语言校验和处理功能，确保整个应用中语言参数的一致性。
-
-Functions:
-    validate_language: 校验语言参数，确保其为有效值
-    get_language_from_header: 从请求头获取并校验语言参数
-"""
-
-from typing import Optional
-
-from app.core.logging_config import get_logger
-
-logger = get_logger(__name__)
-
-# 支持的语言列表
-SUPPORTED_LANGUAGES = {"zh", "en"}
-
-# 默认回退语言
-DEFAULT_LANGUAGE = "zh"
-
-
-def validate_language(language: Optional[str]) -> str:
-    """
-    校验语言参数，确保其为有效值。
-    
-    Args:
-        language: 待校验的语言代码，可以是 None、"zh"、"en" 或其他值
-        
-    Returns:
-        有效的语言代码（"zh" 或 "en"）
-        
-    Examples:
-        >>> validate_language("zh")
-        'zh'
-        >>> validate_language("en")
-        'en'
-        >>> validate_language("EN")  # 大小写不敏感
-        'en'
-        >>> validate_language(None)  # None 回退到默认值
-        'zh'
-        >>> validate_language("fr")  # 不支持的语言回退到默认值
-        'zh'
-    """
-    if language is None:
-        return DEFAULT_LANGUAGE
-    
-    # 标准化：转小写并去除空白
-    lang = str(language).lower().strip()
-    
-    if lang in SUPPORTED_LANGUAGES:
-        return lang
-    
-    logger.warning(
-        f"无效的语言参数 '{language}'，已回退到默认值 '{DEFAULT_LANGUAGE}'。"
-        f"支持的语言: {SUPPORTED_LANGUAGES}"
-    )
-    return DEFAULT_LANGUAGE
-
-
-def get_language_from_header(language_type: Optional[str]) -> str:
-    """
-    从请求头获取并校验语言参数。
-    
-    这是一个便捷函数，用于在 controller 层统一处理 X-Language-Type Header。
-    
-    Args:
-        language_type: 从 X-Language-Type Header 获取的语言值
-        
-    Returns:
-        有效的语言代码（"zh" 或 "en"）
-        
-    Examples:
-        >>> get_language_from_header(None)  # Header 未传递
-        'zh'
-        >>> get_language_from_header("en")
-        'en'
-        >>> get_language_from_header("invalid")  # 无效值回退
-        'zh'
-    """
-    return validate_language(language_type)

api/app/core/logging_config.py

@@ -38,56 +38,6 @@ class SensitiveDataLoggingFilter(logging.Filter):
         return True
 
 
-class Neo4jSuccessNotificationFilter(logging.Filter):
-    """Neo4j 日志过滤器：过滤成功/信息性状态的通知，保留真正的警告和错误
-    
-    Neo4j 驱动会以 WARNING 级别记录所有数据库通知，包括成功的操作。
-    这个过滤器会过滤掉以下 GQL 状态码的通知，只保留真正的警告和错误：
-      - 00000: 成功完成 (successful completion)
-      - 00N00: 无数据 (no data)
-      - 00NA0: 无数据，信息性通知 (no data, informational notification)
-    
-    使用正则表达式进行更严格的匹配，避免误过滤无关的警告。
-    """
-    
-    import re
-    
-    # 编译正则表达式以提高性能
-    # 匹配所有"成功/信息性"的 GQL 状态码：
-    # 00000 = 成功完成, 00N00 = 无数据, 00NA0 = 无数据信息性通知
-    GQL_STATUS_PATTERN = re.compile(r"gql_status=['\"](00000|00N00|00NA0)['\"]")
-    
-    # 匹配 status_description 中的成功完成或信息性通知消息
-    SUCCESS_DESC_PATTERN = re.compile(r"status_description=['\"]note:\s*(successful\s+completion|no\s+data)['\"]", re.IGNORECASE)
-    
-    def filter(self, record: logging.LogRecord) -> bool:
-        """
-        过滤 Neo4j 成功通知
-        
-        Args:
-            record: 日志记录
-            
-        Returns:
-            True表示允许记录，False表示拒绝（过滤掉）
-        """
-        # 只处理 INFO 和 WARNING 级别的日志
-        # Neo4j 驱动对 severity='INFORMATION' 的通知使用 INFO 级别，
-        # 对 severity='WARNING' 的通知使用 WARNING 级别
-        if record.levelno not in (logging.INFO, logging.WARNING):
-            return True
-        
-        # 检查是否是 Neo4j 的成功通知
-        message = str(record.msg)
-        
-        # 使用正则表达式进行更严格的匹配
-        # 这样可以避免误过滤包含这些子字符串但不是 Neo4j 通知的日志
-        if self.GQL_STATUS_PATTERN.search(message) or self.SUCCESS_DESC_PATTERN.search(message):
-            return False  # 过滤掉这条日志
-        
-        # 保留其他所有日志（包括真正的警告和错误）
-        return True
-
-
 class LoggingConfig:
     """全局日志配置类"""
     
@@ -115,22 +65,6 @@ class LoggingConfig:
         # 清除现有处理器
         root_logger.handlers.clear()
         
-        # Neo4j 通知过滤器 - 挂在 handler 上确保所有传播上来的日志都能被过滤
-        neo4j_filter = Neo4jSuccessNotificationFilter()
-        
-        # 抑制 Neo4j 通知日志
-        # Neo4j 驱动内部会给 neo4j.notifications logger 配置自己的 handler，
-        # 导致日志绕过根 logger 的 filter 直接输出。
-        # 多管齐下确保过滤生效：
-        # 1. 设置 neo4j.notifications 级别为 WARNING（过滤 INFO 级别的 00NA0 通知）
-        # 2. 在所有 neo4j logger 上添加 filter（过滤 WARNING 级别的成功通知）
-        # 3. 在根 handler 上也添加 filter（兜底）
-        neo4j_notifications_logger = logging.getLogger("neo4j.notifications")
-        neo4j_notifications_logger.setLevel(logging.WARNING)
-        for neo4j_logger_name in ["neo4j", "neo4j.io", "neo4j.pool", "neo4j.notifications"]:
-            neo4j_logger = logging.getLogger(neo4j_logger_name)
-            neo4j_logger.addFilter(neo4j_filter)
-        
         # 创建格式化器
         formatter = logging.Formatter(
             fmt=settings.LOG_FORMAT,
@@ -146,7 +80,6 @@ class LoggingConfig:
             console_handler.setFormatter(formatter)
             console_handler.setLevel(getattr(logging, settings.LOG_LEVEL.upper()))
             console_handler.addFilter(sensitive_filter)
-            console_handler.addFilter(neo4j_filter)
             root_logger.addHandler(console_handler)
         
         # 文件处理器（带轮转）
@@ -160,7 +93,6 @@ class LoggingConfig:
             file_handler.setFormatter(formatter)
             file_handler.setLevel(getattr(logging, settings.LOG_LEVEL.upper()))
             file_handler.addFilter(sensitive_filter)
-            file_handler.addFilter(neo4j_filter)
             root_logger.addHandler(file_handler)
         
         cls._initialized = True

api/app/core/memory/agent/langgraph_graph/nodes/write_nodes.py

@@ -10,7 +10,7 @@ async def write_node(state: WriteState) -> WriteState:
         Write data to the database/file system.
 
         Args:
-            state: WriteState containing messages, end_user_id, memory_config, and language
+            state: WriteState containing messages, end_user_id, and memory_config
 
         Returns:
             dict: Contains 'write_result' with status and data fields
@@ -18,7 +18,6 @@ async def write_node(state: WriteState) -> WriteState:
     messages = state.get('messages', [])
     end_user_id = state.get('end_user_id', '')
     memory_config = state.get('memory_config', '')
-    language = state.get('language', 'zh')  # 默认中文
 
     # Convert LangChain messages to structured format expected by write()
     structured_messages = []
@@ -36,7 +35,6 @@ async def write_node(state: WriteState) -> WriteState:
             messages=structured_messages,
             end_user_id=end_user_id,
             memory_config=memory_config,
-            language=language,
         )
         logger.info(f"Write completed successfully! Config: {memory_config.config_name}")
 

api/app/core/memory/agent/langgraph_graph/write_graph.py

@@ -1,3 +1,4 @@
+
 import asyncio
 import json
 import sys
@@ -19,8 +20,6 @@ logger = get_agent_logger(__name__)
 
 if sys.platform.startswith("win"):
     asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
-
-
 @asynccontextmanager
 async def make_write_graph():
     """

api/app/core/memory/agent/utils/llm_tools.py

@@ -18,7 +18,6 @@ class WriteState(TypedDict):
     memory_config: object
     write_result: dict
     data: str
-    language: str  # 语言类型 ("zh" 中文, "en" 英文)
 
 class ReadState(TypedDict):
     """

api/app/core/memory/agent/utils/write_tools.py

@@ -34,17 +34,17 @@ async def write(
     memory_config: MemoryConfig,
     messages: list,
     ref_id: str = "wyl20251027",
-    language: str = "zh",
 ) -> None:
     """
     Execute the complete knowledge extraction pipeline.
 
     Args:
+        user_id: User identifier
+        apply_id: Application identifier
         end_user_id: Group identifier
         memory_config: MemoryConfig object containing all configuration
         messages: Structured message list [{"role": "user", "content": "..."}, ...]
         ref_id: Reference ID, defaults to "wyl20251027"
-        language: 语言类型 ("zh" 中文, "en" 英文)，默认中文
     """
     # Extract config values
     embedding_model_id = str(memory_config.embedding_model_id)
@@ -94,39 +94,12 @@ async def write(
     from app.core.memory.utils.config.config_utils import get_pipeline_config
     pipeline_config = get_pipeline_config(memory_config)
 
-    # Fetch ontology types if scene_id is configured
-    ontology_types = None
-    if memory_config.scene_id:
-        try:
-            from app.core.memory.ontology_services.ontology_type_loader import load_ontology_types_for_scene
-            
-            with get_db_context() as db:
-                ontology_types = load_ontology_types_for_scene(
-                    scene_id=memory_config.scene_id,
-                    workspace_id=memory_config.workspace_id,
-                    db=db
-                )
-                
-                if ontology_types:
-                    logger.info(
-                        f"Loaded {len(ontology_types.types)} ontology types for scene_id: {memory_config.scene_id}"
-                    )
-                else:
-                    logger.info(f"No ontology classes found for scene_id: {memory_config.scene_id}")
-        except Exception as e:
-            logger.warning(
-                f"Failed to fetch ontology types for scene_id {memory_config.scene_id}: {e}",
-                exc_info=True
-            )
-
     orchestrator = ExtractionOrchestrator(
         llm_client=llm_client,
         embedder_client=embedder_client,
         connector=neo4j_connector,
         config=pipeline_config,
         embedding_id=embedding_model_id,
-        language=language,
-        ontology_types=ontology_types,
     )
 
     # Run the complete extraction pipeline
@@ -200,7 +173,7 @@ async def write(
     step_start = time.time()
     try:
         summaries = await memory_summary_generation(
-            chunked_dialogs, llm_client=llm_client, embedder_client=embedder_client, language=language
+            chunked_dialogs, llm_client=llm_client, embedder_client=embedder_client
         )
 
         try:
@@ -226,4 +199,4 @@ async def write(
         f.write(f"=== Pipeline Run Completed: {timestamp} ===\n\n")
 
     logger.info("=== Pipeline Complete ===")
-    logger.info(f"Total execution time: {total_time:.2f} seconds")
+    logger.info(f"Total execution time: {total_time:.2f} seconds")

api/app/core/memory/analytics/hot_memory_tags.py

@@ -39,20 +39,16 @@ async def filter_tags_with_llm(tags: List[str], end_user_id: str) -> List[str]:
             
             connected_config = get_end_user_connected_config(end_user_id, db)
             config_id = connected_config.get("memory_config_id")
-            workspace_id = connected_config.get("workspace_id")
             
-            if not config_id and not workspace_id:
+            if not config_id:
                 raise ValueError(
                     f"No memory_config_id found for end_user_id: {end_user_id}. "
                     "Please ensure the user has a valid memory configuration."
                 )
             
-            # Use the config_id to get the proper LLM client with workspace fallback
+            # Use the config_id to get the proper LLM client
             config_service = MemoryConfigService(db)
-            memory_config = config_service.load_memory_config(
-                config_id=config_id,
-                workspace_id=workspace_id
-            )
+            memory_config = config_service.load_memory_config(config_id)
             
             if not memory_config.llm_model_id:
                 raise ValueError(

api/app/core/memory/analytics/implicit_memory/analyzers/dimension_analyzer.py

@@ -108,6 +108,7 @@ class DimensionAnalyzer:
             
             # Create dimension portrait
             portrait = DimensionPortrait(
+                user_id=user_id,
                 creativity=dimension_scores["creativity"],
                 aesthetic=dimension_scores["aesthetic"],
                 technology=dimension_scores["technology"],
@@ -219,7 +220,7 @@ class DimensionAnalyzer:
         """Create an empty dimension portrait when no data is available.
         
         Args:
-            user_id: Target user ID (used for logging only)
+            user_id: Target user ID
             
         Returns:
             Empty DimensionPortrait
@@ -227,6 +228,7 @@ class DimensionAnalyzer:
         current_time = datetime.now()
         
         return DimensionPortrait(
+            user_id=user_id,
             creativity=self._create_default_dimension_score("creativity"),
             aesthetic=self._create_default_dimension_score("aesthetic"),
             technology=self._create_default_dimension_score("technology"),

api/app/core/memory/analytics/implicit_memory/analyzers/interest_analyzer.py

@@ -7,7 +7,7 @@ providing percentage distribution that totals 100%.
 
 import logging
 from datetime import datetime
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from app.core.memory.analytics.implicit_memory.llm_client import ImplicitMemoryLLMClient
 from app.core.memory.llm_tools.llm_client import LLMClientException
@@ -133,6 +133,7 @@ class InterestAnalyzer:
             
             # Create interest area distribution
             distribution = InterestAreaDistribution(
+                user_id=user_id,
                 tech=interest_categories["tech"],
                 lifestyle=interest_categories["lifestyle"],
                 music=interest_categories["music"],
@@ -250,7 +251,7 @@ class InterestAnalyzer:
         """Create an empty interest distribution when no data is available.
         
         Args:
-            user_id: Target user ID (used for logging only)
+            user_id: Target user ID
             
         Returns:
             Empty InterestAreaDistribution with equal percentages
@@ -258,15 +259,15 @@ class InterestAnalyzer:
         current_time = datetime.now()
         equal_percentage = 25.0  # 100% / 4 categories
         
-        def default_category(name: str) -> InterestCategory:
-            return InterestCategory(
-                category_name=name,
-                percentage=equal_percentage,
-                evidence=["Insufficient data for analysis"],
-                trending_direction=None
-            )
+        default_category = lambda name: InterestCategory(
+            category_name=name,
+            percentage=equal_percentage,
+            evidence=["Insufficient data for analysis"],
+            trending_direction=None
+        )
         
         return InterestAreaDistribution(
+            user_id=user_id,
             tech=default_category("tech"),
             lifestyle=default_category("lifestyle"),
             music=default_category("music"),

api/app/core/memory/analytics/implicit_memory/prompts/preference_analysis.jinja2

@@ -16,7 +16,6 @@ Summary {{ loop.index }}:
 3. DO NOT use long phrases - use short nouns or noun phrases
 4. Only include preferences with confidence_score >= 0.3
 5. **IMPORTANT: Output language MUST match the input language. If summaries are in Chinese, output in Chinese. If in English, output in English.**
-6. **CRITICAL: supporting_evidence must be DIRECT QUOTES or paraphrases from the user's actual statements. DO NOT reference summary numbers (e.g., "Summary 1", "摘要1"). DO NOT describe what the summary contains. Extract the actual user behavior or statement as evidence.**
 
 ## Output Format
 {
@@ -39,16 +38,6 @@ Summary {{ loop.index }}:
   ]
 }
 
-## BAD supporting_evidence examples (DO NOT do this):
-- "Summary 1：西湖为核心景区" ❌
-- "摘要2中提到喜欢咖啡" ❌
-- "Based on Summary 3" ❌
-
-## GOOD supporting_evidence examples:
-- "去过西湖断桥、苏堤" ✓
-- "每天早上喝咖啡" ✓
-- "mentioned visiting the lake twice" ✓
-
 ## Example (English input → English output)
 {
   "preferences": [

api/app/core/memory/models/__init__.py

@@ -58,25 +58,12 @@ from app.core.memory.models.triplet_models import (
     TripletExtractionResponse,
 )
 
-# Ontology scenario models (LLM extracted from scenarios)
-from app.core.memory.models.ontology_scenario_models import (
+# Ontology models
+from app.core.memory.models.ontology_models import (
     OntologyClass,
     OntologyExtractionResponse,
 )
 
-# Ontology extraction models (for extraction flow)
-from app.core.memory.models.ontology_extraction_models import (
-    OntologyTypeInfo,
-    OntologyTypeList,
-)
-
-# Ontology general models (loaded from external ontology files)
-from app.core.memory.models.ontology_general_models import (
-    OntologyFileFormat,
-    GeneralOntologyType,
-    GeneralOntologyTypeRegistry,
-)
-
 # Variable configuration models
 from app.core.memory.models.variate_config import (
     StatementExtractionConfig,
@@ -127,13 +114,6 @@ __all__ = [
     # Ontology models
     "OntologyClass",
     "OntologyExtractionResponse",
-    # Ontology type models for extraction flow
-    "OntologyTypeInfo",
-    "OntologyTypeList",
-    # General ontology type models
-    "OntologyFileFormat",
-    "GeneralOntologyType",
-    "GeneralOntologyTypeRegistry",
     # Variable configuration
     "StatementExtractionConfig",
     "ForgettingEngineConfig",

api/app/core/memory/models/ontology_extraction_models.py

@@ -1,105 +0,0 @@
-# -*- coding: utf-8 -*-
-"""本体类型数据结构模块
-
-本模块定义用于在萃取流程中传递本体类型信息的轻量级数据类。
-
-Classes:
-    OntologyTypeInfo: 单个本体类型信息
-    OntologyTypeList: 本体类型列表
-"""
-
-from dataclasses import dataclass
-from typing import List
-
-
-@dataclass
-class OntologyTypeInfo:
-    """本体类型信息，用于萃取流程中传递。
-    
-    Attributes:
-        class_name: 类型名称
-        class_description: 类型描述
-    """
-    class_name: str
-    class_description: str
-    
-    def to_prompt_format(self) -> str:
-        """转换为提示词格式。
-        
-        Returns:
-            格式化的字符串，如 "- TypeName: Description"
-        """
-        return f"- {self.class_name}: {self.class_description}"
-
-
-@dataclass
-class OntologyTypeList:
-    """本体类型列表。
-    
-    Attributes:
-        types: 本体类型信息列表
-    """
-    types: List[OntologyTypeInfo]
-    
-    @classmethod
-    def from_db_models(cls, ontology_classes: list) -> "OntologyTypeList":
-        """从数据库模型转换创建 OntologyTypeList。
-        
-        Args:
-            ontology_classes: OntologyClass 数据库模型列表，
-                每个对象应包含 class_name 和 class_description 属性
-        
-        Returns:
-            包含转换后类型信息的 OntologyTypeList 实例
-        """
-        types = [
-            OntologyTypeInfo(
-                class_name=oc.class_name,
-                class_description=oc.class_description or ""
-            )
-            for oc in ontology_classes
-        ]
-        return cls(types=types)
-    
-    def to_prompt_section(self) -> str:
-        """转换为提示词中的类型列表部分。
-        
-        Returns:
-            格式化的类型列表字符串，每行一个类型；
-            如果列表为空则返回空字符串
-        """
-        if not self.types:
-            return ""
-        lines = [t.to_prompt_format() for t in self.types]
-        return "\n".join(lines)
-    
-    def get_type_names(self) -> List[str]:
-        """获取所有类型名称列表。
-        
-        Returns:
-            类型名称字符串列表
-        """
-        return [t.class_name for t in self.types]
-    
-    def get_type_hierarchy_hints(self) -> List[str]:
-        """获取类型层次结构提示列表。
-        
-        尝试从通用本体注册表中获取每个类型的继承链信息。
-        
-        Returns:
-            层次提示字符串列表，格式为 "类型名 → 父类1 → 父类2"
-        """
-        hints = []
-        try:
-            from app.core.memory.ontology_services.ontology_type_merger import OntologyTypeMerger
-            
-            merger = OntologyTypeMerger()
-            for type_info in self.types:
-                hint = merger.get_type_hierarchy_hint(type_info.class_name)
-                if hint:
-                    hints.append(hint)
-        except Exception:
-            # 如果无法获取层次信息，返回空列表
-            pass
-        
-        return hints

api/app/core/memory/models/ontology_general_models.py

@@ -1,223 +0,0 @@
-# -*- coding: utf-8 -*-
-"""通用本体类型数据模型模块
-
-本模块定义用于通用本体类型管理的数据结构，包括：
-- OntologyFileFormat: 本体文件格式枚举
-- GeneralOntologyType: 通用本体类型数据类
-- GeneralOntologyTypeRegistry: 通用本体类型注册表
-
-Classes:
-    OntologyFileFormat: 本体文件格式枚举，支持 TTL、OWL/XML、RDF/XML、N-Triples、JSON-LD
-    GeneralOntologyType: 通用本体类型，包含类名、URI、标签、描述、父类等信息
-    GeneralOntologyTypeRegistry: 类型注册表，管理类型集合和层次结构
-"""
-
-import logging
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Any, Dict, List, Optional, Set
-
-logger = logging.getLogger(__name__)
-
-
-class OntologyFileFormat(Enum):
-    """本体文件格式枚举
-    
-    支持的格式：
-    - TURTLE: Turtle 格式 (.ttl 文件)
-    - RDF_XML: RDF/XML 格式 (.owl, .rdf 文件)
-    - N_TRIPLES: N-Triples 格式 (.nt 文件)
-    - JSON_LD: JSON-LD 格式 (.jsonld, .json 文件)
-    """
-    TURTLE = "turtle"      # .ttl 文件
-    RDF_XML = "xml"        # .owl, .rdf (RDF/XML 格式)
-    N_TRIPLES = "nt"       # .nt 文件
-    JSON_LD = "json-ld"    # .jsonld 文件
-    
-    @classmethod
-    def from_extension(cls, file_path: str) -> "OntologyFileFormat":
-        """根据文件扩展名推断格式
-        
-        Args:
-            file_path: 文件路径
-            
-        Returns:
-            推断出的文件格式，默认返回 RDF_XML
-        """
-        ext = file_path.lower().split('.')[-1]
-        format_map = {
-            'ttl': cls.TURTLE,
-            'owl': cls.RDF_XML,
-            'rdf': cls.RDF_XML,
-            'nt': cls.N_TRIPLES,
-            'jsonld': cls.JSON_LD,
-            'json': cls.JSON_LD,
-        }
-        return format_map.get(ext, cls.RDF_XML)
-
-
-@dataclass
-class GeneralOntologyType:
-    """通用本体类型
-    
-    表示从本体文件中解析出的类型定义，包含类型的基本信息和层次关系。
-    
-    Attributes:
-        class_name: 类型名称，如 "Person"
-        class_uri: 完整 URI，如 "http://dbpedia.org/ontology/Person"
-        labels: 多语言标签字典，键为语言代码（如 "en", "zh"），值为标签文本
-        description: 类型描述
-        parent_class: 父类名称，用于构建类型层次
-        source_file: 来源文件路径
-    """
-    class_name: str                          # 类型名称，如 "Person"
-    class_uri: str                           # 完整 URI
-    labels: Dict[str, str] = field(default_factory=dict)  # 多语言标签
-    description: Optional[str] = None        # 类型描述
-    parent_class: Optional[str] = None       # 父类名称
-    source_file: Optional[str] = None        # 来源文件
-    
-    def get_label(self, lang: str = "en") -> str:
-        """获取指定语言的标签
-        
-        优先返回指定语言的标签，如果不存在则尝试返回英文标签，
-        最后返回类型名称作为默认值。
-        
-        Args:
-            lang: 语言代码，默认为 "en"
-            
-        Returns:
-            指定语言的标签，或默认值
-        """
-        return self.labels.get(lang, self.labels.get("en", self.class_name))
-
-
-@dataclass
-class GeneralOntologyTypeRegistry:
-    """通用本体类型注册表
-    
-    管理解析后的本体类型集合，提供类型查询、层次遍历、注册表合并等功能。
-    
-    Attributes:
-        types: 类型字典，键为类型名称，值为 GeneralOntologyType 实例
-        hierarchy: 层次结构字典，键为父类名称，值为子类名称集合
-        source_files: 已加载的源文件路径列表
-    """
-    types: Dict[str, GeneralOntologyType] = field(default_factory=dict)
-    hierarchy: Dict[str, Set[str]] = field(default_factory=dict)  # 父类 -> 子类集合
-    source_files: List[str] = field(default_factory=list)
-    
-    def get_type(self, name: str) -> Optional[GeneralOntologyType]:
-        """根据名称获取类型
-        
-        Args:
-            name: 类型名称
-            
-        Returns:
-            对应的 GeneralOntologyType 实例，如果不存在则返回 None
-        """
-        return self.types.get(name)
-    
-    def get_ancestors(self, name: str) -> List[str]:
-        """获取类型的所有祖先类型（防循环）
-        
-        从当前类型开始，沿着父类链向上遍历，返回所有祖先类型名称。
-        使用 visited 集合防止循环引用导致的无限循环。
-        
-        Args:
-            name: 类型名称
-            
-        Returns:
-            祖先类型名称列表，按从近到远的顺序排列
-        """
-        ancestors = []
-        current = name
-        visited = set()
-        while current and current not in visited:
-            visited.add(current)
-            type_info = self.types.get(current)
-            if type_info and type_info.parent_class:
-                # 检测循环引用
-                if type_info.parent_class in visited:
-                    logger.warning(
-                        f"检测到类型层次循环引用: {current} -> {type_info.parent_class}，"
-                        f"已遍历路径: {' -> '.join([name] + ancestors)}"
-                    )
-                    break
-                ancestors.append(type_info.parent_class)
-                current = type_info.parent_class
-            else:
-                break
-        return ancestors
-    
-    def get_descendants(self, name: str) -> Set[str]:
-        """获取类型的所有后代类型
-        
-        从当前类型开始，沿着子类关系向下遍历，返回所有后代类型名称。
-        使用广度优先搜索，避免重复处理已访问的类型。
-        
-        Args:
-            name: 类型名称
-            
-        Returns:
-            后代类型名称集合
-        """
-        descendants: Set[str] = set()
-        to_process = [name]
-        while to_process:
-            current = to_process.pop()
-            children = self.hierarchy.get(current, set())
-            new_children = children - descendants
-            descendants.update(new_children)
-            to_process.extend(new_children)
-        return descendants
-    
-    def merge(self, other: "GeneralOntologyTypeRegistry") -> None:
-        """合并另一个注册表（先加载的优先）
-        
-        将另一个注册表的类型和层次结构合并到当前注册表。
-        对于同名类型，保留当前注册表中已存在的定义（先加载优先）。
-        层次结构会合并所有子类关系。
-        
-        Args:
-            other: 要合并的另一个注册表
-        """
-        for name, type_info in other.types.items():
-            if name not in self.types:
-                self.types[name] = type_info
-        for parent, children in other.hierarchy.items():
-            if parent not in self.hierarchy:
-                self.hierarchy[parent] = set()
-            self.hierarchy[parent].update(children)
-        self.source_files.extend(other.source_files)
-    
-    def get_statistics(self) -> Dict[str, Any]:
-        """获取注册表统计信息
-        
-        Returns:
-            包含以下键的字典：
-            - total_types: 总类型数
-            - root_types: 根类型数（无父类的类型）
-            - max_depth: 类型层次的最大深度
-            - source_files: 源文件列表
-        """
-        return {
-            "total_types": len(self.types),
-            "root_types": len([t for t in self.types.values() if not t.parent_class]),
-            "max_depth": self._calculate_max_depth(),
-            "source_files": self.source_files,
-        }
-    
-    def _calculate_max_depth(self) -> int:
-        """计算类型层次的最大深度
-        
-        遍历所有类型，计算每个类型到根的深度，返回最大值。
-        
-        Returns:
-            类型层次的最大深度
-        """
-        max_depth = 0
-        for type_name in self.types:
-            depth = len(self.get_ancestors(type_name))
-            max_depth = max(max_depth, depth)
-        return max_depth

api/app/core/memory/models/ontology_models.py

@@ -74,7 +74,7 @@ class OntologyClass(BaseModel):
         """Validate that the class name follows PascalCase convention.
 
         PascalCase rules:
-        - Must start with an uppercase letter (for English) or any character (for Chinese/Unicode)
+        - Must start with an uppercase letter
         - Cannot contain spaces
         - Should not contain special characters except underscores
 
@@ -90,10 +90,7 @@ class OntologyClass(BaseModel):
         if not v:
             raise ValueError("Class name cannot be empty")
         
-        # For Chinese/Unicode characters, skip the uppercase check
-        # Only check uppercase for ASCII letters
-        first_char = v[0]
-        if first_char.isascii() and first_char.isalpha() and not first_char.isupper():
+        if not v[0].isupper():
             raise ValueError(
                 f"Class name '{v}' must start with an uppercase letter (PascalCase)"
             )
@@ -103,11 +100,11 @@ class OntologyClass(BaseModel):
                 f"Class name '{v}' cannot contain spaces (PascalCase)"
             )
         
-        # Check for invalid characters (allow alphanumeric, underscore, and Unicode characters)
-        if not all(c.isalnum() or c == '_' or ord(c) > 127 for c in v):
+        # Check for invalid characters (allow alphanumeric and underscore only)
+        if not all(c.isalnum() or c == '_' for c in v):
             raise ValueError(
                 f"Class name '{v}' contains invalid characters. "
-                "Only alphanumeric characters, underscores, and Unicode characters are allowed"
+                "Only alphanumeric characters and underscores are allowed"
             )
         
         return v

api/app/core/memory/ontology_services/__init__.py

@@ -1,39 +0,0 @@
-# -*- coding: utf-8 -*-
-"""本体类型服务模块
-
-本模块提供本体类型相关的服务，包括：
-- OntologyTypeMerger: 本体类型合并服务
-- get_general_ontology_registry: 获取通用本体类型注册表（单例，懒加载）
-- get_ontology_type_merger: 获取类型合并服务实例
-- reload_ontology_registry: 重新加载本体注册表（实验模式）
-- clear_ontology_cache: 清除本体缓存
-- is_general_ontology_enabled: 检查通用本体类型功能是否启用
-- load_ontology_types_for_scene: 从数据库加载场景的本体类型
-- create_empty_ontology_type_list: 创建空的本体类型列表
-- load_ontology_types_with_fallback: 加载本体类型（带通用类型回退）
-"""
-
-from .ontology_type_merger import OntologyTypeMerger, DEFAULT_CORE_GENERAL_TYPES
-from .ontology_type_loader import (
-    get_general_ontology_registry,
-    get_ontology_type_merger,
-    reload_ontology_registry,
-    clear_ontology_cache,
-    is_general_ontology_enabled,
-    load_ontology_types_for_scene,
-    create_empty_ontology_type_list,
-    load_ontology_types_with_fallback,
-)
-
-__all__ = [
-    "OntologyTypeMerger",
-    "DEFAULT_CORE_GENERAL_TYPES",
-    "get_general_ontology_registry",
-    "get_ontology_type_merger",
-    "reload_ontology_registry",
-    "clear_ontology_cache",
-    "is_general_ontology_enabled",
-    "load_ontology_types_for_scene",
-    "create_empty_ontology_type_list",
-    "load_ontology_types_with_fallback",
-]

api/app/core/memory/ontology_services/ontology_type_loader.py

@@ -1,270 +0,0 @@
-"""本体类型加载器
-
-提供统一的本体类型加载逻辑，避免代码重复。
-
-Functions:
-    load_ontology_types_for_scene: 从数据库加载场景的本体类型
-    is_general_ontology_enabled: 检查是否启用通用本体
-    get_general_ontology_registry: 获取通用本体类型注册表（单例，懒加载）
-    get_ontology_type_merger: 获取类型合并服务实例
-    reload_ontology_registry: 重新加载本体注册表
-    clear_ontology_cache: 清除本体缓存
-"""
-
-import logging
-import os
-from typing import Optional
-from uuid import UUID
-
-from sqlalchemy.orm import Session
-
-logger = logging.getLogger(__name__)
-
-# 模块级缓存（单例）
-_general_registry_cache = None
-_ontology_type_merger_cache = None
-
-
-def load_ontology_types_for_scene(
-    scene_id: Optional[UUID],
-    workspace_id: UUID,
-    db: Session
-) -> Optional["OntologyTypeList"]:
-    """从数据库加载场景的本体类型
-    
-    统一的本体类型加载逻辑，用于替代各处重复的加载代码。
-    
-    Args:
-        scene_id: 场景ID，如果为 None 则返回 None
-        workspace_id: 工作空间ID
-        db: 数据库会话
-        
-    Returns:
-        OntologyTypeList 如果场景有类型定义，否则返回 None
-        
-    Examples:
-        >>> ontology_types = load_ontology_types_for_scene(
-        ...     scene_id=scene_uuid,
-        ...     workspace_id=workspace_uuid,
-        ...     db=db_session
-        ... )
-        >>> if ontology_types:
-        ...     print(f"Loaded {len(ontology_types.types)} types")
-    """
-    if not scene_id:
-        return None
-    
-    try:
-        from app.core.memory.models.ontology_extraction_models import OntologyTypeList
-        from app.repositories.ontology_class_repository import OntologyClassRepository
-        
-        # 查询场景的本体类型
-        ontology_repo = OntologyClassRepository(db)
-        ontology_classes = ontology_repo.get_classes_by_scene(
-            scene_id=scene_id
-        )
-        
-        if not ontology_classes:
-            logger.info(f"No ontology types found for scene_id: {scene_id}")
-            return None
-        
-        # 转换为 OntologyTypeList
-        ontology_types = OntologyTypeList.from_db_models(ontology_classes)
-        logger.info(
-            f"Loaded {len(ontology_types.types)} ontology types for scene_id: {scene_id}"
-        )
-        
-        return ontology_types
-        
-    except Exception as e:
-        logger.error(f"Failed to load ontology types for scene_id {scene_id}: {e}", exc_info=True)
-        return None
-
-
-def create_empty_ontology_type_list() -> Optional["OntologyTypeList"]:
-    """创建空的本体类型列表（用于仅使用通用类型的场景）
-    
-    Returns:
-        空的 OntologyTypeList 如果通用本体已启用，否则返回 None
-    """
-    try:
-        from app.core.memory.models.ontology_extraction_models import OntologyTypeList
-        
-        if is_general_ontology_enabled():
-            logger.info("Creating empty OntologyTypeList for general types only")
-            return OntologyTypeList(types=[])
-        
-        return None
-        
-    except Exception as e:
-        logger.warning(f"Failed to create empty OntologyTypeList: {e}")
-        return None
-
-
-def is_general_ontology_enabled() -> bool:
-    """检查是否启用了通用本体
-    
-    通过配置开关和注册表是否可用来判断。
-    
-    Returns:
-        True 如果通用本体已启用，否则 False
-    """
-    try:
-        from app.core.config import settings
-        
-        if not settings.ENABLE_GENERAL_ONTOLOGY_TYPES:
-            return False
-        
-        registry = get_general_ontology_registry()
-        return registry is not None and len(registry.types) > 0
-        
-    except Exception as e:
-        logger.warning(f"Failed to check general ontology status: {e}")
-        return False
-
-
-def get_general_ontology_registry():
-    """获取通用本体类型注册表（单例，懒加载）
-    
-    从配置的本体文件中解析并缓存注册表。
-    
-    Returns:
-        GeneralOntologyTypeRegistry 实例，如果加载失败则返回 None
-    """
-    global _general_registry_cache
-    
-    if _general_registry_cache is not None:
-        return _general_registry_cache
-    
-    try:
-        from app.core.config import settings
-        
-        if not settings.ENABLE_GENERAL_ONTOLOGY_TYPES:
-            logger.info("通用本体类型功能已禁用")
-            return None
-        
-        # 解析本体文件路径
-        file_names = [f.strip() for f in settings.GENERAL_ONTOLOGY_FILES.split(",") if f.strip()]
-        if not file_names:
-            logger.warning("未配置通用本体文件")
-            return None
-        
-        # 构建完整路径（相对于项目根目录）
-        base_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))))
-        file_paths = []
-        for name in file_names:
-            full_path = os.path.join(base_dir, name)
-            if os.path.exists(full_path):
-                file_paths.append(full_path)
-            else:
-                logger.warning(f"本体文件不存在: {full_path}")
-        
-        if not file_paths:
-            logger.warning("没有找到可用的通用本体文件")
-            return None
-        
-        # 解析本体文件
-        from app.core.memory.utils.ontology.ontology_parser import MultiOntologyParser
-        
-        parser = MultiOntologyParser(file_paths)
-        _general_registry_cache = parser.parse_all()
-        logger.info(f"通用本体注册表加载完成: {len(_general_registry_cache.types)} 个类型")
-        
-        return _general_registry_cache
-        
-    except Exception as e:
-        logger.error(f"加载通用本体注册表失败: {e}", exc_info=True)
-        return None
-
-
-def get_ontology_type_merger():
-    """获取类型合并服务实例（单例，懒加载）
-    
-    Returns:
-        OntologyTypeMerger 实例，如果通用本体未启用则返回 None
-    """
-    global _ontology_type_merger_cache
-    
-    if _ontology_type_merger_cache is not None:
-        return _ontology_type_merger_cache
-    
-    try:
-        registry = get_general_ontology_registry()
-        if registry is None:
-            return None
-        
-        from app.core.config import settings
-        from app.core.memory.ontology_services.ontology_type_merger import OntologyTypeMerger
-        
-        # 从配置读取核心类型
-        core_types_str = settings.CORE_GENERAL_TYPES
-        core_types = [t.strip() for t in core_types_str.split(",") if t.strip()] if core_types_str else None
-        
-        _ontology_type_merger_cache = OntologyTypeMerger(
-            general_registry=registry,
-            max_types_in_prompt=settings.MAX_ONTOLOGY_TYPES_IN_PROMPT,
-            core_types=core_types,
-        )
-        logger.info("OntologyTypeMerger 实例创建完成")
-        
-        return _ontology_type_merger_cache
-        
-    except Exception as e:
-        logger.error(f"创建 OntologyTypeMerger 失败: {e}", exc_info=True)
-        return None
-
-
-def reload_ontology_registry():
-    """重新加载本体注册表（清除缓存后重新加载）
-    
-    用于实验模式下动态更新本体配置。
-    """
-    clear_ontology_cache()
-    registry = get_general_ontology_registry()
-    if registry:
-        get_ontology_type_merger()
-        logger.info("本体注册表已重新加载")
-    return registry
-
-
-def clear_ontology_cache():
-    """清除本体缓存"""
-    global _general_registry_cache, _ontology_type_merger_cache
-    _general_registry_cache = None
-    _ontology_type_merger_cache = None
-    logger.info("本体缓存已清除")
-
-
-def load_ontology_types_with_fallback(
-    scene_id: Optional[UUID],
-    workspace_id: UUID,
-    db: Session,
-    enable_general_fallback: bool = True
-) -> Optional["OntologyTypeList"]:
-    """加载本体类型，如果场景没有类型则回退到通用类型
-    
-    这是一个便捷函数，组合了场景类型加载和通用类型回退逻辑。
-    
-    Args:
-        scene_id: 场景ID
-        workspace_id: 工作空间ID
-        db: 数据库会话
-        enable_general_fallback: 是否在没有场景类型时启用通用类型回退
-        
-    Returns:
-        OntologyTypeList 或 None
-    """
-    # 首先尝试加载场景类型
-    ontology_types = load_ontology_types_for_scene(
-        scene_id=scene_id,
-        workspace_id=workspace_id,
-        db=db
-    )
-    
-    # 如果没有场景类型且启用了回退，创建空列表以使用通用类型
-    if ontology_types is None and enable_general_fallback:
-        ontology_types = create_empty_ontology_type_list()
-        if ontology_types:
-            logger.info("No scene ontology types, will use general ontology types only")
-    
-    return ontology_types

api/app/core/memory/ontology_services/ontology_type_merger.py

@@ -1,231 +0,0 @@
-# -*- coding: utf-8 -*-
-"""本体类型合并服务模块
-
-本模块实现本体类型合并服务，负责按优先级合并场景类型与通用类型。
-
-合并优先级：
-1. 场景特定类型（最高优先级）
-2. 核心通用类型
-3. 相关父类类型（最低优先级）
-
-Classes:
-    OntologyTypeMerger: 本体类型合并服务类
-
-Constants:
-    DEFAULT_CORE_GENERAL_TYPES: 默认核心通用类型集合
-"""
-
-import logging
-from typing import List, Optional, Set
-
-from app.core.memory.models.ontology_general_models import GeneralOntologyTypeRegistry
-from app.core.memory.models.ontology_extraction_models import OntologyTypeInfo, OntologyTypeList
-
-logger = logging.getLogger(__name__)
-
-# 默认核心通用类型
-DEFAULT_CORE_GENERAL_TYPES: Set[str] = {
-    "Person", "Organization", "Company", "GovernmentAgency",
-    "Place", "Location", "City", "Country", "Building",
-    "Event", "SportsEvent", "MusicEvent", "SocialEvent",
-    "Work", "Book", "Film", "Software", "Album",
-    "Concept", "TopicalConcept", "AcademicSubject",
-    "Device", "Food", "Drug", "ChemicalSubstance",
-    "TimePeriod", "Year",
-}
-
-
-class OntologyTypeMerger:
-    """本体类型合并服务
-    
-    负责按优先级合并场景类型与通用类型，生成用于三元组提取的类型列表。
-    
-    合并优先级：
-    1. 场景特定类型（最高优先级）- 标记为 [场景类型]
-    2. 核心通用类型 - 标记为 [通用类型]
-    3. 相关父类类型（最低优先级）- 标记为 [通用父类]
-    
-    Attributes:
-        general_registry: 通用本体类型注册表
-        max_types_in_prompt: Prompt 中最大类型数量限制
-        core_types: 核心通用类型集合
-    
-    Example:
-        >>> registry = GeneralOntologyTypeRegistry()
-        >>> merger = OntologyTypeMerger(registry, max_types_in_prompt=50)
-        >>> merged = merger.merge(scene_types)
-        >>> print(len(merged.types))
-    """
-    
-    def __init__(
-        self,
-        general_registry: GeneralOntologyTypeRegistry,
-        max_types_in_prompt: int = 50,
-        core_types: Optional[List[str]] = None
-    ):
-        """初始化本体类型合并服务
-        
-        Args:
-            general_registry: 通用本体类型注册表
-            max_types_in_prompt: Prompt 中最大类型数量，默认 50
-            core_types: 自定义核心类型列表，如果为 None 则使用默认核心类型
-        """
-        self.general_registry = general_registry
-        self.max_types_in_prompt = max_types_in_prompt
-        self.core_types: Set[str] = set(core_types) if core_types else DEFAULT_CORE_GENERAL_TYPES.copy()
-    
-    def update_core_types(self, core_types: List[str]) -> None:
-        """动态更新核心类型列表
-        
-        更新后立即生效，无需重启服务。
-        
-        Args:
-            core_types: 新的核心类型列表
-        """
-        self.core_types = set(core_types)
-        logger.info(f"核心类型已更新: {len(self.core_types)} 个类型")
-    
-    def merge(
-        self,
-        scene_types: Optional[OntologyTypeList],
-        include_related_types: bool = True
-    ) -> OntologyTypeList:
-        """合并场景类型与通用类型
-        
-        按优先级合并类型：
-        1. 场景特定类型（最高优先级）
-        2. 核心通用类型
-        3. 相关父类类型（可选）
-        
-        合并后的类型总数不超过 max_types_in_prompt。
-        
-        Args:
-            scene_types: 场景特定类型列表，可以为 None
-            include_related_types: 是否包含相关父类类型，默认 True
-            
-        Returns:
-            合并后的类型列表，每个类型带有来源标记
-        """
-        merged_types: List[OntologyTypeInfo] = []
-        seen_names: Set[str] = set()
-        
-        # 1. 场景特定类型（最高优先级）
-        scene_type_count = 0
-        if scene_types and scene_types.types:
-            for scene_type in scene_types.types:
-                if scene_type.class_name not in seen_names:
-                    merged_types.append(OntologyTypeInfo(
-                        class_name=scene_type.class_name,
-                        class_description=f"[场景类型] {scene_type.class_description}"
-                    ))
-                    seen_names.add(scene_type.class_name)
-                    scene_type_count += 1
-        
-        # 2. 核心通用类型
-        remaining_slots = self.max_types_in_prompt - len(merged_types)
-        core_types_added: List[OntologyTypeInfo] = []
-        
-        for type_name in self.core_types:
-            if type_name not in seen_names and remaining_slots > 0:
-                general_type = self.general_registry.get_type(type_name)
-                if general_type:
-                    description = (
-                        general_type.labels.get("zh") or 
-                        general_type.description or 
-                        general_type.get_label("en") or 
-                        type_name
-                    )
-                    core_types_added.append(OntologyTypeInfo(
-                        class_name=type_name,
-                        class_description=f"[通用类型] {description}"
-                    ))
-                    seen_names.add(type_name)
-                    remaining_slots -= 1
-        
-        merged_types.extend(core_types_added)
-        
-        # 3. 相关父类类型
-        related_types_added: List[OntologyTypeInfo] = []
-        if include_related_types and scene_types and scene_types.types:
-            for scene_type in scene_types.types:
-                if remaining_slots <= 0:
-                    break
-                general_type = self.general_registry.get_type(scene_type.class_name)
-                if general_type and general_type.parent_class:
-                    parent_name = general_type.parent_class
-                    if parent_name not in seen_names:
-                        parent_type = self.general_registry.get_type(parent_name)
-                        if parent_type:
-                            description = (
-                                parent_type.labels.get("zh") or 
-                                parent_type.description or 
-                                parent_name
-                            )
-                            related_types_added.append(OntologyTypeInfo(
-                                class_name=parent_name,
-                                class_description=f"[通用父类] {description}"
-                            ))
-                            seen_names.add(parent_name)
-                            remaining_slots -= 1
-        
-        merged_types.extend(related_types_added)
-        
-        logger.info(
-            f"类型合并完成: 场景类型 {scene_type_count} 个, "
-            f"核心通用类型 {len(core_types_added)} 个, "
-            f"相关类型 {len(related_types_added)} 个, "
-            f"总计 {len(merged_types)} 个"
-        )
-        
-        return OntologyTypeList(types=merged_types)
-    
-    def get_type_hierarchy_hint(self, type_name: str) -> Optional[str]:
-        """获取类型的层次提示信息（最多 3 级）
-        
-        返回类型的继承链信息，格式为 "类型名 → 父类1 → 父类2 → 父类3"。
-        
-        Args:
-            type_name: 类型名称
-            
-        Returns:
-            层次提示字符串，如果类型不存在或没有父类则返回 None
-        """
-        general_type = self.general_registry.get_type(type_name)
-        if not general_type:
-            return None
-        ancestors = self.general_registry.get_ancestors(type_name)
-        if ancestors:
-            # 限制最多 3 级祖先
-            return f"{type_name} → {' → '.join(ancestors[:3])}"
-        return None
-    
-    def get_merge_statistics(self, scene_types: Optional[OntologyTypeList]) -> dict:
-        """获取合并统计信息
-        
-        执行合并操作并返回各类型来源的数量统计。
-        
-        Args:
-            scene_types: 场景特定类型列表
-            
-        Returns:
-            包含以下键的统计字典：
-            - total_types: 合并后总类型数
-            - scene_types: 场景类型数量
-            - general_types: 通用类型数量
-            - parent_types: 父类类型数量
-            - available_core_types: 可用核心类型数量
-            - registry_total_types: 注册表中总类型数
-        """
-        merged = self.merge(scene_types)
-        scene_count = sum(1 for t in merged.types if "[场景类型]" in t.class_description)
-        general_count = sum(1 for t in merged.types if "[通用类型]" in t.class_description)
-        parent_count = sum(1 for t in merged.types if "[通用父类]" in t.class_description)
-        
-        return {
-            "total_types": len(merged.types),
-            "scene_types": scene_count,
-            "general_types": general_count,
-            "parent_types": parent_count,
-            "available_core_types": len(self.core_types),
-            "registry_total_types": len(self.general_registry.types),
-        }

api/app/core/memory/storage_services/extraction_engine/extraction_orchestrator.py

@@ -34,8 +34,6 @@ from app.core.memory.models.graph_models import (
     StatementNode,
 )
 from app.core.memory.models.message_models import DialogData
-from app.core.memory.models.ontology_extraction_models import OntologyTypeList
-from app.core.memory.models.ontology_extraction_models import OntologyTypeList
 from app.core.memory.models.variate_config import (
     ExtractionPipelineConfig,
 )
@@ -97,9 +95,6 @@ class ExtractionOrchestrator:
         config: Optional[ExtractionPipelineConfig] = None,
         progress_callback: Optional[Callable[[str, str, Optional[Dict[str, Any]]], Awaitable[None]]] = None,
         embedding_id: Optional[str] = None,
-        ontology_types: Optional[OntologyTypeList] = None,
-        enable_general_types: bool = True,
-        language: str = "zh",
     ):
         """
         初始化流水线编排器
@@ -113,7 +108,6 @@ class ExtractionOrchestrator:
                 - 接受 (stage: str, message: str, data: Optional[Dict[str, Any]]) 并返回 Awaitable[None]
                 - 在管线关键点调用以报告进度和结果数据
             embedding_id: 嵌入模型ID，如果为 None 则从全局配置获取（向后兼容）
-            language: 语言类型 ("zh" 中文, "en" 英文)，默认中文
         """
         self.llm_client = llm_client
         self.embedder_client = embedder_client
@@ -122,30 +116,6 @@ class ExtractionOrchestrator:
         self.is_pilot_run = False  # 默认非试运行模式
         self.progress_callback = progress_callback  # 保存进度回调函数
         self.embedding_id = embedding_id  # 保存嵌入模型ID
-        self.language = language  # 保存语言配置
-    
-        # 处理本体类型配置
-        # 根据 enable_general_types 参数决定是否将通用本体类型与场景特定类型合并
-        # 如果启用合并且配置中开启了通用本体功能，则使用 OntologyTypeMerger 进行融合
-        if enable_general_types and ontology_types:
-            from app.core.memory.ontology_services.ontology_type_loader import (
-                get_ontology_type_merger,
-                is_general_ontology_enabled,
-            )
-            if is_general_ontology_enabled():
-                merger = get_ontology_type_merger()
-                self.ontology_types = merger.merge(ontology_types)
-                logger.info(
-                    f"已启用通用本体类型融合: 场景类型 {len(ontology_types.types) if ontology_types.types else 0} 个 -> "
-                    f"合并后 {len(self.ontology_types.types) if self.ontology_types.types else 0} 个"
-                )
-            else:
-                self.ontology_types = ontology_types
-                logger.info("通用本体类型功能已在配置中禁用，仅使用场景类型")
-        else:
-            self.ontology_types = ontology_types
-            if not enable_general_types and ontology_types:
-                logger.info("enable_general_types=False，仅使用场景类型")
         
         # 保存去重消歧的详细记录（内存中的数据结构）
         self.dedup_merge_records: List[Dict[str, Any]] = []  # 实体合并记录
@@ -157,7 +127,7 @@ class ExtractionOrchestrator:
             llm_client=llm_client,
             config=self.config.statement_extraction,
         )
-        self.triplet_extractor = TripletExtractor(llm_client=llm_client,ontology_types=self.ontology_types, language=language)
+        self.triplet_extractor = TripletExtractor(llm_client=llm_client)
         self.temporal_extractor = TemporalExtractor(llm_client=llm_client)
 
         logger.info("ExtractionOrchestrator 初始化完成")
@@ -645,25 +615,9 @@ class ExtractionOrchestrator:
         logger.info(f"总陈述句: {total_statements}, 用户陈述句: {filtered_statements}, 开始全局并行提取情绪")
 
         # 初始化情绪提取服务
-        # 如果 emotion_model_id 为空，回退到工作空间默认 LLM
         from app.services.emotion_extraction_service import EmotionExtractionService
-        
-        emotion_model_id = memory_config.emotion_model_id
-        if not emotion_model_id and memory_config.workspace_id:
-            from app.repositories.workspace_repository import get_workspace_models_configs
-            from app.db import SessionLocal
-            
-            db = SessionLocal()
-            try:
-                workspace_models = get_workspace_models_configs(db, memory_config.workspace_id)
-                if workspace_models and workspace_models.get("llm"):
-                    emotion_model_id = workspace_models["llm"]
-                    logger.info(f"emotion_model_id 为空，使用工作空间默认 LLM: {emotion_model_id}")
-            finally:
-                db.close()
-        
         emotion_service = EmotionExtractionService(
-            llm_id=emotion_model_id if emotion_model_id else None
+            llm_id=memory_config.emotion_model_id if memory_config.emotion_model_id else None
         )
 
         # 全局并行处理所有陈述句

api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/memory_summary.py

@@ -10,11 +10,38 @@ from app.core.memory.models.base_response import RobustLLMResponse
 from app.core.memory.models.graph_models import MemorySummaryNode
 from app.core.memory.models.message_models import DialogData
 from app.core.memory.utils.prompt.prompt_utils import render_memory_summary_prompt
-from app.core.language_utils import validate_language  # 使用集中化的语言校验
 from pydantic import Field
 
 logger = get_memory_logger(__name__)
 
+# 支持的语言列表和默认回退值
+SUPPORTED_LANGUAGES = {"zh", "en"}
+FALLBACK_LANGUAGE = "en"
+
+
+def validate_language(language: Optional[str]) -> str:
+    """
+    校验语言参数，确保其为有效值。
+    
+    Args:
+        language: 待校验的语言代码
+        
+    Returns:
+        有效的语言代码（"zh" 或 "en"）
+    """
+    if language is None:
+        return FALLBACK_LANGUAGE
+    
+    lang = str(language).lower().strip()
+    if lang in SUPPORTED_LANGUAGES:
+        return lang
+    
+    logger.warning(
+        f"无效的语言参数 '{language}'，已回退到默认值 '{FALLBACK_LANGUAGE}'。"
+        f"支持的语言: {SUPPORTED_LANGUAGES}"
+    )
+    return FALLBACK_LANGUAGE
+
 
 class MemorySummaryResponse(RobustLLMResponse):
     """Structured response for summary generation per chunk.
@@ -33,7 +60,7 @@ class MemorySummaryResponse(RobustLLMResponse):
 async def generate_title_and_type_for_summary(
     content: str,
     llm_client,
-    language: str = "zh"
+    language: str = None
 ) -> Tuple[str, str]:
     """
     为MemorySummary生成标题和类型
@@ -43,14 +70,17 @@ async def generate_title_and_type_for_summary(
     Args:
         content: Summary的内容文本
         llm_client: LLM客户端实例
-        language: 生成标题使用的语言 ("zh" 中文, "en" 英文)，默认中文
+        language: 生成标题使用的语言 ("zh" 中文, "en" 英文)，如果为None则从配置读取
         
     Returns:
         (标题, 类型)元组
     """
     from app.core.memory.utils.prompt.prompt_utils import render_episodic_title_and_type_prompt
+    from app.core.config import settings
     
-    # 验证语言参数
+    # 如果没有指定语言，从配置中读取，并校验有效性
+    if language is None:
+        language = settings.DEFAULT_LANGUAGE
     language = validate_language(language)
     
     # 定义有效的类型集合
@@ -158,7 +188,6 @@ async def _process_chunk_summary(
     chunk,
     llm_client,
     embedder: OpenAIEmbedderClient,
-    language: str = "zh",
 ) -> Optional[MemorySummaryNode]:
     """Process a single chunk to generate a memory summary node."""
     # Skip empty chunks
@@ -166,8 +195,9 @@ async def _process_chunk_summary(
         return None
 
     try:
-        # 验证语言参数
-        language = validate_language(language)
+        # 从配置中获取语言设置（只获取一次，复用），并校验有效性
+        from app.core.config import settings
+        language = validate_language(settings.DEFAULT_LANGUAGE)
         
         # Render prompt via Jinja2 for a single chunk
         prompt_content = await render_memory_summary_prompt(
@@ -237,21 +267,13 @@ async def memory_summary_generation(
     chunked_dialogs: List[DialogData],
     llm_client,
     embedder_client: OpenAIEmbedderClient,
-    language: str = "zh",
 ) -> List[MemorySummaryNode]:
-    """Generate memory summaries per chunk, embed them, and return nodes.
-    
-    Args:
-        chunked_dialogs: 分块后的对话数据
-        llm_client: LLM客户端
-        embedder_client: 嵌入客户端
-        language: 语言类型 ("zh" 中文, "en" 英文)，默认中文
-    """
+    """Generate memory summaries per chunk, embed them, and return nodes."""
     # Collect all tasks for parallel processing
     tasks = []
     for dialog in chunked_dialogs:
         for chunk in dialog.chunks:
-            tasks.append(_process_chunk_summary(dialog, chunk, llm_client, embedder_client, language=language))
+            tasks.append(_process_chunk_summary(dialog, chunk, llm_client, embedder_client))
 
     # Process all chunks in parallel
     results = await asyncio.gather(*tasks, return_exceptions=False)

api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/ontology_extraction.py

@@ -14,7 +14,7 @@ import time
 from typing import List, Optional
 
 from app.core.memory.llm_tools.openai_client import OpenAIClient
-from app.core.memory.models.ontology_scenario_models import (
+from app.core.memory.models.ontology_models import (
     OntologyClass,
     OntologyExtractionResponse,
 )
@@ -64,7 +64,6 @@ class OntologyExtractor:
         llm_max_tokens: int = 2000,
         max_description_length: int = 500,
         timeout: Optional[float] = None,
-        language: str = "zh",
     ) -> OntologyExtractionResponse:
         """Extract ontology classes from a scenario description.
         
@@ -85,7 +84,6 @@ class OntologyExtractor:
             llm_max_tokens: LLM max tokens parameter (default: 2000)
             max_description_length: Maximum description length (default: 500)
             timeout: Optional timeout in seconds for LLM call (default: None, no timeout)
-            language: Language for output ("zh" for Chinese, "en" for English)
             
         Returns:
             OntologyExtractionResponse containing validated ontology classes
@@ -118,7 +116,7 @@ class OntologyExtractor:
         logger.info(
             f"Starting ontology extraction - scenario_length={len(scenario)}, "
             f"domain={domain}, max_classes={max_classes}, min_classes={min_classes}, "
-            f"timeout={timeout}, language={language}"
+            f"timeout={timeout}"
         )
         
         try:
@@ -136,7 +134,6 @@ class OntologyExtractor:
                             max_classes=max_classes,
                             llm_temperature=llm_temperature,
                             llm_max_tokens=llm_max_tokens,
-                            language=language,
                         ),
                         timeout=timeout
                     )
@@ -159,7 +156,6 @@ class OntologyExtractor:
                     max_classes=max_classes,
                     llm_temperature=llm_temperature,
                     llm_max_tokens=llm_max_tokens,
-                    language=language,
                 )
             
             llm_duration = time.time() - llm_start_time
@@ -264,7 +260,6 @@ class OntologyExtractor:
         max_classes: int,
         llm_temperature: float,
         llm_max_tokens: int,
-        language: str = "zh",
     ) -> OntologyExtractionResponse:
         """Call LLM to extract ontology classes from scenario.
         
@@ -277,7 +272,6 @@ class OntologyExtractor:
             max_classes: Maximum number of classes to extract
             llm_temperature: LLM temperature parameter
             llm_max_tokens: LLM max tokens parameter
-            language: Language for output ("zh" for Chinese, "en" for English)
             
         Returns:
             OntologyExtractionResponse from LLM
@@ -292,7 +286,6 @@ class OntologyExtractor:
                 domain=domain,
                 max_classes=max_classes,
                 json_schema=OntologyExtractionResponse.model_json_schema(),
-                language=language,
             )
             
             logger.debug(f"Rendered prompt length: {len(prompt_content)}")

api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/triplet_extraction.py

@@ -1,6 +1,6 @@
 import os
 import asyncio
-from typing import List, Dict, Optional
+from typing import List, Dict
 
 from app.core.logging_config import get_memory_logger
 from app.core.memory.llm_tools.openai_client import OpenAIClient
@@ -8,7 +8,6 @@ from app.core.memory.utils.prompt.prompt_utils import render_triplet_extraction_
 from app.core.memory.utils.data.ontology import PREDICATE_DEFINITIONS, Predicate # 引入枚举 Predicate 白名单过滤
 from app.core.memory.models.triplet_models import TripletExtractionResponse
 from app.core.memory.models.message_models import DialogData, Statement
-from app.core.memory.models.ontology_extraction_models import OntologyTypeList
 from app.core.memory.utils.log.logging_utils import prompt_logger
 
 logger = get_memory_logger(__name__)
@@ -18,22 +17,13 @@ logger = get_memory_logger(__name__)
 class TripletExtractor:
     """Extracts knowledge triplets and entities from statements using LLM"""
 
-    def __init__(
-        self,
-        llm_client: OpenAIClient,
-        ontology_types: Optional[OntologyTypeList] = None,
-        language: str = "zh"):
+    def __init__(self, llm_client: OpenAIClient):
         """Initialize the TripletExtractor with an LLM client
 
         Args:
             llm_client: OpenAIClient instance for processing
-            language: 语言类型 ("zh" 中文, "en" 英文)，默认中文
-            ontology_types: Optional OntologyTypeList containing predefined ontology types
-                for entity classification guidance
         """
         self.llm_client = llm_client
-        self.ontology_types = ontology_types
-        self.language = language
 
     def _get_language(self) -> str:
         """Get the configured language for entity descriptions
@@ -41,7 +31,8 @@ class TripletExtractor:
         Returns:
             Language code ("zh" or "en")
         """
-        return self.language
+        from app.core.config import settings
+        return settings.DEFAULT_LANGUAGE
 
     async def _extract_triplets(self, statement: Statement, chunk_content: str) -> TripletExtractionResponse:
         """Process a single statement and return extracted triplets and entities"""
@@ -59,8 +50,7 @@ class TripletExtractor:
             chunk_content=chunk_content,
             json_schema=TripletExtractionResponse.model_json_schema(),
             predicate_instructions=PREDICATE_DEFINITIONS,
-            language=self._get_language(),
-            ontology_types=self.ontology_types,
+            language=self._get_language()
         )
 
         # Create messages for LLM

api/app/core/memory/storage_services/reflection_engine/self_reflexion.py

@@ -462,8 +462,8 @@ class ReflectionEngine:
             List[Any]: 反思数据列表
         """
 
-        print("=== 获取反思数据 ===")
-        print(f"  主机ID: {host_id}")
+
+
         if self.config.reflexion_range == ReflectionRange.PARTIAL:
             neo4j_query = neo4j_query_part.format(host_id)
             neo4j_statement = neo4j_statement_part.format(host_id)

api/app/core/memory/utils/ontology/__init__.py

@@ -1,12 +0,0 @@
-# -*- coding: utf-8 -*-
-"""本体解析工具模块
-
-本模块提供本体文件解析功能，支持多种 RDF 格式的本体文件解析。
-
-Modules:
-    ontology_parser: 本体文件解析器
-"""
-
-from .ontology_parser import MultiOntologyParser, OntologyParser
-
-__all__ = ["OntologyParser", "MultiOntologyParser"]

api/app/core/memory/utils/ontology/ontology_parser.py

@@ -1,366 +0,0 @@
-# -*- coding: utf-8 -*-
-"""本体文件解析器模块
-
-本模块提供统一的本体文件解析功能，支持多种 RDF 格式：
-- Turtle (.ttl)
-- OWL/XML (.owl)
-- RDF/XML (.rdf)
-- N-Triples (.nt)
-- JSON-LD (.jsonld)
-
-解析器会自动根据文件扩展名推断格式，并在解析失败时尝试其他格式。
-解析结果包含类定义的名称、URI、多语言标签、描述和父类信息。
-
-Classes:
-    OntologyParser: 统一本体文件解析器
-    MultiOntologyParser: 多本体文件解析器
-
-Example:
-    >>> parser = OntologyParser("ontology.ttl")
-    >>> registry = parser.parse()
-    >>> print(f"解析了 {len(registry.types)} 个类型")
-    
-    >>> multi_parser = MultiOntologyParser(["ontology1.ttl", "ontology2.owl"])
-    >>> merged_registry = multi_parser.parse_all()
-    >>> print(f"合并后共 {len(merged_registry.types)} 个类型")
-"""
-
-import logging
-import re
-from typing import List, Optional
-
-from rdflib import OWL, RDF, RDFS, Graph, URIRef
-
-from app.core.memory.models.ontology_general_models import (
-    GeneralOntologyType,
-    GeneralOntologyTypeRegistry,
-    OntologyFileFormat,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class OntologyParser:
-    """统一本体文件解析器
-    
-    解析本体文件并提取类定义，构建类型注册表。支持多种 RDF 格式，
-    并提供格式自动推断和回退机制。
-    
-    Attributes:
-        file_path: 本体文件路径
-        file_format: 文件格式，如果未指定则根据扩展名推断
-        graph: rdflib Graph 实例，用于存储解析后的 RDF 数据
-    
-    Example:
-        >>> parser = OntologyParser("dbpedia.owl")
-        >>> registry = parser.parse()
-        >>> person_type = registry.get_type("Person")
-        >>> if person_type:
-        ...     print(f"Person URI: {person_type.class_uri}")
-    """
-    
-    def __init__(
-        self,
-        file_path: str,
-        file_format: Optional[OntologyFileFormat] = None,
-    ):
-        """初始化解析器
-        
-        Args:
-            file_path: 本体文件路径
-            file_format: 文件格式，如果未指定则根据扩展名自动推断
-        """
-        self.file_path = file_path
-        self.file_format = file_format or OntologyFileFormat.from_extension(file_path)
-        self.graph = Graph()
-
-    def parse(self) -> GeneralOntologyTypeRegistry:
-        """解析本体文件，返回类型注册表
-        
-        首先尝试使用推断的格式解析文件，如果失败则尝试其他格式。
-        解析成功后，遍历所有 owl:Class 和 rdfs:Class 定义，
-        提取类信息并构建层次结构。
-        
-        Returns:
-            GeneralOntologyTypeRegistry: 包含所有解析出的类型和层次结构的注册表
-            
-        Raises:
-            ValueError: 当所有格式都无法解析文件时抛出
-        """
-        logger.info(f"开始解析本体文件: {self.file_path}")
-        
-        # 尝试解析，失败则尝试其他格式
-        self._parse_with_fallback()
-        
-        registry = GeneralOntologyTypeRegistry()
-        registry.source_files.append(self.file_path)
-        
-        # 遍历 owl:Class
-        for class_uri in self.graph.subjects(RDF.type, OWL.Class):
-            type_info = self._parse_class(class_uri)
-            if type_info:
-                registry.types[type_info.class_name] = type_info
-                self._update_hierarchy(registry, type_info)
-        
-        # 遍历 rdfs:Class（避免重复）
-        for class_uri in self.graph.subjects(RDF.type, RDFS.Class):
-            uri_str = str(class_uri)
-            # 检查是否已经作为 owl:Class 解析过
-            if uri_str not in [t.class_uri for t in registry.types.values()]:
-                type_info = self._parse_class(class_uri)
-                if type_info and type_info.class_name not in registry.types:
-                    registry.types[type_info.class_name] = type_info
-                    self._update_hierarchy(registry, type_info)
-        
-        logger.info(f"本体解析完成: {len(registry.types)} 个类型")
-        return registry
-    
-    def _parse_with_fallback(self) -> None:
-        """尝试解析文件，失败时尝试其他格式
-        
-        首先使用推断的格式解析，如果失败则依次尝试 RDF_XML 和 TURTLE 格式。
-        
-        Raises:
-            ValueError: 当所有格式都无法解析文件时抛出
-        """
-        try:
-            self.graph.parse(self.file_path, format=self.file_format.value)
-            return
-        except Exception as e:
-            logger.warning(f"使用 {self.file_format.value} 格式解析失败: {e}")
-        
-        # 尝试其他格式
-        fallback_formats = [
-            OntologyFileFormat.RDF_XML,
-            OntologyFileFormat.TURTLE,
-            OntologyFileFormat.N_TRIPLES,
-            OntologyFileFormat.JSON_LD,
-        ]
-        
-        for fmt in fallback_formats:
-            if fmt != self.file_format:
-                try:
-                    self.graph.parse(self.file_path, format=fmt.value)
-                    logger.info(f"使用回退格式 {fmt.value} 解析成功")
-                    return
-                except Exception:
-                    continue
-        
-        raise ValueError(f"无法解析本体文件: {self.file_path}")
-    
-    def _update_hierarchy(
-        self, 
-        registry: GeneralOntologyTypeRegistry, 
-        type_info: GeneralOntologyType
-    ) -> None:
-        """更新层次结构
-        
-        如果类型有父类，将其添加到层次结构中。
-        
-        Args:
-            registry: 类型注册表
-            type_info: 类型信息
-        """
-        if type_info.parent_class:
-            if type_info.parent_class not in registry.hierarchy:
-                registry.hierarchy[type_info.parent_class] = set()
-            registry.hierarchy[type_info.parent_class].add(type_info.class_name)
-    
-    def _parse_class(self, class_uri: URIRef) -> Optional[GeneralOntologyType]:
-        """解析单个类定义
-        
-        从 RDF 图中提取类的名称、URI、标签、描述和父类信息。
-        过滤空白节点和内置类型（Thing、Resource）。
-        
-        Args:
-            class_uri: 类的 URI 引用
-            
-        Returns:
-            GeneralOntologyType 实例，如果应该跳过该类则返回 None
-        """
-        uri_str = str(class_uri)
-        class_name = self._extract_local_name(uri_str)
-        
-        # 过滤空白节点和内置类型
-        if not class_name:
-            return None
-        if class_name.startswith('_:'):
-            return None
-        if class_name in ('Thing', 'Resource'):
-            return None
-        # 过滤空白节点 URI（以 _: 开头或包含空白节点标识）
-        if uri_str.startswith('_:'):
-            return None
-        
-        # 提取标签
-        labels = self._extract_labels(class_uri)
-        
-        # 提取描述
-        description = self._extract_description(class_uri)
-        
-        # 提取父类
-        parent_class = self._extract_parent_class(class_uri)
-        
-        return GeneralOntologyType(
-            class_name=class_name,
-            class_uri=uri_str,
-            labels=labels,
-            description=description,
-            parent_class=parent_class,
-            source_file=self.file_path
-        )
-    
-    def _extract_labels(self, class_uri: URIRef) -> dict:
-        """提取类的多语言标签
-        
-        从 rdfs:label 属性中提取所有语言的标签。
-        如果没有标签，使用类名作为英文标签。
-        
-        Args:
-            class_uri: 类的 URI 引用
-            
-        Returns:
-            语言代码到标签文本的字典
-        """
-        labels = {}
-        for label in self.graph.objects(class_uri, RDFS.label):
-            lang = getattr(label, 'language', None) or "en"
-            labels[lang] = str(label)
-        
-        # 如果没有标签，使用类名作为默认标签
-        if not labels:
-            class_name = self._extract_local_name(str(class_uri))
-            if class_name:
-                labels["en"] = class_name
-        
-        return labels
-    
-    def _extract_description(self, class_uri: URIRef) -> Optional[str]:
-        """提取类的描述
-        
-        从 rdfs:comment 属性中提取描述，优先使用英文描述。
-        
-        Args:
-            class_uri: 类的 URI 引用
-            
-        Returns:
-            类的描述文本，如果没有则返回 None
-        """
-        description = None
-        for comment in self.graph.objects(class_uri, RDFS.comment):
-            lang = getattr(comment, 'language', None)
-            # 优先使用英文描述
-            if lang == "en":
-                return str(comment)
-            # 如果还没有描述，使用无语言标记或其他语言的描述
-            if description is None:
-                description = str(comment)
-        return description
-    
-    def _extract_parent_class(self, class_uri: URIRef) -> Optional[str]:
-        """提取类的父类
-        
-        从 rdfs:subClassOf 属性中提取第一个有效的父类。
-        过滤内置类型（Thing、Resource）和空白节点。
-        
-        Args:
-            class_uri: 类的 URI 引用
-            
-        Returns:
-            父类名称，如果没有有效父类则返回 None
-        """
-        for parent_uri in self.graph.objects(class_uri, RDFS.subClassOf):
-            parent_uri_str = str(parent_uri)
-            # 跳过空白节点
-            if parent_uri_str.startswith('_:'):
-                continue
-            
-            parent_name = self._extract_local_name(parent_uri_str)
-            # 过滤内置类型
-            if parent_name and parent_name not in ('Thing', 'Resource'):
-                return parent_name
-        
-        return None
-    
-    def _extract_local_name(self, uri: str) -> Optional[str]:
-        """从 URI 中提取本地名称
-        
-        支持两种常见的 URI 格式：
-        1. 使用 # 分隔的 URI，如 http://example.org/ontology#Person
-        2. 使用 / 分隔的 URI，如 http://dbpedia.org/ontology/Person
-        
-        Args:
-            uri: 完整的 URI 字符串
-            
-        Returns:
-            本地名称，如果无法提取则返回 None
-        """
-        # 处理空白节点
-        if uri.startswith('_:'):
-            return None
-        
-        # 尝试使用 # 分隔
-        if '#' in uri:
-            local_name = uri.rsplit('#', 1)[1]
-            if local_name:
-                return local_name
-        
-        # 尝试使用 / 分隔
-        if '/' in uri:
-            local_name = uri.rsplit('/', 1)[1]
-            if local_name:
-                return local_name
-        
-        # 使用正则表达式作为最后手段
-        match = re.search(r'[#/]([^#/]+)$', uri)
-        return match.group(1) if match else None
-
-
-class MultiOntologyParser:
-    """多本体文件解析器
-    
-    支持加载多个本体文件并将它们合并到一个统一的类型注册表中。
-    先加载的文件中的类型定义优先保留（当存在同名类型时）。
-    
-    Attributes:
-        file_paths: 本体文件路径列表
-    
-    Example:
-        >>> parser = MultiOntologyParser([
-        ...     "General_purpose_entity.ttl",
-        ...     "domain_specific.owl"
-        ... ])
-        >>> registry = parser.parse_all()
-        >>> print(f"合并后共 {len(registry.types)} 个类型")
-    """
-    
-    def __init__(self, file_paths: List[str]):
-        """初始化多文件解析器
-        
-        Args:
-            file_paths: 本体文件路径列表
-        """
-        self.file_paths = file_paths
-    
-    def parse_all(self) -> GeneralOntologyTypeRegistry:
-        """解析所有本体文件并合并
-        
-        依次解析每个本体文件，并将结果合并到一个统一的注册表中。
-        如果某个文件解析失败，会记录警告日志并跳过该文件继续处理。
-        
-        Returns:
-            GeneralOntologyTypeRegistry: 合并后的类型注册表
-        """
-        merged_registry = GeneralOntologyTypeRegistry()
-        
-        for file_path in self.file_paths:
-            try:
-                parser = OntologyParser(file_path)
-                registry = parser.parse()
-                merged_registry.merge(registry)
-                logger.info(f"已合并本体文件: {file_path}")
-            except Exception as e:
-                logger.warning(f"跳过无法解析的本体文件 {file_path}: {e}")
-        
-        logger.info(f"多本体合并完成: 共 {len(merged_registry.types)} 个类型")
-        return merged_registry

api/app/core/memory/utils/prompt/prompt_utils.py

@@ -9,29 +9,22 @@ current_dir = os.path.dirname(os.path.abspath(__file__))
 prompt_dir = os.path.join(current_dir, "prompts")
 prompt_env = Environment(loader=FileSystemLoader(prompt_dir))
 
-async def get_prompts(message: str, language: str = "zh") -> list[dict]:
+async def get_prompts(message: str) -> list[dict]:
     """
     Renders system and user prompts using Jinja2 templates.
-    
-    Args:
-        message: The message content
-        language: Language for output ("zh" for Chinese, "en" for English)
-        
-    Returns:
-        List of message dictionaries with role and content
     """
     system_template = prompt_env.get_template("system.jinja2")
     user_template = prompt_env.get_template("user.jinja2")
 
-    system_prompt = system_template.render(language=language)
-    user_prompt = user_template.render(message=message, language=language)
+    system_prompt = system_template.render()
+    user_prompt = user_template.render(message=message)
 
     # 记录渲染结果到提示日志（与示例日志结构一致）
     log_prompt_rendering('system', system_prompt)
     log_prompt_rendering('user', user_prompt)
     # 可选：记录模板渲染信息（仅当 prompt_templates.log 存在时生效）
-    log_template_rendering('system.jinja2', {'language': language})
-    log_template_rendering('user.jinja2', {'message': message, 'language': language})
+    log_template_rendering('system.jinja2', {})
+    log_template_rendering('user.jinja2', {'message': message})
     return [
         {"role": "system", "content": system_prompt},
         {"role": "user", "content": user_prompt},
@@ -45,7 +38,6 @@ async def render_statement_extraction_prompt(
     include_dialogue_context: bool = False,
     dialogue_content: str | None = None,
     max_dialogue_chars: int | None = None,
-    language: str = "zh",
 ) -> str:
     """
     Renders the statement extraction prompt using the extract_statement.jinja2 template.
@@ -54,11 +46,6 @@ async def render_statement_extraction_prompt(
         chunk_content: The content of the chunk to process
         definitions: Label definitions for statement classification
         json_schema: JSON schema for the expected output format
-        granularity: Extraction granularity level (1-3)
-        include_dialogue_context: Whether to include full dialogue context
-        dialogue_content: Full dialogue content for context
-        max_dialogue_chars: Maximum characters for dialogue context
-        language: Language for output ("zh" for Chinese, "en" for English)
 
     Returns:
         Rendered prompt content as string
@@ -82,7 +69,6 @@ async def render_statement_extraction_prompt(
         granularity=granularity,
         include_dialogue_context=include_dialogue_context,
         dialogue_context=ctx,
-        language=language,
     )
     # 记录渲染结果到提示日志（与示例日志结构一致）
     log_prompt_rendering('statement extraction', rendered_prompt)
@@ -104,7 +90,6 @@ async def render_temporal_extraction_prompt(
     temporal_guide: dict,
     statement_guide: dict,
     json_schema: dict,
-    language: str = "zh",
 ) -> str:
     """
     Renders the temporal extraction prompt using the extract_temporal.jinja2 template.
@@ -115,7 +100,6 @@ async def render_temporal_extraction_prompt(
         temporal_guide: Guidance on temporal types.
         statement_guide: Guidance on statement types.
         json_schema: JSON schema for the expected output format.
-        language: Language for output ("zh" for Chinese, "en" for English)
 
     Returns:
         Rendered prompt content as a string.
@@ -127,7 +111,6 @@ async def render_temporal_extraction_prompt(
         temporal_guide=temporal_guide,
         statement_guide=statement_guide,
         json_schema=json_schema,
-        language=language,
     )
     # 记录渲染结果到提示日志（与示例日志结构一致）
     log_prompt_rendering('temporal extraction', rendered_prompt)
@@ -147,7 +130,6 @@ def render_entity_dedup_prompt(
     context: dict,
     json_schema: dict,
     disambiguation_mode: bool = False,
-    language: str = "zh",
 ) -> str:
     """
     Render the entity deduplication prompt using the entity_dedup.jinja2 template.
@@ -157,8 +139,6 @@ def render_entity_dedup_prompt(
         entity_b: Dict of entity B attributes
         context: Dict of computed signals (group/type gate, similarities, co-occurrence, relation statements)
         json_schema: JSON schema for the structured output (EntityDedupDecision)
-        disambiguation_mode: Whether to use disambiguation mode
-        language: Language for output ("zh" for Chinese, "en" for English)
 
     Returns:
         Rendered prompt content as string
@@ -177,7 +157,6 @@ def render_entity_dedup_prompt(
         relation_statements=context.get("relation_statements", []),
         json_schema=json_schema,
         disambiguation_mode=disambiguation_mode,
-        language=language,
     )
 
     # prompt_logger.info("\n=== RENDERED ENTITY DEDUP PROMPT ===")
@@ -198,14 +177,7 @@ def render_entity_dedup_prompt(
 
 #     Args:
 #         entity_a: Dict of entity A attributes
-async def render_triplet_extraction_prompt(
-    statement: str,
-    chunk_content: str,
-    json_schema: dict,
-    predicate_instructions: dict = None,
-    language: str = "zh",
-    ontology_types: "OntologyTypeList | None" = None,
-) -> str:
+async def render_triplet_extraction_prompt(statement: str, chunk_content: str, json_schema: dict, predicate_instructions: dict = None, language: str = "zh") -> str:
     """
     Renders the triplet extraction prompt using the extract_triplet.jinja2 template.
 
@@ -215,31 +187,17 @@ async def render_triplet_extraction_prompt(
         json_schema: JSON schema for the expected output format
         predicate_instructions: Optional predicate instructions
         language: The language to use for entity descriptions ("zh" for Chinese, "en" for English)
-        ontology_types: Optional OntologyTypeList containing predefined ontology types for entity classification
 
     Returns:
         Rendered prompt content as string
     """
     template = prompt_env.get_template("extract_triplet.jinja2")
-    
-    # 准备本体类型数据
-    ontology_type_section = ""
-    ontology_type_names = []
-    type_hierarchy_hints = []
-    if ontology_types and ontology_types.types:
-        ontology_type_section = ontology_types.to_prompt_section()
-        ontology_type_names = ontology_types.get_type_names()
-        type_hierarchy_hints = ontology_types.get_type_hierarchy_hints()
-    
     rendered_prompt = template.render(
         statement=statement,
         chunk_content=chunk_content,
         json_schema=json_schema,
         predicate_instructions=predicate_instructions,
-        language=language,
-        ontology_types=ontology_type_section,
-        ontology_type_names=ontology_type_names,
-        type_hierarchy_hints=type_hierarchy_hints,
+        language=language
     )
     # 记录渲染结果到提示日志（与示例日志结构一致）
     log_prompt_rendering('triplet extraction', rendered_prompt)
@@ -249,10 +207,7 @@ async def render_triplet_extraction_prompt(
         'chunk_content': 'str',
         'json_schema': 'TripletExtractionResponse.schema',
         'predicate_instructions': 'PREDICATE_DEFINITIONS',
-        'language': language,
-        'ontology_types': bool(ontology_type_section),
-        'ontology_type_count': len(ontology_type_names),
-        'type_hierarchy_hints_count': len(type_hierarchy_hints),
+        'language': language
     })
 
     return rendered_prompt
@@ -294,8 +249,7 @@ async def render_memory_summary_prompt(
 async def render_emotion_extraction_prompt(
     statement: str,
     extract_keywords: bool,
-    enable_subject: bool,
-    language: str = "zh"
+    enable_subject: bool
 ) -> str:
     """
     Renders the emotion extraction prompt using the extract_emotion.jinja2 template.
@@ -304,7 +258,6 @@ async def render_emotion_extraction_prompt(
         statement: The statement to analyze
         extract_keywords: Whether to extract emotion keywords
         enable_subject: Whether to enable subject classification
-        language: Language for output ("zh" for Chinese, "en" for English)
 
     Returns:
         Rendered prompt content as string
@@ -313,8 +266,7 @@ async def render_emotion_extraction_prompt(
     rendered_prompt = template.render(
         statement=statement,
         extract_keywords=extract_keywords,
-        enable_subject=enable_subject,
-        language=language
+        enable_subject=enable_subject
     )
     
     # 记录渲染结果到提示日志
@@ -331,8 +283,7 @@ async def render_emotion_extraction_prompt(
 async def render_emotion_suggestions_prompt(
     health_data: dict,
     patterns: dict,
-    user_profile: dict,
-    language: str = "zh"
+    user_profile: dict
 ) -> str:
     """
     Renders the emotion suggestions generation prompt using the generate_emotion_suggestions.jinja2 template.
@@ -341,7 +292,6 @@ async def render_emotion_suggestions_prompt(
         health_data: 情绪健康数据
         patterns: 情绪模式分析结果
         user_profile: 用户画像数据
-        language: 输出语言 ("zh" 中文, "en" 英文)
 
     Returns:
         Rendered prompt content as string
@@ -349,39 +299,18 @@ async def render_emotion_suggestions_prompt(
     import json
     
     # 预处理 emotion_distribution 为 JSON 字符串
-    # 如果是中文，将 emotion_distribution 的 key 翻译为中文
-    emotion_distribution = health_data.get('emotion_distribution', {})
-    if language == "zh":
-        emotion_type_zh = {
-            'joy': '喜悦', 'sadness': '悲伤', 'anger': '愤怒',
-            'fear': '恐惧', 'surprise': '惊讶', 'neutral': '中性'
-        }
-        emotion_distribution = {
-            emotion_type_zh.get(k, k): v for k, v in emotion_distribution.items()
-        }
     emotion_distribution_json = json.dumps(
-        emotion_distribution, 
+        health_data.get('emotion_distribution', {}), 
         ensure_ascii=False, 
         indent=2
     )
     
-    # 翻译 dominant_negative_emotion
-    dominant_negative_translated = None
-    dominant_neg = patterns.get('dominant_negative_emotion')
-    if dominant_neg and language == "zh":
-        emotion_type_zh_map = {
-            'sadness': '悲伤', 'anger': '愤怒', 'fear': '恐惧'
-        }
-        dominant_negative_translated = emotion_type_zh_map.get(dominant_neg, dominant_neg)
-    
     template = prompt_env.get_template("generate_emotion_suggestions.jinja2")
     rendered_prompt = template.render(
         health_data=health_data,
         patterns=patterns,
         user_profile=user_profile,
-        emotion_distribution_json=emotion_distribution_json,
-        language=language,
-        dominant_negative_translated=dominant_negative_translated
+        emotion_distribution_json=emotion_distribution_json
     )
     
     # 记录渲染结果到提示日志
@@ -399,8 +328,7 @@ async def render_emotion_suggestions_prompt(
 async def render_user_summary_prompt(
     user_id: str,
     entities: str,
-    statements: str,
-    language: str = "zh"
+    statements: str
 ) -> str:
     """
     Renders the user summary prompt using the user_summary.jinja2 template.
@@ -409,7 +337,6 @@ async def render_user_summary_prompt(
         user_id: User identifier
         entities: Core entities with frequency information
         statements: Representative statement samples
-        language: The language to use for summary generation ("zh" for Chinese, "en" for English)
 
     Returns:
         Rendered prompt content as string
@@ -418,8 +345,7 @@ async def render_user_summary_prompt(
     rendered_prompt = template.render(
         user_id=user_id,
         entities=entities,
-        statements=statements,
-        language=language
+        statements=statements
     )
     
     # 记录渲染结果到提示日志
@@ -428,8 +354,7 @@ async def render_user_summary_prompt(
     log_template_rendering('user_summary.jinja2', {
         'user_id': user_id,
         'entities_len': len(entities),
-        'statements_len': len(statements),
-        'language': language
+        'statements_len': len(statements)
     })
     
     return rendered_prompt
@@ -438,8 +363,7 @@ async def render_user_summary_prompt(
 async def render_memory_insight_prompt(
     domain_distribution: str = None,
     active_periods: str = None,
-    social_connections: str = None,
-    language: str = "zh"
+    social_connections: str = None
 ) -> str:
     """
     Renders the memory insight prompt using the memory_insight.jinja2 template.
@@ -448,7 +372,6 @@ async def render_memory_insight_prompt(
         domain_distribution: 核心领域分布信息
         active_periods: 活跃时段信息
         social_connections: 社交关联信息
-        language: The language to use for report generation ("zh" for Chinese, "en" for English)
 
     Returns:
         Rendered prompt content as string
@@ -457,8 +380,7 @@ async def render_memory_insight_prompt(
     rendered_prompt = template.render(
         domain_distribution=domain_distribution,
         active_periods=active_periods,
-        social_connections=social_connections,
-        language=language
+        social_connections=social_connections
     )
     
     # 记录渲染结果到提示日志
@@ -467,8 +389,7 @@ async def render_memory_insight_prompt(
     log_template_rendering('memory_insight.jinja2', {
         'has_domain_distribution': bool(domain_distribution),
         'has_active_periods': bool(active_periods),
-        'has_social_connections': bool(social_connections),
-        'language': language
+        'has_social_connections': bool(social_connections)
     })
     
     return rendered_prompt
@@ -503,8 +424,7 @@ async def render_ontology_extraction_prompt(
     scenario: str,
     domain: str | None = None,
     max_classes: int = 15,
-    json_schema: dict | None = None,
-    language: str = "zh"
+    json_schema: dict | None = None
 ) -> str:
     """
     Renders the ontology extraction prompt using the extract_ontology.jinja2 template.
@@ -514,7 +434,6 @@ async def render_ontology_extraction_prompt(
         domain: Optional domain hint for the scenario (e.g., "Healthcare", "Education")
         max_classes: Maximum number of classes to extract (default: 15)
         json_schema: JSON schema for the expected output format
-        language: Language for output ("zh" for Chinese, "en" for English)
 
     Returns:
         Rendered prompt content as string
@@ -524,8 +443,7 @@ async def render_ontology_extraction_prompt(
         scenario=scenario,
         domain=domain,
         max_classes=max_classes,
-        json_schema=json_schema,
-        language=language
+        json_schema=json_schema
     )
     
     # 记录渲染结果到提示日志
@@ -535,8 +453,7 @@ async def render_ontology_extraction_prompt(
         'scenario_len': len(scenario) if scenario else 0,
         'domain': domain,
         'max_classes': max_classes,
-        'json_schema': 'OntologyExtractionResponse.schema',
-        'language': language
+        'json_schema': 'OntologyExtractionResponse.schema'
     })
     
     return rendered_prompt

api/app/core/memory/utils/prompt/prompts/entity_dedup.jinja2

@@ -1,16 +1,9 @@
-===Task===
-{% if language == "zh" %}
+===任务===
 你是一个实体去重/消歧判断助手。你将被提供两个实体的详细信息和上下文，请严格根据指引判断它们是否是同一真实世界实体，并在需要时进行类型消歧。
 
 模式: {{ '消歧模式' if disambiguation_mode else '去重模式' }}
-{% else %}
-You are an entity deduplication/disambiguation assistant. You will be provided with detailed information and context for two entities. Please strictly follow the guidelines to determine whether they are the same real-world entity and perform type disambiguation when necessary.
 
-Mode: {{ 'Disambiguation Mode' if disambiguation_mode else 'Deduplication Mode' }}
-{% endif %}
-
-===Input===
-{% if language == "zh" %}
+===输入===
 实体A:
 - 名称: "{{ entity_a.name | default('') }}"
 - 类型: "{{ entity_a.entity_type | default('') }}"
@@ -41,41 +34,8 @@ Mode: {{ 'Disambiguation Mode' if disambiguation_mode else 'Deduplication Mode'
 {% for s in relation_statements %}
   - {{ s }}
 {% endfor %}
-{% else %}
-Entity A:
-- Name: "{{ entity_a.name | default('') }}"
-- Type: "{{ entity_a.entity_type | default('') }}"
-- Description: "{{ entity_a.description | default('') }}"
-- Aliases: {{ entity_a.aliases | default([]) }}
-{# TODO: fact_summary feature temporarily disabled, to be enabled after future development #}
-{# - Summary: "{{ entity_a.fact_summary | default('') }}" #}
-- Connection Strength: "{{ entity_a.connect_strength | default('') }}"
 
-Entity B:
-- Name: "{{ entity_b.name | default('') }}"
-- Type: "{{ entity_b.entity_type | default('') }}"
-- Description: "{{ entity_b.description | default('') }}"
-- Aliases: {{ entity_b.aliases | default([]) }}
-{# TODO: fact_summary feature temporarily disabled, to be enabled after future development #}
-{# - Summary: "{{ entity_b.fact_summary | default('') }}" #}
-- Connection Strength: "{{ entity_b.connect_strength | default('') }}"
-
-Context:
-- Same Group: {{ same_group | default(false) }}
-- Type Consistent or Unknown: {{ type_ok | default(false) }}
-- Type Similarity (0-1): {{ type_similarity | default(0.0) }}
-- Name Text Similarity (0-1): {{ name_text_sim | default(0.0) }}
-- Name Embedding Similarity (0-1): {{ name_embed_sim | default(0.0) }}
-- Name Contains Relationship: {{ name_contains | default(false) }}
-- Context Co-occurrence (same statement refers to both): {{ co_occurrence | default(false) }}
-- Related Relationship Statements (from entity-entity edges):
-{% for s in relation_statements %}
-  - {{ s }}
-{% endfor %}
-{% endif %}
-
-===Guidelines===
-{% if language == "zh" %}
+===判定指引===
 {% if disambiguation_mode %}
 - 这是"同名但类型不同"的消歧场景。请判断两者是否指向同一真实世界实体。
 - 综合名称文本/向量相似度、别名、描述、摘要与上下文关系（同源与关系陈述）进行判断。
@@ -108,43 +68,8 @@ Context:
   - 优先保留连接强度更强(strong/both)者；其余相同则保留描述/摘要更丰富者；再相同时保留实体A（canonical_idx=0）。
 - **注意**：别名（aliases）已在三元组提取阶段获取，合并时会自动整合，无需在此阶段提取。
 {% endif %}
-{% else %}
-{% if disambiguation_mode %}
-- This is a disambiguation scenario for "same name but different types". Please determine whether they refer to the same real-world entity.
-- Make judgments based on name text/vector similarity, aliases, descriptions, summaries, and contextual relationships (co-occurrence and relationship statements).
-- **Alias Handling (High Priority)**: 
-  * If the alias lists of both entities have intersections, this is a strong signal of identity
-  * If one entity's name appears in another entity's aliases, it should be considered a high-confidence match
-  * If one entity's alias exactly matches another entity's name, it should be considered a high-confidence match
-  * Alias matching weight should be higher than pure name text similarity
-- If unable to determine with sufficient confidence, handle conservatively: do not merge, and suggest blocking this pair in other fuzzy/heuristic merges (block_pair=true).
-- If merging is needed (should_merge=true), select the "canonical entity" (canonical_idx) and **must** provide a suggested unified type (suggested_type).
-- **Type Unification Principles (Important)**:
-  * Prioritize more specific and accurate types (e.g., HistoricalPeriod over Organization, MilitaryCapability over Concept)
-  * If both types are specific but different, choose the type that best matches the entity's core semantics
-  * Generic types (Concept, Phenomenon, Condition, State, Attribute, Event) have lower priority than domain-specific types
-  * Suggested type must be consistent with context and entity description
-- Canonical entity priority: higher connection strength (strong/both); if equal, retain the one with richer description/summary; if still equal, retain Entity A (canonical_idx=0).
-- **Note**: Aliases are already obtained during triplet extraction and will be automatically integrated during merging; no need to extract at this stage.
-{% else %}
-- If entity types are the same or either is UNKNOWN/empty, can proceed as candidates; if types clearly conflict (e.g., person vs. item), unless aliases and descriptions are highly consistent, determine as different entities.
-- **Alias Matching Priority (Highest Priority)**: 
-  * If Entity A's name exactly matches any of Entity B's aliases, it should be considered a high-confidence match
-  * If Entity B's name exactly matches any of Entity A's aliases, it should be considered a high-confidence match
-  * If any alias of Entity A exactly matches any alias of Entity B, it should be considered a high-confidence match
-  * When aliases match exactly, merging should be considered even if name text similarity is low
-  * Alias matching confidence should be higher than pure name similarity matching
-- Make judgments based on name text/vector similarity, aliases, descriptions, summaries, and contextual relationships.
-- When context co-occurs or there are clear relationship statements supporting identity (e.g., the same object is repeatedly mentioned or aliases correspond), the judgment threshold can be moderately lowered.
-- Conservative decision: when unable to determine with sufficient confidence, do not merge (same_entity=false).
-- If merging is needed, select the "canonical entity to retain" (canonical_idx) as the more appropriate one:
-  - Prioritize retaining the one with stronger connection strength (strong/both); if equal, retain the one with richer description/summary; if still equal, retain Entity A (canonical_idx=0).
-- **Note**: Aliases are already obtained during triplet extraction and will be automatically integrated during merging; no need to extract at this stage.
-{% endif %}
-{% endif %}
 
 **Output format**
-{% if language == "zh" %}
 {% if disambiguation_mode %}
 返回JSON格式，必须包含以下字段：
 {
@@ -178,41 +103,6 @@ Context:
 - confidence: 决策的置信度，范围0.0-1.0
 - reason: 决策理由的简短说明
 {% endif %}
-{% else %}
-{% if disambiguation_mode %}
-Return JSON format with the following required fields:
-{
-  "should_merge": boolean,
-  "canonical_idx": 0 or 1,
-  "confidence": float (0.0-1.0),
-  "block_pair": boolean,
-  "suggested_type": "string or null",
-  "reason": "string"
-}
-
-**Field Descriptions**:
-- should_merge: Whether these two entities should be merged (true/false)
-- canonical_idx: Index of the canonical entity, 0 for Entity A, 1 for Entity B
-- confidence: Confidence level of the decision, range 0.0-1.0
-- block_pair: Whether to block this pair in other fuzzy/heuristic merges (true/false)
-- suggested_type: Suggested unified type (string or null)
-- reason: Brief explanation of the decision
-{% else %}
-Return JSON format with the following required fields:
-{
-  "same_entity": boolean,
-  "canonical_idx": 0 or 1,
-  "confidence": float (0.0-1.0),
-  "reason": "string"
-}
-
-**Field Descriptions**:
-- same_entity: Whether the two entities refer to the same real-world entity (true/false)
-- canonical_idx: Index of the canonical entity, 0 for Entity A, 1 for Entity B
-- confidence: Confidence level of the decision, range 0.0-1.0
-- reason: Brief explanation of the decision
-{% endif %}
-{% endif %}
 
 **CRITICAL JSON FORMATTING REQUIREMENTS:**
 1. Use only standard ASCII double quotes (") for JSON structure - never use Chinese quotation marks ("") or other Unicode quotes
@@ -220,9 +110,5 @@ Return JSON format with the following required fields:
 3. Do not include line breaks within JSON string values
 4. Test your JSON output mentally to ensure it can be parsed correctly
 
-{% if language == "zh" %}
-输出语言应始终与输入语言相同。
-{% else %}
 The output language should always be the same as the input language.
-{% endif %}
 {{ json_schema }}

api/app/core/memory/utils/prompt/prompts/extracat_Pruning.jinja2

@@ -17,18 +17,9 @@
 #}
 
 {% set scene_instructions = {
-  'education': {
-    'zh': '教育场景：教学、课程、考试、作业、老师/学生互动、学习资源、学校管理等。',
-    'en': 'Education Scenario: Teaching, courses, exams, homework, teacher/student interaction, learning resources, school management, etc.'
-  },
-  'online_service': {
-    'zh': '在线客服场景：客户咨询、问题排查、服务工单、售后支持、订单/退款、工单升级等。',
-    'en': 'Online Service Scenario: Customer inquiries, troubleshooting, service tickets, after-sales support, orders/refunds, ticket escalation, etc.'
-  },
-  'outbound': {
-    'zh': '外呼场景：电话外呼、邀约、调研问卷、线索跟进、对话脚本、回访记录等。',
-    'en': 'Outbound Scenario: Outbound calls, invitations, survey questionnaires, lead follow-up, call scripts, follow-up records, etc.'
-  }
+  'education': '教育场景：教学、课程、考试、作业、老师/学生互动、学习资源、学校管理等。',
+  'online_service': '在线客服场景：客户咨询、问题排查、服务工单、售后支持、订单/退款、工单升级等。',
+  'outbound': '外呼场景：电话外呼、邀约、调研问卷、线索跟进、对话脚本、回访记录等。'
 } %}
 
 {% set scene_key = pruning_scene %}
@@ -36,9 +27,8 @@
 {% set scene_key = 'education' %}
 {% endif %}
 
-{% set instruction = scene_instructions[scene_key][language] if language in ['zh', 'en'] else scene_instructions[scene_key]['zh'] %}
+{% set instruction = scene_instructions[scene_key] %}
 
-{% if language == "zh" %}
 请在下方对话全文基础上，按该场景进行一次性抽取并判定相关性：
 场景说明：{{ instruction }}
 
@@ -56,24 +46,4 @@
   "contacts": [<string>...],
   "addresses": [<string>...],
   "keywords": [<string>...]
-}
-{% else %}
-Based on the full dialogue below, perform one-time extraction and relevance determination according to this scenario:
-Scenario Description: {{ instruction }}
-
-Full Dialogue:
-"""
-{{ dialog_text }}
-"""
-
-Output strict JSON only (fixed keys, order doesn't matter):
-{
-  "is_related": <true or false>,
-  "times": [<string>...],
-  "ids": [<string>...],
-  "amounts": [<string>...],
-  "contacts": [<string>...],
-  "addresses": [<string>...],
-  "keywords": [<string>...]
-}
-{% endif %}
+}

api/app/core/memory/utils/prompt/prompts/extract_emotion.jinja2

@@ -1,4 +1,3 @@
-{% if language == "zh" %}
 你是一个专业的情绪分析专家。请分析以下陈述句的情绪信息。
 
 陈述句：{{ statement }}
@@ -56,62 +55,3 @@
 - 主体分类要准确，优先识别用户本人（self）
 
 请以 JSON 格式返回结果。
-{% else %}
-You are a professional emotion analysis expert. Please analyze the emotional information in the following statement.
-
-Statement: {{ statement }}
-
-Please extract the following information:
-
-1. emotion_type (Emotion Type):
-   - joy: happiness, delight, pleasure, satisfaction, cheerfulness
-   - sadness: sorrow, grief, disappointment, depression, regret
-   - anger: rage, irritation, dissatisfaction, annoyance, frustration
-   - fear: anxiety, worry, concern, nervousness, apprehension
-   - surprise: astonishment, amazement, shock, wonder
-   - neutral: neutral, objective statement, no obvious emotion
-
-2. emotion_intensity (Emotion Intensity):
-   - 0.0-0.3: weak emotion
-   - 0.3-0.7: moderate emotion
-   - 0.7-1.0: strong emotion
-
-{% if extract_keywords %}
-3. emotion_keywords (Emotion Keywords):
-   - Words directly expressing emotions in the original sentence
-   - Extract up to 3 keywords
-   - Return empty list if no obvious emotion words
-{% else %}
-3. emotion_keywords (Emotion Keywords):
-   - Return empty list
-{% endif %}
-
-{% if enable_subject %}
-4. emotion_subject (Emotion Subject):
-   - self: user's own emotions (includes "I", "we", "us" and other first-person pronouns)
-   - other: others' emotions (includes names, "he/she" and other third-person pronouns)
-   - object: evaluation of things (for products, places, events, etc.)
-   
-   Note:
-   - If multiple subjects are present, prioritize identifying the user (self)
-   - If the subject cannot be clearly determined, default to self
-
-5. emotion_target (Emotion Target):
-   - If there is a clear emotion target, extract its name
-   - If there is no clear target, return null
-{% else %}
-4. emotion_subject (Emotion Subject):
-   - Default to self
-
-5. emotion_target (Emotion Target):
-   - Return null
-{% endif %}
-
-Notes:
-- If the statement is an objective factual statement with no obvious emotion, mark as neutral
-- Emotion intensity should match the context, do not over-interpret
-- Emotion keywords should be accurate, do not add words not in the original sentence
-- Subject classification should be accurate, prioritize identifying the user (self)
-
-Please return the result in JSON format.
-{% endif %}

api/app/core/memory/utils/prompt/prompts/extract_ontology.jinja2

@@ -1,100 +1,19 @@
 ===Task===
-{% if language == "zh" %}
-从给定的场景描述中提取本体类，遵循本体工程标准。
-{% else %}
 Extract ontology classes from the given scenario description following ontology engineering standards.
-{% endif %}
 
 ===Role===
-{% if language == "zh" %}
-你是一位专业的本体工程师，精通知识表示和OWL（Web本体语言）标准。你的任务是从场景描述中识别抽象类和概念，而不是具体实例。
-{% else %}
 You are a professional ontology engineer with expertise in knowledge representation and OWL (Web Ontology Language) standards. Your task is to identify abstract classes and concepts from scenario descriptions, not concrete instances.
-{% endif %}
 
 ===Scenario Description===
 {{ scenario }}
 
 {% if domain -%}
 ===Domain Hint===
-{% if language == "zh" %}
-此场景属于 **{{ domain }}** 领域。提取类时请考虑领域特定的概念和术语。
-{% else %}
 This scenario belongs to the **{{ domain }}** domain. Consider domain-specific concepts and terminology when extracting classes.
-{% endif %}
-{%- endif %}
-
-===Output Language===
-{% if language == "en" -%}
-**IMPORTANT: All output content MUST be in English.**
-- Class names (name field): English in PascalCase format
-- Chinese name (name_chinese field): Provide Chinese translation
-- Descriptions: MUST be in English
-- Examples: MUST be in English
-- Domain: MUST be in English
-{%- else -%}
-**IMPORTANT: Output content language requirements:**
-- Class names (name field): English in PascalCase format
-- Chinese name (name_chinese field): Chinese translation
-- Descriptions: MUST be in Chinese (中文)
-- Examples: MUST be in Chinese (中文)
-- Domain: Can be in Chinese or English
 {%- endif %}
 
 ===Extraction Rules===
 
-{% if language == "zh" %}
-**1. 抽象类，而非实例：**
-- 提取抽象类别和概念（如"医疗程序"、"患者"、"诊断"）
-- 不要提取具体实例（如"张三"、"301房间"、"2024-01-15"）
-- 以"事物的类型"而非"具体事物"的角度思考
-
-**2. 命名规范：**
-- "name"字段使用中文名称
-- 使用清晰、描述性的中文名称
-- 示例："医疗程序"、"医疗服务提供者"、"诊断测试"
-
-**3. 领域相关性：**
-- 专注于场景领域的核心类
-- 优先提取代表关键概念、实体或关系的类
-- 避免过于通用的类（如"事物"、"对象"），除非它们在领域中有特定含义
-
-**4. 类数量：**
-- 提取5到{{ max_classes }}个类
-- 目标是覆盖场景主要概念的平衡集合
-- 质量优于数量：优先选择定义明确的类
-
-**5. 清晰的描述：**
-- 用中文提供简洁、信息丰富的描述（最多500字）
-- 描述类代表什么，而不是具体实例
-- 使用清晰、自然的中文解释类在领域中的作用
-
-**6. 具体示例：**
-- 为每个类提供2-5个中文具体实例示例
-- 示例应该是该类的具体、现实的实例
-- 示例有助于阐明类的范围和含义
-- 示例格式：["示例1", "示例2", "示例3"]
-
-**7. 类层次结构：**
-- 在适用的情况下识别父子关系
-- 使用parent_class字段指定继承关系
-- 父类必须是提取的类之一或标准OWL类
-- 顶级类的parent_class设为null
-
-**8. 实体类型：**
-- 为每个类分配适当的entity_type
-- 常见类型："人物"、"组织"、"地点"、"事件"、"概念"、"过程"、"对象"、"角色"
-- 选择最具体的适用类型
-
-**9. 语言一致性：**
-- 所有字段内容必须使用中文
-- "name"字段使用中文名称
-- "description"字段使用中文描述
-- "examples"字段使用中文示例
-- "entity_type"字段使用中文类型名称
-- "domain"字段使用中文领域名称
-
-{% else %}
 **1. Abstract Classes, Not Instances:**
 - Extract abstract categories and concepts (e.g., "MedicalProcedure", "Patient", "Diagnosis")
 - Do NOT extract concrete instances (e.g., "John Smith", "Room 301", "2024-01-15")
@@ -105,6 +24,8 @@ This scenario belongs to the **{{ domain }}** domain. Consider domain-specific c
 - Examples: "MedicalProcedure", "HealthcareProvider", "DiagnosticTest"
 - Avoid: "medical procedure", "healthcare_provider", "diagnostic-test"
 - Use clear, descriptive names in English
+- Avoid abbreviations unless they are standard in the domain (e.g., "API", "DNA")
+- Provide Chinese translation in the "name_chinese" field (e.g., "医疗程序", "医疗服务提供者", "诊断测试")
 
 **3. Domain Relevance:**
 - Focus on classes that are central to the scenario's domain
@@ -116,31 +37,17 @@ This scenario belongs to the **{{ domain }}** domain. Consider domain-specific c
 - Aim for a balanced set covering the main concepts in the scenario
 - Quality over quantity: prefer well-defined classes over exhaustive lists
 
-
 **5. Clear Descriptions:**
-{% if language == "en" -%}
-- Provide concise, informative descriptions in English (max 500 characters)
+- Provide concise, informative descriptions in Chinese (max 500 characters)
 - Describe what the class represents, not specific instances
-- Use clear, natural English language that explains the class's role in the domain
-{%- else -%}
-- Provide concise, informative descriptions in English (max 500 characters)
-- Describe what the class represents, not specific instances
-- Use clear, natural English language
-{%- endif %}
+- Use clear, natural Chinese language that explains the class's role in the domain
 
 **6. Concrete Examples:**
-{% if language == "en" -%}
-- Provide 2-5 concrete instance examples in English for each class
+- Provide 2-5 concrete instance examples in Chinese for each class
 - Examples should be specific, realistic instances of the class
 - Examples help clarify the class's scope and meaning
-- Use natural English language for examples
-- Example format: ["Example1", "Example2", "Example3"]
-{%- else -%}
-- Provide 2-5 concrete instance examples in English for each class
-- Examples should be specific, realistic instances of the class
-- Examples help clarify the class's scope and meaning
-- Example format: ["Example1", "Example2", "Example3"]
-{%- endif %}
+- Use natural Chinese language for examples
+- Example format: ["示例1", "示例2", "示例3"]
 
 **7. Class Hierarchy:**
 - Identify parent-child relationships where applicable
@@ -153,121 +60,20 @@ This scenario belongs to the **{{ domain }}** domain. Consider domain-specific c
 - Common types: "Person", "Organization", "Location", "Event", "Concept", "Process", "Object", "Role"
 - Choose the most specific type that applies
 
-**9. Language Consistency:**
-- All field content must be in English
-- "name" field uses English PascalCase names
-- "description" field uses English descriptions
-- "examples" field uses English examples
-- "entity_type" field uses English type names
-- "domain" field uses English domain names
-{% endif %}
+**9. OWL Reserved Words:**
+- Do NOT use OWL reserved words as class names
+- Reserved words include: "Thing", "Nothing", "Class", "Property", "ObjectProperty", "DatatypeProperty", "AnnotationProperty", "Ontology", "Individual", "Literal"
+- If a reserved word is needed, add a domain-specific prefix (e.g., "MedicalClass" instead of "Class")
+
+**10. Language Consistency:**
+- Extract all class names in English (PascalCase format) for the "name" field
+- Provide Chinese translation for class names in the "name_chinese" field
+- Descriptions MUST be in Chinese (中文)
+- Examples MUST be in Chinese (中文)
+- Use clear, natural Chinese language for descriptions and examples
 
 ===Examples===
 
-{% if language == "zh" %}
-**示例1（医疗领域）：**
-场景："一家医院管理患者记录，安排预约，并协调医疗程序。医生诊断病情并开具治疗方案。"
-
-输出：
-{
-  "classes": [
-    {
-      "name": "患者",
-      "description": "在医疗机构接受医疗护理或治疗的人",
-      "examples": ["张三", "李四", "患有糖尿病的老年患者"],
-      "parent_class": null,
-      "entity_type": "人物",
-      "domain": "医疗"
-    },
-    {
-      "name": "医疗程序",
-      "description": "为医疗诊断或治疗而执行的系统性操作流程",
-      "examples": ["手术", "血液检查", "X光检查", "疫苗接种"],
-      "parent_class": null,
-      "entity_type": "过程",
-      "domain": "医疗"
-    },
-    {
-      "name": "诊断",
-      "description": "基于症状和检查结果对疾病或状况的识别",
-      "examples": ["糖尿病诊断", "癌症诊断", "流感诊断"],
-      "parent_class": null,
-      "entity_type": "概念",
-      "domain": "医疗"
-    },
-    {
-      "name": "医生",
-      "description": "诊断和治疗患者的持证医疗专业人员",
-      "examples": ["全科医生", "外科医生", "心脏病专家"],
-      "parent_class": null,
-      "entity_type": "角色",
-      "domain": "医疗"
-    },
-    {
-      "name": "治疗",
-      "description": "为治愈或管理疾病状况而提供的医疗护理或疗法",
-      "examples": ["药物治疗", "物理治疗", "化疗", "手术治疗"],
-      "parent_class": null,
-      "entity_type": "过程",
-      "domain": "医疗"
-    }
-  ],
-  "domain": "医疗"
-}
-
-**示例2（教育领域）：**
-场景："一所大学提供由教授教授的课程。学生注册项目，参加讲座，并完成作业以获得学位。"
-
-输出：
-{
-  "classes": [
-    {
-      "name": "学生",
-      "description": "在教育机构注册学习的人",
-      "examples": ["本科生", "研究生", "在职学生"],
-      "parent_class": null,
-      "entity_type": "角色",
-      "domain": "教育"
-    },
-    {
-      "name": "课程",
-      "description": "涵盖特定学科或主题的结构化教育课程",
-      "examples": ["计算机科学导论", "微积分I", "世界历史"],
-      "parent_class": null,
-      "entity_type": "概念",
-      "domain": "教育"
-    },
-    {
-      "name": "教授",
-      "description": "教授课程并进行研究的学术教师",
-      "examples": ["助理教授", "副教授", "正教授"],
-      "parent_class": null,
-      "entity_type": "角色",
-      "domain": "教育"
-    },
-    {
-      "name": "学术项目",
-      "description": "通向学位或证书的结构化课程体系",
-      "examples": ["理学学士", "文学硕士", "博士项目"],
-      "parent_class": null,
-      "entity_type": "概念",
-      "domain": "教育"
-    },
-    {
-      "name": "作业",
-      "description": "分配给学生以评估学习成果的任务或项目",
-      "examples": ["论文", "习题集", "研究报告", "实验报告"],
-      "parent_class": null,
-      "entity_type": "对象",
-      "domain": "教育"
-    }
-  ],
-  "domain": "教育"
-}
-
-{% else %}
-
-{% if language == "en" -%}
 **Example 1 (Healthcare Domain):**
 Scenario: "A hospital manages patient records, schedules appointments, and coordinates medical procedures. Doctors diagnose conditions and prescribe treatments."
 
@@ -277,8 +83,8 @@ Output:
     {
       "name": "Patient",
       "name_chinese": "患者",
-      "description": "A person who receives medical care or treatment at a healthcare facility",
-      "examples": ["Outpatient", "Inpatient", "Emergency patient", "Chronic disease patient"],
+      "description": "在医疗机构接受医疗护理或治疗的人",
+      "examples": ["张三", "李四", "患有糖尿病的老年患者"],
       "parent_class": null,
       "entity_type": "Person",
       "domain": "Healthcare"
@@ -286,8 +92,8 @@ Output:
     {
       "name": "MedicalProcedure",
       "name_chinese": "医疗程序",
-      "description": "A systematic operation or process performed for medical diagnosis or treatment",
-      "examples": ["Surgery", "Blood test", "X-ray examination", "Vaccination"],
+      "description": "为医疗诊断或治疗而执行的系统性操作流程",
+      "examples": ["手术", "血液检查", "X光检查", "疫苗接种"],
       "parent_class": null,
       "entity_type": "Process",
       "domain": "Healthcare"
@@ -295,8 +101,8 @@ Output:
     {
       "name": "Diagnosis",
       "name_chinese": "诊断",
-      "description": "The identification of a disease or condition based on symptoms and examination results",
-      "examples": ["Diabetes diagnosis", "Cancer diagnosis", "Flu diagnosis"],
+      "description": "基于症状和检查结果对疾病或状况的识别",
+      "examples": ["糖尿病诊断", "癌症诊断", "流感诊断"],
       "parent_class": null,
       "entity_type": "Concept",
       "domain": "Healthcare"
@@ -304,8 +110,8 @@ Output:
     {
       "name": "Doctor",
       "name_chinese": "医生",
-      "description": "A licensed medical professional who diagnoses and treats patients",
-      "examples": ["General practitioner", "Surgeon", "Cardiologist"],
+      "description": "诊断和治疗患者的持证医疗专业人员",
+      "examples": ["全科医生", "外科医生", "心脏病专家"],
       "parent_class": null,
       "entity_type": "Role",
       "domain": "Healthcare"
@@ -313,8 +119,8 @@ Output:
     {
       "name": "Treatment",
       "name_chinese": "治疗",
-      "description": "Medical care or therapy provided to cure or manage a disease condition",
-      "examples": ["Medication therapy", "Physical therapy", "Chemotherapy", "Surgical treatment"],
+      "description": "为治愈或管理疾病状况而提供的医疗护理或疗法",
+      "examples": ["药物治疗", "物理治疗", "化疗", "手术治疗"],
       "parent_class": null,
       "entity_type": "Process",
       "domain": "Healthcare"
@@ -323,56 +129,6 @@ Output:
   "domain": "Healthcare",
   "namespace": "http://example.org/healthcare#"
 }
-{%- else -%}
-**Example 1 (Healthcare Domain):**
-Scenario: "A hospital manages patient records, schedules appointments, and coordinates medical procedures. Doctors diagnose conditions and prescribe treatments."
-
-Output:
-{
-  "classes": [
-    {
-      "name": "Patient",
-      "description": "A person receiving medical care or treatment at a healthcare facility",
-      "examples": ["John Smith", "Jane Doe", "Elderly patient with diabetes"],
-      "parent_class": null,
-      "entity_type": "Person",
-      "domain": "Healthcare"
-    },
-    {
-      "name": "MedicalProcedure",
-      "description": "A systematic operation performed for medical diagnosis or treatment",
-      "examples": ["Surgery", "Blood test", "X-ray examination", "Vaccination"],
-      "parent_class": null,
-      "entity_type": "Process",
-      "domain": "Healthcare"
-    },
-    {
-      "name": "Diagnosis",
-      "description": "Identification of a disease or condition based on symptoms and examination results",
-      "examples": ["Diabetes diagnosis", "Cancer diagnosis", "Flu diagnosis"],
-      "parent_class": null,
-      "entity_type": "Concept",
-      "domain": "Healthcare"
-    },
-    {
-      "name": "Doctor",
-      "description": "A licensed medical professional who diagnoses and treats patients",
-      "examples": ["General practitioner", "Surgeon", "Cardiologist"],
-      "parent_class": null,
-      "entity_type": "Role",
-      "domain": "Healthcare"
-    },
-    {
-      "name": "Treatment",
-      "description": "Medical care or therapy provided to cure or manage a disease condition",
-      "examples": ["Medication therapy", "Physical therapy", "Chemotherapy", "Surgical treatment"],
-      "parent_class": null,
-      "entity_type": "Process",
-      "domain": "Healthcare"
-    }
-  ],
-  "domain": "Healthcare"
-}
 
 **Example 2 (Education Domain):**
 Scenario: "A university offers courses taught by professors. Students enroll in programs, attend lectures, and complete assignments to earn degrees."
@@ -382,49 +138,62 @@ Output:
   "classes": [
     {
       "name": "Student",
-      "description": "A person enrolled in an educational institution for learning",
-      "examples": ["Undergraduate student", "Graduate student", "Part-time student"],
+      "name_chinese": "学生",
+      "description": "在教育机构注册学习的人",
+      "examples": ["本科生", "研究生", "在职学生"],
       "parent_class": null,
       "entity_type": "Role",
       "domain": "Education"
     },
     {
       "name": "Course",
-      "description": "A structured educational program covering a specific subject or topic",
-      "examples": ["Introduction to Computer Science", "Calculus I", "World History"],
+      "name_chinese": "课程",
+      "description": "涵盖特定学科或主题的结构化教育课程",
+      "examples": ["计算机科学导论", "微积分I", "世界历史"],
       "parent_class": null,
       "entity_type": "Concept",
       "domain": "Education"
     },
     {
       "name": "Professor",
-      "description": "An academic teacher who teaches courses and conducts research",
-      "examples": ["Assistant professor", "Associate professor", "Full professor"],
+      "name_chinese": "教授",
+      "description": "教授课程并进行研究的学术教师",
+      "examples": ["助理教授", "副教授", "正教授"],
       "parent_class": null,
       "entity_type": "Role",
       "domain": "Education"
     },
     {
       "name": "AcademicProgram",
-      "description": "A structured curriculum leading to a degree or certificate",
-      "examples": ["Bachelor of Science", "Master of Arts", "PhD program"],
+      "name_chinese": "学术项目",
+      "description": "通向学位或证书的结构化课程体系",
+      "examples": ["理学学士", "文学硕士", "博士项目"],
       "parent_class": null,
       "entity_type": "Concept",
       "domain": "Education"
     },
     {
       "name": "Assignment",
-      "description": "A task or project assigned to students to assess learning outcomes",
-      "examples": ["Essay", "Problem set", "Research paper", "Lab report"],
+      "name_chinese": "作业",
+      "description": "分配给学生以评估学习成果的任务或项目",
+      "examples": ["论文", "习题集", "研究报告", "实验报告"],
       "parent_class": null,
       "entity_type": "Object",
       "domain": "Education"
+    },
+    {
+      "name": "Lecture",
+      "name_chinese": "讲座",
+      "description": "由教师进行的教育性演讲或讲座",
+      "examples": ["入门讲座", "客座讲座", "在线讲座"],
+      "parent_class": null,
+      "entity_type": "Event",
+      "domain": "Education"
     }
   ],
-  "domain": "Education"
+  "domain": "Education",
+  "namespace": "http://example.org/education#"
 }
-{% endif %}
-{% endif %}
 
 ===Output Format===
 
@@ -434,12 +203,8 @@ Output:
 - Escape quotation marks in text with backslashes (\")
 - Ensure proper string closure and comma separation
 - No line breaks within JSON string values
+- All class names must be in PascalCase format
 - All class names must be unique (case-insensitive)
 - Extract between 5 and {{ max_classes }} classes
-{% if language == "zh" %}
-- 所有字段内容必须使用中文
-{% else %}
-- All field content must be in English
-{% endif %}
 
 {{ json_schema }}

api/app/core/memory/utils/prompt/prompts/extract_statement.jinja2

@@ -5,13 +5,8 @@
 
 ===Tasks===
 
-{% if language == "zh" %}
-你的任务是根据详细的提取指南，从提供的对话片段中识别和提取陈述句。
-每个陈述句必须按照下面提到的标准进行标记。
-{% else %}
 Your task is to identify and extract declarative statements from the provided conversational chunk based on the detailed extraction guidelines. 
 Each statement must be labeled as per the criteria mentioned below.
-{% endif %}
 
 ===Inputs===
 {% if inputs %}
@@ -22,32 +17,6 @@ Each statement must be labeled as per the criteria mentioned below.
 
 
 ===Extraction Instructions===
-{% if language == "zh" %}
-{% if granularity %}
-{% if granularity == 3 %}
-原子化和清晰：构建陈述句以清楚地显示单一的主谓宾关系。最好有多个较小的陈述句，而不是一个复杂的陈述句。
-上下文独立：陈述句必须在不需要阅读整个对话的情况下可以理解。
-{% elif granularity == 2 %}
-在句子级别提取陈述句。每个陈述句应对应一个单一、完整的思想（通常是来源中的一个完整句子），但要重新表述以获得最大的清晰度，删除对话填充词（例如，"嗯"、"像"、感叹词）。
-{% elif granularity == 1 %}
-仅提取精华句子，并将片段总结为多个独立的陈述句，每个陈述句关注事实陈述、用户偏好、关系和显著的时间上下文。
-{% endif %}
-{% endif %}
-
-上下文解析要求：
-- 将指示代词（"那个"、"这个"、"那些"、"这些"）解析为其具体指代对象
-- 如果陈述句包含无法从对话上下文中解析的模糊引用，则：
-  a) 扩展陈述句以包含对话早期的缺失上下文
-  b) 标记陈述句为需要额外上下文
-  c) 如果陈述句在没有上下文的情况下变得无意义，则跳过提取
-
-对话上下文和共指消解：
-- 将每个陈述句归属于说出它的参与者。
-- 如果参与者列表为说话者提供了名称（例如，"李雪（用户）"），请在提取的陈述句中使用具体名称（"李雪"），而不是通用角色（"用户"）。
-- 将所有代词解析为对话上下文中的具体人物或实体。
-- 识别并将抽象引用解析为其具体名称（如果提到）。
-- 将缩写和首字母缩略词扩展为其完整形式。
-{% else %}
 {% if granularity %}
 {% if granularity == 3 %}
 Atomic & Clear: Structure statements to clearly show a single subject-predicate-object relationship. It is better to have multiple smaller statements than one complex one.
@@ -60,7 +29,7 @@ Extract only essence sentences and summarize the chunk into multiple, standalone
 {% endif %}
 
 Context Resolution Requirements:
-- Resolve demonstrative pronouns ("that," "this," "those") to their specific referents
+- Resolve demonstrative pronouns ("that," "this," "those","这个", "那个") to their specific referents
 - If a statement contains vague references that cannot be resolved from the conversation context, either:
   a) Expand the statement to include the missing context from earlier in the conversation
   b) Mark the statement as requiring additional context
@@ -72,36 +41,16 @@ Conversational Context & Co-reference Resolution:
 - Resolve all pronouns to the specific person or entity from the conversation's context.
 - Identify and resolve abstract references to their specific names if mentioned.
 - Expand abbreviations and acronyms to their full form.
-{% endif %}
 
 {% if include_dialogue_context %}
-{% if language == "zh" %}
-===完整对话上下文===
-以下是完整的对话上下文，以帮助您理解引用、代词和对话流程：
-{% else %}
 ===Full Dialogue Context===
 The following is the complete dialogue context to help you understand references, pronouns, and conversational flow:
-{% endif %}
 
 {{ dialogue_context }}
 
-{% if language == "zh" %}
-===对话上下文结束===
-{% else %}
 ===End of Dialogue Context===
 {% endif %}
-{% endif %}
 
-{% if language == "zh" %}
-过滤和格式化：
-
-- 仅提取陈述句。
-  不要提取问题、命令、问候语或对话填充词。
-时间精度：
-
-包括任何明确的日期、时间或定量限定符。
-如果一个句子既描述了事件的开始（静态）又描述了其持续性质（动态），则将两者提取为单独的陈述句。
-{% else %}
 Filtering and Formatting:
 
 - Extract only declarative statements.
@@ -110,114 +59,18 @@ Temporal Precision:
 
 Include any explicit dates, times, or quantitative qualifiers.
 If a sentence describes both the start of an event (static) and its ongoing nature (dynamic), extract both as separate statements.
-{% endif %}
 
 {%- if definitions %}
   {%- for section_key, section_dict in definitions.items() %}
-==== {{ tidy(section_key) | upper }} {% if language == "zh" %}定义和指导{% else %}DEFINITIONS & GUIDANCE{% endif %} ====
+==== {{ tidy(section_key) | upper }} DEFINITIONS & GUIDANCE ====
     {%- for category, details in section_dict.items() %}
 {{ loop.index }}. {{ category }}
-- {% if language == "zh" %}定义{% else %}Definition{% endif %}: {{ details.get("definition", "") }}
+- Definition: {{ details.get("definition", "") }}
     {% endfor -%}
   {% endfor -%}
 {% endif -%}
 
 ===Examples===
-{% if language == "zh" %}
-示例 1: 英文对话
-示例片段: """
-日期: 2024年3月15日
-参与者:
-- Sarah Chen (用户)
-- 助手 (AI)
-
-用户: "我最近一直在尝试水彩画，画了一些花朵。"
-AI: "水彩画很有趣！水彩颜料通常由颜料与阿拉伯树胶等粘合剂混合而成。你觉得怎么样？"
-用户: "我认为色彩组合可以改进，但我真的很喜欢玫瑰和百合。"
-"""
-
-示例输出: {
-  "statements": [
-    {
-      "statement": "Sarah Chen 最近一直在尝试水彩画。",
-      "statement_type": "FACT",
-      "temporal_type": "DYNAMIC",
-      "relevance": "RELEVANT"
-    },
-    {
-      "statement": "Sarah Chen 画了一些花朵。",
-      "statement_type": "FACT",
-      "temporal_type": "DYNAMIC",
-      "relevance": "RELEVANT"
-    },
-    {
-      "statement": "水彩颜料通常由颜料与阿拉伯树胶等粘合剂混合而成。",
-      "statement_type": "FACT",
-      "temporal_type": "ATEMPORAL",
-      "relevance": "IRRELEVANT"
-    },
-    {
-      "statement": "Sarah Chen 认为她的水彩画中的色彩组合可以改进。",
-      "statement_type": "OPINION",
-      "temporal_type": "STATIC",
-      "relevance": "RELEVANT"
-    },
-    {
-      "statement": "Sarah Chen 真的很喜欢玫瑰和百合。",
-      "statement_type": "FACT",
-      "temporal_type": "STATIC",
-      "relevance": "RELEVANT"
-    }
-  ]
-}
-
-示例 2: 中文对话示例
-示例片段: """
-日期: 2024年3月15日
-参与者:
-- 张曼婷 (用户)
-- 小助手 (AI助手)
-
-用户: "我最近在尝试水彩画，画了一些花朵。"
-AI: "水彩画很有趣！水彩颜料通常由颜料和阿拉伯树胶等粘合剂混合而成。你觉得怎么样？"
-用户: "我觉得色彩搭配还有提升的空间，不过我很喜欢玫瑰和百合这两种花。"
-"""
-
-示例输出: {
-  "statements": [
-    {
-      "statement": "张曼婷最近在尝试水彩画。",
-      "statement_type": "FACT",
-      "temporal_type": "DYNAMIC",
-      "relevance": "RELEVANT"
-    },
-    {
-      "statement": "张曼婷画了一些花朵。",
-      "statement_type": "FACT",
-      "temporal_type": "DYNAMIC",
-      "relevance": "RELEVANT"
-    },
-    {
-      "statement": "水彩颜料通常由颜料和阿拉伯树胶等粘合剂混合而成。",
-      "statement_type": "FACT",
-      "temporal_type": "ATEMPORAL",
-      "relevance": "IRRELEVANT"
-    },
-    {
-      "statement": "张曼婷觉得水彩画的色彩搭配还有提升的空间。",
-      "statement_type": "OPINION",
-      "temporal_type": "STATIC",
-      "relevance": "RELEVANT"
-    },
-    {
-      "statement": "张曼婷很喜欢玫瑰和百合。",
-      "statement_type": "FACT",
-      "temporal_type": "STATIC",
-      "relevance": "RELEVANT"
-    }
-  ]
-}
-{% else %}
 Example 1: English Conversation
 Example Chunk: """
 Date: March 15, 2024
@@ -311,33 +164,8 @@ Example Output: {
     }
   ]
 }
-{% endif %}
 ===End of Examples===
 
-{% if language == "zh" %}
-===反思过程===
-
-提取陈述句后，执行以下自我审查步骤：
-
-**步骤 1: 归属检查**
-- 确认每个陈述句都正确归属于正确的说话者
-- 验证说话者名称在整个过程中使用一致
-- 检查 AI 助手陈述句是否正确归属
-
-**步骤 2: 完整性审查**
-- 确保没有遗漏重要的陈述句
-- 检查时间信息是否保留
-
-**步骤 3: 分类验证**
-- 审查 statement_type 分类（FACT/OPINION/PREDICTION/SUGGESTION）
-- 验证 temporal_type 分配（STATIC/DYNAMIC/ATEMPORAL）
-- 确保分类与提供的定义一致
-
-**步骤 4: 最终质量检查**
-- 删除任何问题、命令或对话填充词
-- 验证 JSON 格式合规性
-- 确认输出语言与输入语言匹配
-{% else %}
 ===Reflection Process===
 
 After extracting statements, perform the following self-review steps:
@@ -360,7 +188,6 @@ After extracting statements, perform the following self-review steps:
 - Remove any questions, commands, or conversational filler
 - Verify JSON format compliance
 - Confirm output language matches input language
-{% endif %}
 
 **Output format**
 **CRITICAL JSON FORMATTING REQUIREMENTS:**
@@ -371,21 +198,10 @@ After extracting statements, perform the following self-review steps:
 5. Example of proper escaping: "statement": "John said: \"I really like this book.\""
 
 **LANGUAGE REQUIREMENT:**
-{% if language == "zh" %}
-- 输出语言应始终与输入语言匹配
-- 如果输入是中文，则用中文提取陈述句
-- 如果输入是英文，则用英文提取陈述句
-- 保留原始语言，不要翻译
-{% else %}
 - The output language should ALWAYS match the input language
 - If input is in English, extract statements in English
 - If input is in Chinese, extract statements in Chinese
 - Preserve the original language and do not translate
-{% endif %}
 
-{% if language == "zh" %}
-仅返回与以下架构匹配的 JSON 对象数组中提取的标记陈述句列表：
-{% else %}
 Return only a list of extracted labelled statements in the JSON ARRAY of objects that match the schema below:
-{% endif %}
-{{ json_schema }}
+{{ json_schema }}

api/app/core/memory/utils/prompt/prompts/extract_temporal.jinja2

@@ -14,113 +14,68 @@
 #}
 # Task
 
-{% if language == "zh" %}
-从提供的陈述句中提取时间信息（日期和时间范围）。确定所描述的关系或事件何时生效以及何时结束（如果适用）。
-{% else %}
 Extract temporal information (dates and time ranges) from the provided statement. Determine when the relationship or event described became valid and when it ended (if applicable).
-{% endif %}
 
-# {% if language == "zh" %}输入数据{% else %}Input Data{% endif %}
+# Input Data
 {% if inputs %}
 {% for key, val in inputs.items() %}
 - {{ key }}: {{val}}
 {% endfor %}
 {% endif %}
 
-# {% if language == "zh" %}时间字段{% else %}Temporal Fields{% endif %}
+# Temporal Fields
 
-{% if language == "zh" %}
-- **valid_at**: 关系/事件开始或成为真实的时间（ISO 8601 格式）
-- **invalid_at**: 关系/事件结束或停止为真的时间（ISO 8601 格式，如果正在进行则为 null）
-{% else %}
 - **valid_at**: When the relationship/event started or became true (ISO 8601 format)
 - **invalid_at**: When the relationship/event ended or stopped being true (ISO 8601 format, or null if ongoing)
-{% endif %}
 
-# {% if language == "zh" %}提取规则{% else %}Extraction Rules{% endif %}
+# Extraction Rules
 
-## {% if language == "zh" %}核心原则{% else %}Core Principles{% endif %}
-{% if language == "zh" %}
-1. **仅使用明确陈述的时间信息** - 不要从外部知识推断日期
-2. **使用参考/发布日期作为"现在"** 解释相对时间时
-3. **仅在日期与关系的有效性相关时设置日期** - 忽略偶然的时间提及
-4. **对于时间点事件**，仅设置 `valid_at`
-{% else %}
+## Core Principles
 1. **Only use explicitly stated temporal information** - do not infer dates from external knowledge
 2. **Use the reference/publication date as "now"** when interpreting relative times
 3. **Set dates only if they relate to the validity of the relationship** - ignore incidental time mentions
 4. **For point-in-time events**, set only `valid_at`
-{% endif %}
 
-## {% if language == "zh" %}日期格式要求{% else %}Date Format Requirements{% endif %}
-{% if language == "zh" %}
-- 使用 ISO 8601: `YYYY-MM-DDTHH:MM:SS.SSSSSSZ`
-- 如果未指定时间，使用 `00:00:00`（午夜）
-- 如果仅提及年份，根据情况使用 `YYYY-01-01`（开始）或 `YYYY-12-31`（结束）
-- 如果仅提及月份，使用月份的第一天或最后一天
-- 始终包含时区（如果未指定，使用 `Z` 表示 UTC）
-- 根据参考日期将相对时间（"两周前"、"去年"）转换为绝对日期
-{% else %}
+## Date Format Requirements
 - Use ISO 8601: `YYYY-MM-DDTHH:MM:SS.SSSSSSZ`
 - If no time specified, use `00:00:00` (midnight)
 - If only year mentioned, use `YYYY-01-01` (start) or `YYYY-12-31` (end) as appropriate
 - If only month mentioned, use first or last day of month
 - Always include timezone (use `Z` for UTC if unspecified)
 - Convert relative times ("two weeks ago", "last year") to absolute dates based on reference date
-{% endif %}
 
-## {% if language == "zh" %}陈述句类型规则{% else %}Statement Type Rules{% endif %}
+## Statement Type Rules
 
-{{ inputs.get("statement_type") | upper }} {% if language == "zh" %}陈述句指导{% else %}Statement Guidance{% endif %}:
+{{ inputs.get("statement_type") | upper }} Statement Guidance:
 {%for key, guide in statement_guide.items() %}
 - {{ tidy(key) | capitalize }}: {{ guide }}
 {% endfor %}
 
-**{% if language == "zh" %}特殊情况{% else %}Special Cases{% endif %}:**
-{% if language == "zh" %}
-- **意见陈述句**: 仅设置 `valid_at`（意见表达的时间）
-- **预测陈述句**: 如果明确提及，将 `invalid_at` 设置为预测窗口的结束
-{% else %}
+**Special Cases:**
 - **Opinion statements**: Set only `valid_at` (when opinion was expressed)
 - **Prediction statements**: Set `invalid_at` to the end of the prediction window if explicitly mentioned
-{% endif %}
 
-## {% if language == "zh" %}时间类型规则{% else %}Temporal Type Rules{% endif %}
+## Temporal Type Rules
 
-{{ inputs.get("temporal_type") | upper }} {% if language == "zh" %}时间类型指导{% else %}Temporal Type Guidance{% endif %}:
+{{ inputs.get("temporal_type") | upper }} Temporal Type Guidance:
 {% for key, guide in temporal_guide.items() %}
 - {{ tidy(key) | capitalize }}: {{ guide }}
 {% endfor %}
 
 {% if inputs.get('quarter') and inputs.get('publication_date') %}
-## {% if language == "zh" %}季度参考{% else %}Quarter Reference{% endif %}
-{% if language == "zh" %}
-假设 {{ inputs.quarter }} 在 {{ inputs.publication_date }} 结束。从此基线计算任何季度引用（Q1、Q2 等）的日期。
-{% else %}
+## Quarter Reference
 Assume {{ inputs.quarter }} ends on {{ inputs.publication_date }}. Calculate dates for any quarter references (Q1, Q2, etc.) from this baseline.
 {% endif %}
-{% endif %}
 
-# {% if language == "zh" %}输出要求{% else %}Output Requirements{% endif %}
+# Output Requirements
 
-## {% if language == "zh" %}JSON 格式化（关键）{% else %}JSON Formatting (CRITICAL){% endif %}
-{% if language == "zh" %}
-1. 使用**仅标准 ASCII 双引号** (") - 永远不要使用中文引号（""）或其他 Unicode 变体
-2. 使用反斜杠转义内部引号: `\"`
-3. JSON 字符串值中不要有换行符
-4. 正确关闭并用逗号分隔所有字段
-{% else %}
+## JSON Formatting (CRITICAL)
 1. Use **only standard ASCII double quotes** (") - never use Chinese quotes ("") or other Unicode variants
 2. Escape internal quotes with backslash: `\"`
 3. No line breaks within JSON string values
 4. Properly close and comma-separate all fields
-{% endif %}
 
-## {% if language == "zh" %}语言{% else %}Language{% endif %}
-{% if language == "zh" %}
-输出语言必须与输入语言匹配。
-{% else %}
+## Language
 Output language must match input language.
-{% endif %}
 
 {{ json_schema }}

api/app/core/memory/utils/prompt/prompts/extract_triplet.jinja2

@@ -6,96 +6,64 @@
 Extract entities and knowledge triplets from the given statement.
 
 {% if language == "zh" %}
-**重要：请使用中文生成实体名称（name）、描述（description）和示例（example）。**
+**重要：请使用中文生成实体描述（description）和示例（example）。**
 {% else %}
-**Important: Please generate entity names, descriptions and examples in English. If the original text is in Chinese, translate entity names to English.**
+**Important: Please generate entity descriptions and examples in English.**
 {% endif %}
 
 ===Inputs===
 **Chunk Content:** "{{ chunk_content }}"
 **Statement:** "{{ statement }}"
 
-{% if ontology_types %}
-===Ontology Type Guidance===
-
-**CRITICAL RULE: You MUST ONLY use the predefined ontology type names listed below for the entity "type" field. Do NOT use any other type names, even if they seem reasonable.**
-
-**If no predefined type fits an entity, use the CLOSEST matching predefined type. NEVER invent new type names.**
-
-**Type Priority (from highest to lowest):**
-1. **[场景类型] Scene Types** - Domain-specific types, ALWAYS prefer these first
-2. **[通用类型] General Types** - Common types from standard ontologies (DBpedia)
-3. **[通用父类] Parent Types** - Provide type hierarchy context
-
-**Type Matching Rules:**
-- Entity type MUST exactly match one of the predefined type names below
-- Do NOT use types like "Equipment", "Component", "Concept", "Action", "Condition", "Data", "Duration" unless they appear in the predefined list
-- Do NOT modify, translate, abbreviate, or create variations of type names
-- Prefer scene types (marked [场景类型]) over general types when both could apply
-- If uncertain, check the type description to find the best match
-
-**Predefined Ontology Types:**
-{{ ontology_types }}
-
-{% if type_hierarchy_hints %}
-**Type Hierarchy Reference:**
-The following shows type inheritance relationships (Child → Parent → Grandparent):
-{% for hint in type_hierarchy_hints %}
-- {{ hint }}
-{% endfor %}
-{% endif %}
-
-**ALLOWED Type Names (use EXACTLY one of these, no exceptions):**
-{{ ontology_type_names | join(', ') }}
-
-{% endif %}
 ===Guidelines===
 
 **Entity Extraction:**
 - Extract entities with their types, context-independent descriptions, **concise examples**, aliases, and semantic memory classification
 {% if language == "zh" %}
-- **实体名称（name）必须使用中文**
 - **实体描述（description）必须使用中文**
 - **示例（example）必须使用中文**
 {% else %}
-- **Entity names must be in English** (translate if the original is in another language)
 - **Entity descriptions must be in English**
 - **Examples must be in English**
 {% endif %}
 - **Semantic Memory Classification (is_explicit_memory):**
   * Set to `true` if the entity represents **explicit/semantic memory**:
-    - **Concepts:** "Machine Learning", "Photosynthesis", "Democracy"
-    - **Knowledge:** "Python Programming Language", "Theory of Relativity"
-    - **Definitions:** "API (Application Programming Interface)", "REST API"
-    - **Principles:** "SOLID Principles", "First Law of Thermodynamics"
-    - **Theories:** "Evolution Theory", "Quantum Mechanics"
-    - **Methods/Techniques:** "Agile Development", "Machine Learning Algorithm"
-    - **Technical Terms:** "Neural Network", "Database"
+    - **Concepts:** "Machine Learning", "Photosynthesis", "Democracy", "人工智能", "光合作用", "民主"
+    - **Knowledge:** "Python Programming Language", "Theory of Relativity", "Python编程语言", "相对论"
+    - **Definitions:** "API (Application Programming Interface)", "REST API", "应用程序接口"
+    - **Principles:** "SOLID Principles", "First Law of Thermodynamics", "SOLID原则", "热力学第一定律"
+    - **Theories:** "Evolution Theory", "Quantum Mechanics", "进化论", "量子力学"
+    - **Methods/Techniques:** "Agile Development", "Machine Learning Algorithm", "敏捷开发", "机器学习算法"
+    - **Technical Terms:** "Neural Network", "Database", "神经网络", "数据库"
   * Set to `false` for:
-    - **People:** "John Smith", "Dr. Wang"
-    - **Organizations:** "Microsoft", "Harvard University"
-    - **Locations:** "Beijing", "Central Park"
-    - **Events:** "2024 Conference", "Project Meeting"
-    - **Specific objects:** "iPhone 15", "Building A"
+    - **People:** "John Smith", "Dr. Wang", "张明", "王博士"
+    - **Organizations:** "Microsoft", "Harvard University", "微软", "哈佛大学"
+    - **Locations:** "Beijing", "Central Park", "北京", "中央公园"
+    - **Events:** "2024 Conference", "Project Meeting", "2024会议", "项目会议"
+    - **Specific objects:** "iPhone 15", "Building A", "iPhone 15", "A栋"
 - **Example Generation (IMPORTANT for semantic memory entities):**
   * For entities where `is_explicit_memory=true`, generate a **concise example (around 20 characters)** to help understand the concept
   * The example should be:
     - **Specific and concrete**: Use real-world scenarios or applications
     - **Brief**: Around 20 characters (can be slightly longer if needed for clarity)
-{% if language == "zh" %}
-    - **使用中文**
-{% else %}
-    - **In English**
-{% endif %}
+    - **In the same language as the entity name**
+  * Examples:
+    - Entity: "机器学习" → example: "如：用神经网络识别图片中的猫狗"
+    - Entity: "SOLID Principles" → example: "e.g., Single Responsibility, Open-Closed"
+    - Entity: "Photosynthesis" → example: "e.g., plants convert sunlight to energy"
+    - Entity: "人工智能" → example: "如：智能客服、自动驾驶"
   * For non-semantic entities (`is_explicit_memory=false`), the example field can be empty
-- **Aliases Extraction:**
-{% if language == "zh" %}
-  * 别名使用中文
-{% else %}
-  * Aliases should be in English
-{% endif %}
-  * Include common alternative names, abbreviations and full names
-  * If no aliases exist, use empty array: []
+- **Aliases Extraction (Important):**
+  * **CRITICAL: Extract aliases ONLY in the SAME LANGUAGE as the input text**
+  * **DO NOT translate or add aliases in different languages**
+  * Include common alternative names in the same language (e.g., "北京" → aliases: ["北平", "京城"])
+  * Include abbreviations and full names in the same language (e.g., "联合国" → aliases: ["联合国组织"])
+  * Include nicknames and common variations in the same language (e.g., "纽约" → aliases: ["纽约市", "大苹果"])
+  * If no aliases exist in the same language, use empty array: []
+  * **Examples:**
+    - Chinese input "北京" → aliases: ["北平", "京城"] (NOT ["Beijing", "Peking"])
+    - English input "Beijing" → aliases: ["Peking"] (NOT ["北京", "北平"])
+    - Chinese input "苹果公司" → aliases: ["苹果"] (NOT ["Apple Inc.", "Apple"])
 - Exclude lengthy quotes, calendar dates, temporal ranges, and temporal expressions
 - For numeric values: extract as separate entities (instance_of: 'Numeric', name: units, numeric_value: value)
   Example: £30 → name: 'GBP', numeric_value: 30, instance_of: 'Numeric'
@@ -105,11 +73,6 @@ The following shows type inheritance relationships (Child → Parent → Grandpa
   - Subject: main entity performing the action or being described
   - Predicate: relationship between entities (e.g., 'is', 'works at', 'believes')
   - Object: entity, value, or concept affected by the predicate
-{% if language == "zh" %}
-- subject_name 和 object_name 必须使用中文
-{% else %}
-- subject_name and object_name must be in English (translate if original is in another language)
-{% endif %}
 - Exclude all temporal expressions from every field
 - Use ONLY the predicates listed in "Predicate Instructions" (uppercase English tokens)
 - Do NOT translate predicate tokens
@@ -118,7 +81,7 @@ The following shows type inheritance relationships (Child → Parent → Grandpa
 **When NOT to extract triplets:**
 - Non-propositional utterances (emotions, fillers, onomatopoeia)
 - No clear predicate from the given definitions applies
-- Standalone noun phrases or checklist items → extract as entities only
+- Standalone noun phrases or checklist items (e.g., "三脚架", "备用电池") → extract as entities only
 - Do NOT invent generic predicates (e.g., "IS_DOING", "FEELS", "MENTIONS")
 
 **If no valid triplet exists:** Return triplets: [], extract entities if present, otherwise both arrays empty.
@@ -133,86 +96,248 @@ Use ONLY these predicates. If none fits, set triplets to [].
 
 
 ===Examples===
-{% if language == "en" %}
-**Example 1 (English output):** "I plan to travel to Paris next week and visit the Louvre."
+
+**Example 1 (English):** "I plan to travel to Paris next week and visit the Louvre."
 Output:
 {
   "triplets": [
-    {"subject_name": "I", "subject_id": 0, "predicate": "PLANS_TO_VISIT", "object_name": "Paris", "object_id": 1, "value": null},
-    {"subject_name": "I", "subject_id": 0, "predicate": "PLANS_TO_VISIT", "object_name": "Louvre", "object_id": 2, "value": null}
+    {
+      "subject_name": "I",
+      "subject_id": 0,
+      "predicate": "PLANS_TO_VISIT",
+      "object_name": "Paris",
+      "object_id": 1,
+      "value": null
+    },
+    {
+      "subject_name": "I",
+      "subject_id": 0,
+      "predicate": "PLANS_TO_VISIT",
+      "object_name": "Louvre",
+      "object_id": 2,
+      "value": null
+    }
   ],
   "entities": [
-    {"entity_idx": 0, "name": "I", "type": "Person", "description": "The user", "example": "", "aliases": [], "is_explicit_memory": false},
-    {"entity_idx": 1, "name": "Paris", "type": "Location", "description": "Capital city of France", "example": "", "aliases": [], "is_explicit_memory": false},
-    {"entity_idx": 2, "name": "Louvre", "type": "Location", "description": "World-famous museum located in Paris", "example": "", "aliases": ["Louvre Museum"], "is_explicit_memory": false}
+    {
+      "entity_idx": 0,
+      "name": "I",
+      "type": "Person",
+      "description": "The user",
+      "example": "",
+      "aliases": [],
+      "is_explicit_memory": false
+    },
+    {
+      "entity_idx": 1,
+      "name": "Paris",
+      "type": "Location",
+      "description": "Capital city of France",
+      "example": "",
+      "aliases": [],
+      "is_explicit_memory": false
+    },
+    {
+      "entity_idx": 2,
+      "name": "Louvre",
+      "type": "Location",
+      "description": "World-famous museum located in Paris",
+      "example": "",
+      "aliases": ["Louvre Museum"],
+      "is_explicit_memory": false
+    }
   ]
 }
 
-**Example 2 (Chinese input → English output - IMPORTANT: translate entity names):** "张明在腾讯工作，负责AI产品开发。"
+**Example 2 (English):** "John Smith works at Google and is responsible for AI product development."
 Output:
 {
   "triplets": [
-    {"subject_name": "Zhang Ming", "subject_id": 0, "predicate": "WORKS_AT", "object_name": "Tencent", "object_id": 1, "value": null},
-    {"subject_name": "Zhang Ming", "subject_id": 0, "predicate": "RESPONSIBLE_FOR", "object_name": "AI product development", "object_id": 2, "value": null}
+    {
+      "subject_name": "John Smith",
+      "subject_id": 0,
+      "predicate": "WORKS_AT",
+      "object_name": "Google",
+      "object_id": 1,
+      "value": null
+    },
+    {
+      "subject_name": "John Smith",
+      "subject_id": 0,
+      "predicate": "RESPONSIBLE_FOR",
+      "object_name": "AI product development",
+      "object_id": 2,
+      "value": null
+    }
   ],
   "entities": [
-    {"entity_idx": 0, "name": "Zhang Ming", "type": "Person", "description": "Individual person name", "example": "", "aliases": [], "is_explicit_memory": false},
-    {"entity_idx": 1, "name": "Tencent", "type": "Organization", "description": "Chinese technology company", "example": "", "aliases": ["Tencent Holdings"], "is_explicit_memory": false},
-    {"entity_idx": 2, "name": "AI product development", "type": "Concept", "description": "Artificial intelligence product development work", "example": "e.g., developing chatbots", "aliases": [], "is_explicit_memory": true}
+    {
+      "entity_idx": 0,
+      "name": "John Smith",
+      "type": "Person",
+      "description": "Individual person name",
+      "example": "",
+      "aliases": [],
+      "is_explicit_memory": false
+    },
+    {
+      "entity_idx": 1,
+      "name": "Google",
+      "type": "Organization",
+      "description": "American technology company",
+      "example": "",
+      "aliases": ["Google LLC", "Alphabet Inc."],
+      "is_explicit_memory": false
+    },
+    {
+      "entity_idx": 2,
+      "name": "AI product development",
+      "type": "Concept",
+      "description": "Artificial intelligence product development work",
+      "example": "e.g., developing chatbots, recommendation systems",
+      "aliases": [],
+      "is_explicit_memory": true
+    }
   ]
 }
 
-**Example 3 (Chinese input → English output):** "三脚架"
+**Example 3 (Chinese):** "我计划下周去巴黎旅行，参观卢浮宫。"
+Output:
+{
+  "triplets": [
+    {
+      "subject_name": "我",
+      "subject_id": 0,
+      "predicate": "PLANS_TO_VISIT",
+      "object_name": "巴黎",
+      "object_id": 1,
+      "value": null
+    },
+    {
+      "subject_name": "我",
+      "subject_id": 0,
+      "predicate": "PLANS_TO_VISIT",
+      "object_name": "卢浮宫",
+      "object_id": 2,
+      "value": null
+    }
+  ],
+  "entities": [
+    {
+      "entity_idx": 0,
+      "name": "我",
+      "type": "Person",
+      "description": "用户本人",
+      "example": "",
+      "aliases": [],
+      "is_explicit_memory": false
+    },
+    {
+      "entity_idx": 1,
+      "name": "巴黎",
+      "type": "Location",
+      "description": "法国首都城市",
+      "example": "",
+      "aliases": [],
+      "is_explicit_memory": false
+    },
+    {
+      "entity_idx": 2,
+      "name": "卢浮宫",
+      "type": "Location",
+      "description": "位于巴黎的世界著名博物馆",
+      "example": "",
+      "aliases": [],
+      "is_explicit_memory": false
+    }
+  ]
+}
+
+**Example 4 (Chinese):** "张明在腾讯工作，负责AI产品开发。"
+Output:
+{
+  "triplets": [
+    {
+      "subject_name": "张明",
+      "subject_id": 0,
+      "predicate": "WORKS_AT",
+      "object_name": "腾讯",
+      "object_id": 1,
+      "value": null
+    },
+    {
+      "subject_name": "张明",
+      "subject_id": 0,
+      "predicate": "RESPONSIBLE_FOR",
+      "object_name": "AI产品开发",
+      "object_id": 2,
+      "value": null
+    }
+  ],
+  "entities": [
+    {
+      "entity_idx": 0,
+      "name": "张明",
+      "type": "Person",
+      "description": "个人姓名",
+      "example": "",
+      "aliases": [],
+      "is_explicit_memory": false
+    },
+    {
+      "entity_idx": 1,
+      "name": "腾讯",
+      "type": "Organization",
+      "description": "中国科技公司",
+      "example": "",
+      "aliases": ["腾讯控股", "腾讯公司"],
+      "is_explicit_memory": false
+    },
+    {
+      "entity_idx": 2,
+      "name": "AI产品开发",
+      "type": "Concept",
+      "description": "人工智能产品研发工作",
+      "example": "如：开发智能客服机器人、推荐系统",
+      "aliases": [],
+      "is_explicit_memory": true
+    }
+  ]
+}
+
+**Example 5 (Entity Only - English):** "Tripod"
 Output:
 {
   "triplets": [],
   "entities": [
-    {"entity_idx": 0, "name": "Tripod", "type": "Equipment", "description": "Photography equipment accessory", "example": "", "aliases": ["Camera Tripod"], "is_explicit_memory": false}
-  ]
-}
-{% else %}
-**Example 1 (English input → Chinese output):** "I plan to travel to Paris next week and visit the Louvre."
-Output:
-{
-  "triplets": [
-    {"subject_name": "我", "subject_id": 0, "predicate": "PLANS_TO_VISIT", "object_name": "巴黎", "object_id": 1, "value": null},
-    {"subject_name": "我", "subject_id": 0, "predicate": "PLANS_TO_VISIT", "object_name": "卢浮宫", "object_id": 2, "value": null}
-  ],
-  "entities": [
-    {"entity_idx": 0, "name": "我", "type": "Person", "description": "用户本人", "example": "", "aliases": [], "is_explicit_memory": false},
-    {"entity_idx": 1, "name": "巴黎", "type": "Location", "description": "法国首都城市", "example": "", "aliases": [], "is_explicit_memory": false},
-    {"entity_idx": 2, "name": "卢浮宫", "type": "Location", "description": "位于巴黎的世界著名博物馆", "example": "", "aliases": [], "is_explicit_memory": false}
+    {
+      "entity_idx": 0,
+      "name": "Tripod",
+      "type": "Equipment",
+      "description": "Photography equipment accessory",
+      "example": "",
+      "aliases": ["Camera Tripod"],
+      "is_explicit_memory": false
+    }
   ]
 }
 
-**Example 2 (Chinese input → Chinese output):** "张明在腾讯工作，负责AI产品开发。"
-Output:
-{
-  "triplets": [
-    {"subject_name": "张明", "subject_id": 0, "predicate": "WORKS_AT", "object_name": "腾讯", "object_id": 1, "value": null},
-    {"subject_name": "张明", "subject_id": 0, "predicate": "RESPONSIBLE_FOR", "object_name": "AI产品开发", "object_id": 2, "value": null}
-  ],
-  "entities": [
-    {"entity_idx": 0, "name": "张明", "type": "Person", "description": "个人姓名", "example": "", "aliases": [], "is_explicit_memory": false},
-    {"entity_idx": 1, "name": "腾讯", "type": "Organization", "description": "中国科技公司", "example": "", "aliases": ["腾讯控股", "腾讯公司"], "is_explicit_memory": false},
-    {"entity_idx": 2, "name": "AI产品开发", "type": "Concept", "description": "人工智能产品研发工作", "example": "如：开发智能客服机器人", "aliases": [], "is_explicit_memory": true}
-  ]
-}
-
-**Example 3 (Entity Only - Chinese):** "三脚架"
+**Example 6 (Entity Only - Chinese):** "三脚架"
 Output:
 {
   "triplets": [],
   "entities": [
-    {"entity_idx": 0, "name": "三脚架", "type": "Equipment", "description": "摄影器材配件", "example": "", "aliases": ["相机三脚架"], "is_explicit_memory": false}
+    {
+      "entity_idx": 0,
+      "name": "三脚架",
+      "type": "Equipment",
+      "description": "摄影器材配件",
+      "example": "",
+      "aliases": ["相机三脚架"],
+      "is_explicit_memory": false
+    }
   ]
 }
-{% endif %}
-===End of Examples===
-
-{% if ontology_types %}
-**⚠️ REMINDER: The examples above use generic type names for illustration only. You MUST use ONLY the predefined ontology type names from the "ALLOWED Type Names" list above. For example, use "PredictiveMaintenance" instead of "Concept", use "ProductionLine" instead of "Equipment", etc. Map each entity to the closest matching predefined type.**
-{% endif %}
 
 ===Output Format===
 
@@ -223,10 +348,10 @@ Output:
 - Ensure proper string closure and comma separation
 - No line breaks within JSON string values
 {% if language == "zh" %}
-- **语言要求：实体名称（name）、描述（description）、示例（example）、subject_name、object_name 必须使用中文**
+- **语言要求：实体描述（description）和示例（example）必须使用中文**
 {% else %}
-- **Language Requirement: Entity names, descriptions, examples, subject_name, object_name must be in English**
-- **If the original text is in Chinese, translate all names to English**
+- **Language Requirement: Entity descriptions and examples must be in English**
 {% endif %}
+- Preserve the original language and do not translate
 
-{{ json_schema }}
+{{ json_schema }}

api/app/core/memory/utils/prompt/prompts/generate_emotion_suggestions.jinja2

@@ -1,103 +1,9 @@
-{% if language == "en" %}
-You are a professional mental health consultant. Based on the following user's emotional health data and personal information, generate 3-5 personalized emotional improvement suggestions.
-
-## Core Principle (Highest Priority)
-
-**You must strictly base your suggestions on the emotion distribution data provided below. As long as any emotion type has a count ≥ 1, that emotion EXISTS and you must acknowledge and address it in your suggestions. You must NEVER claim an emotion is "zero" or "absent" when its count is ≥ 1.**
-
-Specific rules:
-1. Carefully check the count for each emotion type in "Emotion Distribution" — count ≥ 1 means the emotion exists
-2. Even if an emotion appeared only once, you must mention it in health_summary or suggestions and provide targeted advice
-3. Never state that an emotion is "zero" or "non-existent" unless its count in the distribution data is truly 0
-4. If positive emotions (e.g., Joy) exist, health_summary must affirm this positive signal
-5. If negative emotions (e.g., Sadness, Anger, Fear) exist even once, you must provide targeted improvement suggestions
-6. A high proportion of neutral emotions does NOT mean other emotions are absent — address all non-zero emotions
-
-## User Emotional Health Data
-
-Health Score: {{ health_data.health_score }}/100
-Health Level: {{ health_data.level }}
-Total Emotion Records: {{ health_data.dimensions.positivity_rate.positive_count + health_data.dimensions.positivity_rate.negative_count + health_data.dimensions.positivity_rate.neutral_count }}
-
-Dimension Analysis:
-- Positivity Rate: {{ health_data.dimensions.positivity_rate.score }}/100
-  - Positive Emotions: {{ health_data.dimensions.positivity_rate.positive_count }} times
-  - Negative Emotions: {{ health_data.dimensions.positivity_rate.negative_count }} times
-  - Neutral Emotions: {{ health_data.dimensions.positivity_rate.neutral_count }} times
-
-- Stability: {{ health_data.dimensions.stability.score }}/100
-  - Standard Deviation: {{ health_data.dimensions.stability.std_deviation }}
-
-- Resilience: {{ health_data.dimensions.resilience.score }}/100
-  - Recovery Rate: {{ health_data.dimensions.resilience.recovery_rate }}
-
-Emotion Distribution (check each item — every emotion with count ≥ 1 must be reflected in suggestions):
-{{ emotion_distribution_json }}
-
-## Emotion Pattern Analysis
-
-Dominant Negative Emotion: {{ patterns.dominant_negative_emotion|default('None') }}
-Emotion Volatility: {{ patterns.emotion_volatility|default('Unknown') }}
-High Intensity Emotion Count: {{ patterns.high_intensity_emotions|default([])|length }}
-
-## User Interests
-
-{{ user_profile.interests|default(['Unknown'])|join(', ') }}
-
-## Task Requirements
-
-Please generate 3-5 personalized suggestions, each containing:
-1. type: Suggestion type (Emotion Balance/Activity Recommendation/Social Connection/Stress Management)
-2. title: Suggestion title (short and impactful)
-3. content: Suggestion content (detailed explanation, 50-100 words)
-4. priority: Priority level (High/Medium/Low)
-5. actionable_steps: 3 specific executable steps
-
-Also provide a health_summary (no more than 50 words) summarizing the user's overall emotional state.
-**The health_summary must truthfully reflect ALL non-zero emotions from the distribution data. Do not omit any emotion type that has appeared.**
-
-Please return in JSON format as follows:
-{
-  "health_summary": "Your emotional health status...",
-  "suggestions": [
-    {
-      "type": "Emotion Balance",
-      "title": "Suggestion Title",
-      "content": "Suggestion content...",
-      "priority": "High",
-      "actionable_steps": ["Step 1", "Step 2", "Step 3"]
-    }
-  ]
-}
-
-Notes:
-- CRITICAL: Any emotion with count ≥ 1 in the distribution MUST be acknowledged and addressed — never ignore or claim it is zero
-- Suggestions should be specific and actionable, avoid vague advice
-- Provide personalized suggestions based on user's interests and hobbies
-- Provide targeted suggestions for main issues (such as dominant negative emotions)
-- Allocate priorities reasonably (at least 1 high, 1-2 medium, rest low)
-- The 3 steps for each suggestion should be progressive and easy to implement
-- All output must be in English
-{% else %}
 你是一位专业的心理健康顾问。请根据以下用户的情绪健康数据和个人信息，生成3-5条个性化的情绪改善建议。
 
-## 核心原则（最高优先级）
-
-**你必须严格基于下方提供的情绪分布数据来生成建议。只要某种情绪的出现次数 ≥ 1，就代表该情绪确实存在，你必须在建议中承认并回应这一情绪，绝对不能说"该情绪为零"或"没有该情绪"。**
-
-具体规则：
-1. 仔细查看"情绪分布"中每种情绪的出现次数，次数 ≥ 1 即表示该情绪存在
-2. 即使某种情绪只出现了1次，也必须在 health_summary 或建议中提及并给出针对性建议
-3. 严禁在输出中声称某种情绪"为零"或"不存在"，除非该情绪在分布数据中确实为0次
-4. 如果正面情绪（如喜悦）存在，health_summary 中必须肯定这一积极信号
-5. 如果负面情绪（如悲伤、愤怒、恐惧）存在，即使只有1次，也必须给出针对性的改善建议
-6. 中性情绪占比高不代表没有其他情绪，必须同时关注所有非零情绪
-
 ## 用户情绪健康数据
 
 健康分数：{{ health_data.health_score }}/100
 健康等级：{{ health_data.level }}
-情绪记录总数：{{ health_data.dimensions.positivity_rate.positive_count + health_data.dimensions.positivity_rate.negative_count + health_data.dimensions.positivity_rate.neutral_count }}条
 
 维度分析：
 - 积极率：{{ health_data.dimensions.positivity_rate.score }}/100
@@ -111,12 +17,12 @@ Notes:
 - 恢复力：{{ health_data.dimensions.resilience.score }}/100
   - 恢复率：{{ health_data.dimensions.resilience.recovery_rate }}
 
-情绪分布（请逐项检查，次数≥1的情绪都必须在建议中体现）：
+情绪分布：
 {{ emotion_distribution_json }}
 
 ## 情绪模式分析
 
-主要负面情绪：{{ dominant_negative_translated|default(patterns.dominant_negative_emotion)|default('无') }}
+主要负面情绪：{{ patterns.dominant_negative_emotion|default('无') }}
 情绪波动性：{{ patterns.emotion_volatility|default('未知') }}
 高强度情绪次数：{{ patterns.high_intensity_emotions|default([])|length }}
 
@@ -127,35 +33,31 @@ Notes:
 ## 任务要求
 
 请生成3-5条个性化建议，每条建议包含：
-1. type: 建议类型（情绪平衡/活动建议/社交联系/压力管理）
+1. type: 建议类型（emotion_balance/activity_recommendation/social_connection/stress_management）
 2. title: 建议标题（简短有力）
 3. content: 建议内容（详细说明，50-100字）
-4. priority: 优先级（高/中/低）
+4. priority: 优先级（high/medium/low）
 5. actionable_steps: 3个可执行的具体步骤
 
 同时提供一个health_summary（不超过50字），概括用户的整体情绪状态。
-**health_summary 必须如实反映情绪分布中所有非零情绪的存在，不得遗漏任何已出现的情绪类型。**
 
 请以JSON格式返回，格式如下：
 {
   "health_summary": "您的情绪健康状况...",
   "suggestions": [
     {
-      "type": "情绪平衡",
+      "type": "emotion_balance",
       "title": "建议标题",
       "content": "建议内容...",
-      "priority": "高",
+      "priority": "high",
       "actionable_steps": ["步骤1", "步骤2", "步骤3"]
     }
   ]
 }
 
 注意事项：
-- 所有输出内容必须完全使用中文，严禁出现任何英文单词或短语（包括情绪类型名称如fear、sadness、anger等，必须使用对应的中文：恐惧、悲伤、愤怒等）
-- 再次强调：情绪分布中出现次数≥1的情绪必须在建议中被提及和回应，绝不能忽略或声称为零
 - 建议要具体、可执行，避免空泛
 - 结合用户的兴趣爱好提供个性化建议
 - 针对主要问题（如主要负面情绪）提供针对性建议
-- 优先级要合理分配（至少1个高，1-2个中，其余低）
+- 优先级要合理分配（至少1个high，1-2个medium，其余low）
 - 每个建议的3个步骤要循序渐进、易于实施
-{% endif %}

api/app/core/memory/utils/prompt/prompts/memory_insight.jinja2

@@ -7,12 +7,6 @@
 
 Your task is to generate a comprehensive memory insight report based on the provided data analysis. The report should include four distinct sections that capture different aspects of the user's memory patterns and characteristics.
 
-{% if language == "zh" %}
-**重要：请使用中文生成记忆洞察报告内容。**
-{% else %}
-**Important: Please generate the memory insight report content in English.**
-{% endif %}
-
 
 ===Inputs===
 {% if domain_distribution %}
@@ -37,105 +31,56 @@ Your task is to generate a comprehensive memory insight report based on the prov
 
 **Section-Specific Requirements:**
 
-{% if language == "zh" %}
-1. **总体概述** (100-150字)
-   - 重点：基于交互日志对用户档案进行整体分析
-   - 描述用户的主要角色、工作网络和协作精神
-   - 使用专业、数据驱动的语言风格
-   - 示例参考："通过对156次交互日志的深度分析，系统发现张三是一位主要从事用户档案和数据分析的产品经理。他的工作网络体现出鲜明的目标导向和团队协作精神。"
+1. **总体概述 (Overview)** (100-150 Chinese characters)
+   - Focus on: Overall analysis of user profile based on interaction logs
+   - Describe the user's main role, work network, and collaboration spirit
+   - Use professional, data-driven language style
+   - Example reference: "通过对156次交互日志的深度分析，系统发现三层一位主要用户档案和数据分析的产品经理。他的工作网络体现出鲜明的目标导向和团队协作精神。"
 
-2. **行为模式** (80-120字)
-   - 重点：工作模式、时间规律和行为特征
-   - 描述每周工作模式和时间偏好
-   - 使用客观、分析性的语言
-   - 示例参考："张三的工作模式呈现出鲜明的周期性：周一通常用于规划和会议，周三周四专注于产品设计和用户研究，周五进行总结和复盘。他倾向于在上午进行头脑风暴，下午处理执行性工作。"
+2. **行为模式 (Behavior Pattern)** (80-120 Chinese characters)
+   - Focus on: Work patterns, time regularity, and behavioral characteristics
+   - Describe weekly work patterns and time preferences
+   - Use objective, analytical language
+   - Example reference: "张三的工作模式呈现出鲜明的周期性：周一通常用于规划和会议，周三周四专注于产品设计和用户研究，周五进行总结和复盘。他倾向于在上午进行头脑风暴，下午处理执行性工作。"
 
-3. **关键发现** (3-4个要点，每个30-50字)
-   - 重点：关于用户行为和偏好的具体、有洞察力的观察
-   - 使用项目符号（•）格式
-   - 每个发现应具体且有数据支持
-   - 示例参考：
+3. **关键发现 (Key Findings)** (3-4 bullet points, 30-50 characters each)
+   - Focus on: Specific, insightful observations about user behavior and preferences
+   - Use bullet points (•) format
+   - Each finding should be concrete and data-supported
+   - Example reference:
      "• 在产品决策中，张三总是优先考虑用户反应，这在68%的决策记录中得到体现
      • 他善于使用数据可视化工具来支持论点，这种习惯在项目管理中发挥了重要作用
      • 团队成员对他的评价中，"思路清晰"和"思路敏捷"两个关键词出现频率最高
      • 他对AI机器学习领域保持持续关注，近3个月参加了7次相关培训"
 
-4. **成长轨迹** (100-150字)
-   - 重点：用户的成长历程、关键里程碑和能力提升
-   - 按时间顺序组织内容
-   - 突出角色变化和成就
-   - 使用积极、鼓励的语气
-   - 示例参考："从入职时的产品经理成长为高级产品经理，张三在产品规划、团队管理和技术理解三个方面都有显著提升。特别是在最近一年，他开始独立主导更复杂的项目，展现出更强的战略思维能力。他的成长轨迹显示出对新技术的持续学习和对产品思维的不断深化。"
-{% else %}
-1. **Overview** (100-150 words)
-   - Focus on: Overall analysis of user profile based on interaction logs
-   - Describe the user's main role, work network, and collaboration spirit
-   - Use professional, data-driven language style
-   - Example reference: "Through in-depth analysis of 156 interaction logs, the system identified Zhang San as a product manager primarily focused on user profiling and data analysis. His work network demonstrates a clear goal-oriented approach and team collaboration spirit."
-
-2. **Behavior Pattern** (80-120 words)
-   - Focus on: Work patterns, time regularity, and behavioral characteristics
-   - Describe weekly work patterns and time preferences
-   - Use objective, analytical language
-   - Example reference: "Zhang San's work pattern shows distinct periodicity: Mondays are typically used for planning and meetings, Wednesdays and Thursdays focus on product design and user research, and Fridays are for summary and review. He tends to brainstorm in the morning and handle execution tasks in the afternoon."
-
-3. **Key Findings** (3-4 bullet points, 30-50 words each)
-   - Focus on: Specific, insightful observations about user behavior and preferences
-   - Use bullet points (•) format
-   - Each finding should be concrete and data-supported
-   - Example reference:
-     "• In product decisions, Zhang San always prioritizes user feedback, as evidenced in 68% of decision records
-     • He excels at using data visualization tools to support arguments, a habit that plays an important role in project management
-     • Among team member evaluations, 'clear thinking' and 'quick thinking' are the most frequently mentioned keywords
-     • He maintains continuous attention to AI and machine learning, attending 7 related training sessions in the past 3 months"
-
-4. **Growth Trajectory** (100-150 words)
+4. **成长轨迹 (Growth Trajectory)** (100-150 Chinese characters)
    - Focus on: User's growth journey, key milestones, and capability improvements
    - Organize content chronologically
    - Highlight role changes and achievements
    - Use positive, encouraging tone
-   - Example reference: "Growing from a product manager at entry to a senior product manager, Zhang San has shown significant improvement in product planning, team management, and technical understanding. Especially in the past year, he has begun to independently lead more complex projects, demonstrating stronger strategic thinking capabilities. His growth trajectory shows continuous learning of new technologies and deepening of product thinking."
-{% endif %}
+   - Example reference: "从入职时的产品经理成长为高级产品经理，张三在产品单独、团队管理和技术理解三个方面都有显著提升。特别是在最近一年，他开始独立主导更复杂的项目，展现出更强的战略思维能力。他的成长轨迹显示出对新技术的持续学习和对产品思维的不断深化。"
 
 
 ===Output Format (MUST STRICTLY FOLLOW)===
 
-{% if language == "zh" %}
 【总体概述】
-[100-150字，基于交互分析描述用户整体档案和工作网络]
+[100-150 characters describing overall user profile and work network based on interaction analysis]
 
 【行为模式】
-[80-120字，描述工作模式、时间规律和行为特征]
+[80-120 characters describing work patterns, time regularity, and behavioral characteristics]
 
 【关键发现】
-• [第一个关键发现，有数据支持，30-50字]
-• [第二个关键发现，有数据支持，30-50字]
-• [第三个关键发现，有数据支持，30-50字]
-• [第四个关键发现，有数据支持，30-50字]
+• [First key finding with data support, 30-50 characters]
+• [Second key finding with data support, 30-50 characters]
+• [Third key finding with data support, 30-50 characters]
+• [Fourth key finding with data support, 30-50 characters]
 
 【成长轨迹】
-[100-150字，描述成长历程、关键里程碑和能力提升]
-{% else %}
-【Overview】
-[100-150 words describing overall user profile and work network based on interaction analysis]
-
-【Behavior Pattern】
-[80-120 words describing work patterns, time regularity, and behavioral characteristics]
-
-【Key Findings】
-• [First key finding with data support, 30-50 words]
-• [Second key finding with data support, 30-50 words]
-• [Third key finding with data support, 30-50 words]
-• [Fourth key finding with data support, 30-50 words]
-
-【Growth Trajectory】
-[100-150 words describing growth journey, milestones, and capability improvements]
-{% endif %}
+[100-150 characters describing growth journey, milestones, and capability improvements]
 
 
 ===Example===
 
-{% if language == "zh" %}
 Example Input:
 - 核心领域分布: 产品管理(38%), 数据分析(24%), 团队协作(21%)
 - 活跃时段: 用户在每年的 4 和 10 月最为活跃
@@ -156,28 +101,6 @@ Example Output:
 
 【成长轨迹】
 从入职时的产品经理成长为高级产品经理，张三在产品规划、团队管理和技术理解三个方面都有显著提升。特别是在最近一年，他开始独立主导更复杂的项目，展现出更强的战略思维能力。他与李明的47条共同记忆见证了他的成长历程。
-{% else %}
-Example Input:
-- Core Domain Distribution: Product Management (38%), Data Analysis (24%), Team Collaboration (21%)
-- Active Periods: User is most active in April and October each year
-- Social Connections: Has the most shared memories (47 entries) with user "Li Ming", primarily during 2020-2023
-
-Example Output:
-【Overview】
-Through in-depth analysis of 156 interaction logs, the system identified Zhang San as a product manager primarily focused on user profiling and data analysis. His work network demonstrates a clear goal-oriented approach and team collaboration spirit, with deep practical experience in product management, data analysis, and team collaboration.
-
-【Behavior Pattern】
-Zhang San's work pattern shows distinct periodicity: Mondays are typically used for planning and meetings, Wednesdays and Thursdays focus on product design and user research, and Fridays are for summary and review. He tends to brainstorm in the morning and handle execution tasks in the afternoon. April and October are his most active periods each year.
-
-【Key Findings】
-• In product decisions, Zhang San always prioritizes user feedback, as evidenced in 68% of decision records
-• He excels at using data visualization tools to support arguments, a habit that plays an important role in project management
-• Among team member evaluations, "clear thinking" and "quick thinking" are the most frequently mentioned keywords
-• He maintains continuous attention to AI and machine learning, attending 7 related training sessions in the past 3 months
-
-【Growth Trajectory】
-Growing from a product manager at entry to a senior product manager, Zhang San has shown significant improvement in product planning, team management, and technical understanding. Especially in the past year, he has begun to independently lead more complex projects, demonstrating stronger strategic thinking capabilities. His 47 shared memories with Li Ming bear witness to his growth journey.
-{% endif %}
 
 ===End of Example===
 
@@ -210,40 +133,20 @@ After generating the report, perform the following self-review steps:
 
 ===Output Requirements===
 
-{% if language == "zh" %}
-**语言要求：**
-- 输出语言必须始终为简体中文
-- 所有章节内容必须使用中文
-- 章节标题必须使用指定的中文格式：【总体概述】【行为模式】【关键发现】【成长轨迹】
-
-**格式要求：**
-- 每个章节必须以标题开头，标题独占一行
-- 内容紧跟标题之后
-- 章节之间用空行分隔
-- 关键发现章节必须使用项目符号（•）
-- 严格遵守每个章节的字数限制
-
-**内容要求：**
-- 仅使用提供的数据点
-- 不得捏造或推测信息
-- 如果某个章节数据不足，请简要说明或跳过
-- 全文保持专业、分析性的语气
-{% else %}
 **LANGUAGE REQUIREMENT:**
-- The output language must ALWAYS be English
-- All section content must be in English
-- Section headers must use the specified English format: 【Overview】【Behavior Pattern】【Key Findings】【Growth Trajectory】
+- The output language should ALWAYS be Chinese (Simplified)
+- All section content must be in Chinese
+- Section headers must use the specified Chinese format: 【总体概述】【行为模式】【关键发现】【成长轨迹】
 
 **FORMAT REQUIREMENT:**
 - Each section must start with its header on a new line
 - Content follows immediately after the header
 - Sections are separated by blank lines
 - Key Findings section must use bullet points (•)
-- Strictly adhere to word limits for each section
+- Strictly adhere to character limits for each section
 
 **CONTENT REQUIREMENT:**
 - Only use provided data points
 - Do not fabricate or speculate information
 - If data is insufficient for a section, provide a brief note or skip
 - Maintain professional, analytical tone throughout
-{% endif %}

api/app/core/memory/utils/prompt/prompts/system.jinja2

@@ -1,7 +1,2 @@
-{% if language == "zh" %}
-你是一个从对话消息中提取实体节点的 AI 助手。
-你的主要任务是提取和分类说话者以及对话中提到的其他重要实体。
-{% else %}
 You are an AI assistant that extracts entity nodes from conversational messages. 
-Your primary task is to extract and classify the speaker and other significant entities mentioned in the conversation.
-{% endif %}
+Your primary task is to extract and classify the speaker and other significant entities mentioned in the conversation.

api/app/core/memory/utils/prompt/prompts/user.jinja2

@@ -1,13 +1,5 @@
-{% if language == "zh" %}
-给定一个对话上下文和一个当前消息。
-你的任务是提取在当前消息中**明确或隐含**提到的用户名称和年龄。
-代词引用（如 he/she/they 或 this/that/those）应消歧为引用实体的名称。
-
-{{ message }}
-{% else %}
 You are given a conversation context and a CURRENT MESSAGE.
 Your task is to extract user name and age mentioned **explicitly or implicitly** in the CURRENT MESSAGE. 
 Pronoun references such as he/she/they or this/that/those should be disambiguated to the names of the reference entities.
 
-{{ message }}
-{% endif %}
+{{ message }}

api/app/core/memory/utils/prompt/prompts/user_summary.jinja2

@@ -7,11 +7,6 @@
 
 Your task is to generate a comprehensive user profile based on the provided entities and statements. The profile should include four distinct sections that capture different aspects of the user's identity and characteristics.
 
-{% if language == "zh" %}
-**重要：请使用中文生成用户画像内容。**
-{% else %}
-**Important: Please generate the user profile content in English.**
-{% endif %}
 
 ===Inputs===
 {% if user_id %}
@@ -35,73 +30,40 @@ Your task is to generate a comprehensive user profile based on the provided enti
 
 **Section-Specific Requirements:**
 
-{% if language == "zh" %}
-1. **基本介绍** (4-5句话，最多150字)
-   - 重点：身份、职业、地点及其他基本人口统计信息
-   - 提供关于用户是谁的事实背景
-
-2. **性格特点** (2-3句话，最多80字)
-   - 重点：性格特征、行为习惯、沟通风格
-   - 描述用户互动和行为中可观察到的模式
-
-3. **核心价值观** (1-2句话，最多50字)
-   - 重点：价值观、信念、目标和愿望
-   - 捕捉对用户最重要的内容以及驱动其决策的因素
-
-4. **一句话总结** (1句话，最多40字)
-   - 提供对用户核心特质的高度浓缩描述
-   - 类似于捕捉其本质的个人标语或座右铭
-{% else %}
-1. **Basic Introduction** (4-5 sentences, max 150 words)
+1. **Basic Introduction** (4-5 sentences, max 150 Chinese characters)
    - Focus on: identity, occupation, location, and other basic demographic information
    - Provide factual background about who the user is
 
-2. **Personality Traits** (2-3 sentences, max 80 words)
+2. **Personality Traits** (2-3 sentences, max 80 Chinese characters)
    - Focus on: personality characteristics, behavioral habits, communication style
    - Describe observable patterns in how the user interacts and behaves
 
-3. **Core Values** (1-2 sentences, max 50 words)
+3. **Core Values** (1-2 sentences, max 50 Chinese characters)
    - Focus on: values, beliefs, goals, and aspirations
    - Capture what matters most to the user and what drives their decisions
 
-4. **One-Sentence Summary** (1 sentence, max 40 words)
+4. **One-Sentence Summary** (1 sentence, max 40 Chinese characters)
    - Provide a highly condensed characterization of the user's core traits
    - Similar to a personal tagline or motto that captures their essence
-{% endif %}
 
 
 ===Output Format (MUST STRICTLY FOLLOW)===
 
-{% if language == "zh" %}
 【基本介绍】
-[4-5句话描述用户的基本身份、职业和地点]
-
-【性格特点】
-[2-3句话描述用户的性格特征、行为习惯和沟通风格]
-
-【核心价值观】
-[1-2句话描述用户的价值观、信念和目标]
-
-【一句话总结】
-[1句话提供对用户核心特质的高度浓缩总结]
-{% else %}
-【Basic Introduction】
 [4-5 sentences describing the user's basic identity, occupation, and location]
 
-【Personality Traits】
+【性格特点】
 [2-3 sentences describing the user's personality traits, behavioral habits, and communication style]
 
-【Core Values】
+【核心价值观】
 [1-2 sentences describing the user's values, beliefs, and goals]
 
-【One-Sentence Summary】
+【一句话总结】
 [1 sentence providing a highly condensed summary of the user's core characteristics]
-{% endif %}
 
 
 ===Example===
 
-{% if language == "zh" %}
 Example Input:
 - User ID: user_12345
 - Core Entities & Frequency: 产品经理 (15), AI (12), 深圳 (10), 数据分析 (8), 团队协作 (7)
@@ -119,25 +81,6 @@ Example Output:
 
 【一句话总结】
 "让每一个产品决策都充满温度。"
-{% else %}
-Example Input:
-- User ID: user_12345
-- Core Entities & Frequency: Product Manager (15), AI (12), San Francisco (10), Data Analysis (8), Team Collaboration (7)
-- Representative Statement Samples: I have been working as a product manager in San Francisco for 5 years | I believe good products come from deep understanding of user needs | I enjoy playing a coordinating role in teams | Data-driven decision making is my work principle
-
-Example Output:
-【Basic Introduction】
-This is a passionate senior product manager based in San Francisco. Over the past 5 years, they have focused on AI and data-driven product design, dedicated to creating products that truly improve users' lives. They believe good products stem from deep understanding of user needs and continuous exploration of technological possibilities.
-
-【Personality Traits】
-Outgoing personality with excellent communication skills and attention to detail. Enjoys playing a coordinating role in teams, helping everyone reach consensus. Maintains optimism when facing challenges, believing every problem has a solution.
-
-【Core Values】
-User-first, data-driven, continuous learning, team collaboration
-
-【One-Sentence Summary】
-"Making every product decision with warmth and purpose."
-{% endif %}
 
 ===End of Example===
 
@@ -148,7 +91,7 @@ Before generating your final output, internally verify:
 1. All content is grounded in provided data (no fabrication)
 2. Format follows the specified structure with correct headers
 3. Tone is objective, third-person, and neutral
-4. All four sections are complete and within character/word limits
+4. All four sections are complete and within character limits
 
 **IMPORTANT: These checks are for your internal use only. DO NOT include them in your output.**
 
@@ -158,24 +101,14 @@ Before generating your final output, internally verify:
 **CRITICAL: Your response must ONLY contain the four sections below. Do not include any reflection, self-review, or meta-commentary.**
 
 **LANGUAGE REQUIREMENT:**
-{% if language == "zh" %}
-- 输出语言必须为简体中文
-- 所有部分内容必须使用中文
-- 部分标题必须使用指定的中文格式：【基本介绍】【性格特点】【核心价值观】【一句话总结】
-{% else %}
-- The output language must be English
-- All section content must be in English
-- Section headers must use the specified format: 【Basic Introduction】【Personality Traits】【Core Values】【One-Sentence Summary】
-{% endif %}
+- The output language should ALWAYS be Chinese (Simplified)
+- All section content must be in Chinese
+- Section headers must use the specified Chinese format: 【基本介绍】【性格特点】【核心价值观】【一句话总结】
 
 **FORMAT REQUIREMENT:**
 - Each section must start with its header on a new line
 - Content follows immediately after the header
 - Sections are separated by blank lines
-{% if language == "zh" %}
-- 严格遵守每个部分的字数限制
-{% else %}
-- Strictly adhere to word limits for each section
-{% endif %}
-- **DO NOT include any text after the final section**
+- Strictly adhere to character limits for each section
+- **DO NOT include any text after the 【一句话总结】 section**
 - **DO NOT output reflection steps, self-review, or verification notes**

api/app/core/memory/utils/validation/ontology_validator.py

@@ -11,7 +11,7 @@ import logging
 import re
 from typing import List, Tuple
 
-from app.core.memory.models.ontology_scenario_models import OntologyClass
+from app.core.memory.models.ontology_models import OntologyClass
 
 
 logger = logging.getLogger(__name__)
@@ -88,10 +88,8 @@ class OntologyValidator:
             logger.warning(f"Validation failed: {error_msg}")
             return False, error_msg
         
-        # Check if starts with uppercase letter (only for ASCII letters)
-        # For Chinese/Unicode characters, skip this check
-        first_char = name[0]
-        if first_char.isascii() and first_char.isalpha() and not first_char.isupper():
+        # Check if starts with uppercase letter
+        if not name[0].isupper():
             error_msg = f"Class name '{name}' must start with an uppercase letter (PascalCase)"
             logger.warning(f"Validation failed: {error_msg}")
             return False, error_msg
@@ -102,9 +100,9 @@ class OntologyValidator:
             logger.warning(f"Validation failed: {error_msg}")
             return False, error_msg
         
-        # Check for invalid characters (allow alphanumeric, underscore, and Unicode characters)
-        if not re.match(r'^[A-Za-z0-9_\u4e00-\u9fff]+$', name):
-            error_msg = f"Class name '{name}' contains invalid characters. Only alphanumeric characters, underscores, and Chinese characters are allowed"
+        # Check for invalid characters (only alphanumeric and underscore allowed)
+        if not re.match(r'^[A-Za-z0-9_]+$', name):
+            error_msg = f"Class name '{name}' contains invalid characters. Only alphanumeric characters and underscores are allowed"
             logger.warning(f"Validation failed: {error_msg}")
             return False, error_msg
         

api/app/core/memory/utils/validation/owl_validator.py

@@ -20,7 +20,7 @@ from owlready2 import (
     OwlReadyInconsistentOntologyError,
 )
 
-from app.core.memory.models.ontology_scenario_models import OntologyClass
+from app.core.memory.models.ontology_models import OntologyClass
 logger = logging.getLogger(__name__)
 
 
@@ -583,156 +583,3 @@ class OWLValidator:
         is_compatible = len(warnings) == 0
         
         return is_compatible, warnings
-
-    def parse_owl_content(
-        self,
-        owl_content: str,
-        format: str = "rdfxml"
-    ) -> List[dict]:
-        """从 OWL 内容解析出本体类型
-        
-        支持解析 RDF/XML、Turtle 和 JSON 格式的 OWL 文件，
-        提取其中定义的 owl:Class 及其 rdfs:label 和 rdfs:comment。
-        
-        Args:
-            owl_content: OWL 文件内容字符串
-            format: 文件格式，支持 "rdfxml"、"turtle"、"json"
-            
-        Returns:
-            解析出的类型列表，每个元素包含:
-            - name: 类型名称（英文标识符）
-            - name_chinese: 中文名称（如果有）
-            - description: 类型描述
-            - parent_class: 父类名称
-            
-        Raises:
-            ValueError: 如果格式不支持或解析失败
-            
-        Examples:
-            >>> validator = OWLValidator()
-            >>> classes = validator.parse_owl_content(owl_xml, format="rdfxml")
-            >>> for cls in classes:
-            ...     print(cls["name"], cls["description"])
-        """
-        valid_formats = ["rdfxml", "turtle", "json"]
-        if format not in valid_formats:
-            raise ValueError(
-                f"Unsupported format '{format}'. Must be one of: {', '.join(valid_formats)}"
-            )
-        
-        # JSON 格式单独处理
-        if format == "json":
-            return self._parse_json_owl(owl_content)
-        
-        # 使用 rdflib 解析 RDF/XML 或 Turtle
-        try:
-            from rdflib import Graph, RDF, RDFS, OWL, Namespace
-            
-            g = Graph()
-            rdf_format = "xml" if format == "rdfxml" else "turtle"
-            g.parse(data=owl_content, format=rdf_format)
-            
-            classes = []
-            
-            # 查找所有 owl:Class
-            for cls_uri in g.subjects(RDF.type, OWL.Class):
-                cls_str = str(cls_uri)
-                
-                # 跳过空节点和 OWL 内置类
-                if cls_str.startswith("http://www.w3.org/") or "/.well-known/" in cls_str:
-                    continue
-                
-                # 提取类名（从 URI 中获取本地名称）
-                if '#' in cls_str:
-                    name = cls_str.split('#')[-1]
-                else:
-                    name = cls_str.split('/')[-1]
-                
-                # 跳过空名称
-                if not name or name == "Thing":
-                    continue
-                
-                # 获取 rdfs:label（可能有多个，包括中英文）
-                labels = list(g.objects(cls_uri, RDFS.label))
-                name_chinese = None
-                label_str = name  # 默认使用 URI 中的名称
-                
-                for label in labels:
-                    label_text = str(label)
-                    # 检查是否包含中文
-                    if any('\u4e00' <= char <= '\u9fff' for char in label_text):
-                        name_chinese = label_text
-                    else:
-                        label_str = label_text
-                
-                # 获取 rdfs:comment（描述）
-                comments = list(g.objects(cls_uri, RDFS.comment))
-                description = str(comments[0]) if comments else None
-                
-                # 获取父类（rdfs:subClassOf）
-                parent_class = None
-                for parent_uri in g.objects(cls_uri, RDFS.subClassOf):
-                    parent_str = str(parent_uri)
-                    # 跳过 owl:Thing
-                    if parent_str == str(OWL.Thing) or parent_str.endswith("#Thing"):
-                        continue
-                    # 提取父类名称
-                    if '#' in parent_str:
-                        parent_class = parent_str.split('#')[-1]
-                    else:
-                        parent_class = parent_str.split('/')[-1]
-                    break  # 只取第一个非 Thing 的父类
-                
-                classes.append({
-                    "name": name,
-                    "name_chinese": name_chinese,
-                    "description": description,
-                    "parent_class": parent_class
-                })
-            
-            logger.info(f"Parsed {len(classes)} classes from OWL content (format: {format})")
-            return classes
-            
-        except Exception as e:
-            error_msg = f"Failed to parse OWL（文档格式不正确） content: {str(e)}"
-            logger.error(error_msg, exc_info=True)
-            raise ValueError(error_msg) from e
-    
-    def _parse_json_owl(self, json_content: str) -> List[dict]:
-        """解析 JSON 格式的 OWL 内容
-        
-        JSON 格式是简化的本体表示，由 export_to_owl 的 json 格式导出。
-        
-        Args:
-            json_content: JSON 格式的 OWL 内容
-            
-        Returns:
-            解析出的类型列表
-        """
-        import json
-        
-        try:
-            data = json.loads(json_content)
-            
-            # 检查是否是我们导出的 JSON 格式
-            if "ontology" in data and "classes" in data["ontology"]:
-                raw_classes = data["ontology"]["classes"]
-            elif "classes" in data:
-                raw_classes = data["classes"]
-            else:
-                raise ValueError("Invalid JSON format: missing 'classes' field")
-            
-            classes = []
-            for cls in raw_classes:
-                classes.append({
-                    "name": cls.get("name", ""),
-                    "name_chinese": cls.get("name_chinese"),
-                    "description": cls.get("description"),
-                    "parent_class": cls.get("parent_class")
-                })
-            
-            logger.info(f"Parsed {len(classes)} classes from JSON content")
-            return classes
-            
-        except json.JSONDecodeError as e:
-            raise ValueError(f"Invalid JSON content: {str(e)}") from e

api/app/core/models/base.py

@@ -81,8 +81,6 @@ class RedBearModelFactory:
             # api_key 格式: "access_key_id:secret_access_key" 或只是 access_key_id
             # region 从 base_url 或 extra_params 获取
             from botocore.config import Config as BotoConfig
-            from app.core.models.bedrock_model_mapper import normalize_bedrock_model_id
-            
             max_pool_connections = int(os.getenv("BEDROCK_MAX_POOL_CONNECTIONS", "50"))
             max_retries = int(os.getenv("BEDROCK_MAX_RETRIES", "2"))
             # Configure with increased connection pool
@@ -91,11 +89,8 @@ class RedBearModelFactory:
                 retries={'max_attempts': max_retries, 'mode': 'adaptive'}
             )
             
-            # 标准化模型 ID（自动转换简化名称为完整 Bedrock Model ID）
-            model_id = normalize_bedrock_model_id(config.model_name)
-            
             params = {
-                "model_id": model_id,
+                "model_id": config.model_name,
                 "config": boto_config,
                 **config.extra_params
             }

api/app/core/models/bedrock_model_mapper.py

@@ -1,188 +0,0 @@
-"""
-AWS Bedrock 模型名称映射器
-
-将简化的模型名称自动转换为正确的 Bedrock Model ID
-"""
-from typing import Optional
-from app.core.logging_config import get_business_logger
-
-logger = get_business_logger()
-
-# Bedrock 模型名称映射表
-BEDROCK_MODEL_MAPPING = {
-    # Claude 3.5 系列
-    "claude-3.5-sonnet": "anthropic.claude-3-5-sonnet-20240620-v1:0",
-    "claude-3-5-sonnet": "anthropic.claude-3-5-sonnet-20240620-v1:0",
-    "claude-sonnet-3.5": "anthropic.claude-3-5-sonnet-20240620-v1:0",
-    "claude-sonnet-3-5": "anthropic.claude-3-5-sonnet-20240620-v1:0",
-    
-    # Claude 3 系列
-    "claude-3-sonnet": "anthropic.claude-3-sonnet-20240229-v1:0",
-    "claude-3-haiku": "anthropic.claude-3-haiku-20240307-v1:0",
-    "claude-3-opus": "anthropic.claude-3-opus-20240229-v1:0",
-    "claude-sonnet": "anthropic.claude-3-sonnet-20240229-v1:0",
-    "claude-haiku": "anthropic.claude-3-haiku-20240307-v1:0",
-    "claude-opus": "anthropic.claude-3-opus-20240229-v1:0",
-    
-    # Claude 2 系列
-    "claude-2": "anthropic.claude-v2",
-    "claude-2.1": "anthropic.claude-v2:1",
-    "claude-instant": "anthropic.claude-instant-v1",
-    
-    # Amazon Titan 系列
-    "titan-text-express": "amazon.titan-text-express-v1",
-    "titan-text-lite": "amazon.titan-text-lite-v1",
-    "titan-embed-text": "amazon.titan-embed-text-v1",
-    "titan-embed-image": "amazon.titan-embed-image-v1",
-    
-    # Meta Llama 系列
-    "llama3-70b": "meta.llama3-70b-instruct-v1:0",
-    "llama3-8b": "meta.llama3-8b-instruct-v1:0",
-    "llama2-70b": "meta.llama2-70b-chat-v1",
-    "llama2-13b": "meta.llama2-13b-chat-v1",
-    
-    # Mistral 系列
-    "mistral-7b": "mistral.mistral-7b-instruct-v0:2",
-    "mixtral-8x7b": "mistral.mixtral-8x7b-instruct-v0:1",
-    "mistral-large": "mistral.mistral-large-2402-v1:0",
-    
-    # 常见错误格式的映射
-    "claude-sonnet-4-5": "anthropic.claude-3-5-sonnet-20240620-v1:0",  # 常见错误
-    "claude-4-5-sonnet": "anthropic.claude-3-5-sonnet-20240620-v1:0",  # 常见错误
-    "claude-sonnet-4.5": "anthropic.claude-3-5-sonnet-20240620-v1:0",  # 常见错误
-}
-
-
-def normalize_bedrock_model_id(model_name: str, region: Optional[str] = None) -> str:
-    """
-    标准化 Bedrock 模型 ID
-    
-    将简化的模型名称转换为正确的 Bedrock Model ID 格式
-    
-    Args:
-        model_name: 模型名称（可能是简化格式或完整格式）
-        region: AWS 区域（可选，如 "us", "eu", "apac"）
-        
-    Returns:
-        str: 标准化的 Bedrock Model ID
-        
-    Examples:
-        >>> normalize_bedrock_model_id("claude-sonnet-4-5")
-        'anthropic.claude-3-5-sonnet-20240620-v1:0'
-        
-        >>> normalize_bedrock_model_id("claude-3.5-sonnet", region="eu")
-        'eu.anthropic.claude-3-5-sonnet-20240620-v1:0'
-        
-        >>> normalize_bedrock_model_id("anthropic.claude-3-5-sonnet-20240620-v1:0")
-        'anthropic.claude-3-5-sonnet-20240620-v1:0'
-    """
-    # 如果已经是正确的格式（包含 provider），直接返回
-    if "." in model_name and not model_name.startswith(("us.", "eu.", "apac.", "sa.", "amer.", "global.", "us-gov.")):
-        # 检查是否是有效的 provider
-        provider = model_name.split(".", 1)[0]
-        valid_providers = ["anthropic", "amazon", "meta", "mistral", "deepseek", "openai", "ai21", "cohere", "stability"]
-        if provider in valid_providers:
-            logger.debug(f"Model ID 已经是正确格式: {model_name}")
-            return model_name
-    
-    # 移除区域前缀（如果存在）
-    original_model_name = model_name
-    region_prefix = None
-    if model_name.startswith(("us.", "eu.", "apac.", "sa.", "amer.", "global.", "us-gov.")):
-        parts = model_name.split(".", 1)
-        region_prefix = parts[0]
-        model_name = parts[1] if len(parts) > 1 else model_name
-    
-    # 转换为小写进行匹配
-    model_name_lower = model_name.lower()
-    
-    # 尝试从映射表中查找
-    if model_name_lower in BEDROCK_MODEL_MAPPING:
-        mapped_id = BEDROCK_MODEL_MAPPING[model_name_lower]
-        logger.info(f"映射模型名称: {original_model_name} -> {mapped_id}")
-        
-        # 如果指定了区域或原始名称包含区域前缀，添加区域前缀
-        if region:
-            mapped_id = f"{region}.{mapped_id}"
-        elif region_prefix:
-            mapped_id = f"{region_prefix}.{mapped_id}"
-        
-        return mapped_id
-    
-    # 如果没有找到映射，返回原始名称并记录警告
-    logger.warning(
-        f"未找到模型名称映射: {original_model_name}。"
-        f"请确保使用正确的 Bedrock Model ID 格式，如 'anthropic.claude-3-5-sonnet-20240620-v1:0'"
-    )
-    return original_model_name
-
-
-def is_bedrock_model_id(model_name: str) -> bool:
-    """
-    检查是否是 Bedrock Model ID 格式
-    
-    Args:
-        model_name: 模型名称
-        
-    Returns:
-        bool: 是否是 Bedrock Model ID 格式
-    """
-    # 移除区域前缀
-    if model_name.startswith(("us.", "eu.", "apac.", "sa.", "amer.", "global.", "us-gov.")):
-        model_name = model_name.split(".", 1)[1]
-    
-    # 检查是否包含 provider
-    if "." not in model_name:
-        return False
-    
-    provider = model_name.split(".", 1)[0]
-    valid_providers = ["anthropic", "amazon", "meta", "mistral", "deepseek", "openai", "ai21", "cohere", "stability"]
-    return provider in valid_providers
-
-
-def get_provider_from_model_id(model_id: str) -> str:
-    """
-    从 Bedrock Model ID 中提取 provider
-    
-    Args:
-        model_id: Bedrock Model ID
-        
-    Returns:
-        str: Provider 名称
-        
-    Examples:
-        >>> get_provider_from_model_id("anthropic.claude-3-5-sonnet-20240620-v1:0")
-        'anthropic'
-        
-        >>> get_provider_from_model_id("eu.anthropic.claude-3-5-sonnet-20240620-v1:0")
-        'anthropic'
-    """
-    # 移除区域前缀
-    if model_id.startswith(("us.", "eu.", "apac.", "sa.", "amer.", "global.", "us-gov.")):
-        parts = model_id.split(".", 2)
-        return parts[1] if len(parts) > 1 else model_id.split(".", 1)[0]
-    
-    return model_id.split(".", 1)[0]
-
-
-# 添加更多映射的辅助函数
-def add_model_mapping(short_name: str, full_model_id: str) -> None:
-    """
-    添加自定义模型名称映射
-    
-    Args:
-        short_name: 简化的模型名称
-        full_model_id: 完整的 Bedrock Model ID
-    """
-    BEDROCK_MODEL_MAPPING[short_name.lower()] = full_model_id
-    logger.info(f"添加模型映射: {short_name} -> {full_model_id}")
-
-
-def get_all_mappings() -> dict:
-    """
-    获取所有模型名称映射
-    
-    Returns:
-        dict: 模型名称映射字典
-    """
-    return BEDROCK_MODEL_MAPPING.copy()

api/app/core/models/scripts/bedrock_models.yaml

@@ -1,4 +1,5 @@
 provider: bedrock
+enabled: true
 models:
 - name: ai21
   type: llm

api/app/core/models/scripts/dashscope_models.yaml

@@ -1,4 +1,5 @@
 provider: dashscope
+enabled: true
 models:
 - name: deepseek-r1-distill-qwen-14b
   type: llm

api/app/core/models/scripts/loader.py

@@ -1,11 +1,11 @@
 """模型配置加载器 - 用于将预定义模型批量导入到数据库"""
 
+import os
 from pathlib import Path
 from typing import Callable
 
 import yaml
 from sqlalchemy.orm import Session
-
 from app.models.models_model import ModelBase, ModelProvider
 
 
@@ -19,9 +19,31 @@ def _load_yaml_config(provider: ModelProvider) -> list[dict]:
     
     with open(config_file, 'r', encoding='utf-8') as f:
         data = yaml.safe_load(f)
+        
+        # 检查是否需要加载（默认为 true）
+        if not data.get('enabled', True):
+            return []
+        
         return data.get('models', [])
 
 
+def _disable_yaml_config(provider: ModelProvider) -> None:
+    """将YAML文件的enabled标志设置为false"""
+    config_dir = Path(__file__).parent
+    config_file = config_dir / f"{provider.value}_models.yaml"
+    
+    if not config_file.exists():
+        return
+    
+    with open(config_file, 'r', encoding='utf-8') as f:
+        data = yaml.safe_load(f)
+    
+    data['enabled'] = False
+    
+    with open(config_file, 'w', encoding='utf-8') as f:
+        yaml.dump(data, f, allow_unicode=True, sort_keys=False)
+
+
 def load_models(db: Session, providers: list[str] = None, silent: bool = False) -> dict:
     """
     加载模型配置到数据库
@@ -53,7 +75,8 @@ def load_models(db: Session, providers: list[str] = None, silent: bool = False)
             
         if not silent:
             print(f"\n正在加载 {provider.value} 的 {len(models)} 个模型...")
-
+        
+        # provider_success = 0
         for model_data in models:
             try:
                 # 检查模型是否已存在
@@ -70,6 +93,7 @@ def load_models(db: Session, providers: list[str] = None, silent: bool = False)
                     if not silent:
                         print(f"更新成功: {model_data['name']}")
                     result["success"] += 1
+                    # provider_success += 1
                 else:
                     # 创建新模型
                     model = ModelBase(**model_data)
@@ -78,12 +102,17 @@ def load_models(db: Session, providers: list[str] = None, silent: bool = False)
                     if not silent:
                         print(f"添加成功: {model_data['name']}")
                     result["success"] += 1
+                    # provider_success += 1
                 
             except Exception as e:
                 db.rollback()
                 if not silent:
                     print(f"添加失败: {model_data['name']} - {str(e)}")
                 result["failed"] += 1
+        
+        # 如果该供应商的模型全部加载成功，将enabled设置为false
+        # if provider_success == len(models):
+        _disable_yaml_config(provider)
     
     return result
 

api/app/core/models/scripts/openai_models.yaml

@@ -1,4 +1,5 @@
 provider: openai
+enabled: true
 models:
 - name: chatgpt-4o-latest
   type: llm

api/app/core/rag/app/naive.py

@@ -670,7 +670,7 @@ def chunk(filename, binary=None, from_page=0, to_page=100000,
             with open(filename, "rb") as f:
                 binary = f.read()
         excel_parser = ExcelParser()
-        if parser_config.get("html4excel") and parser_config.get("html4excel").lower() == "true":
+        if parser_config.get("html4excel"):
             sections = [(_, "") for _ in excel_parser.html(binary, 12) if _]
             parser_config["chunk_token_num"] = 0
         else:

api/app/core/rag/crawler/__main__.py

@@ -1,89 +0,0 @@
-"""Command-line interface for web crawler."""
-
-import argparse
-import logging
-import sys
-from app.core.rag.crawler.web_crawler import WebCrawler
-
-
-def setup_logging(verbose: bool = False):
-    """Set up logging configuration."""
-    level = logging.DEBUG if verbose else logging.INFO
-    logging.basicConfig(
-        level=level,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-        handlers=[
-            logging.StreamHandler(sys.stdout)
-        ]
-    )
-
-
-def main(entry_url: str,
-         max_pages: int = 200,
-         delay_seconds: float = 1.0,
-         timeout_seconds: int = 10,
-         user_agent: str = "KnowledgeBaseCrawler/1.0"):
-    """Main entry point for the crawler."""
-    # Create crawler
-    crawler = WebCrawler(
-        entry_url=entry_url,
-        max_pages=max_pages,
-        delay_seconds=delay_seconds,
-        timeout_seconds=timeout_seconds,
-        user_agent=user_agent
-    )
-
-    # Crawl and collect documents
-    documents = []
-    try:
-        for doc in crawler.crawl():
-            print(f"\n{'=' * 80}")
-            print(f"URL: {doc.url}")
-            print(f"Title: {doc.title}")
-            print(f"Content Length: {doc.content_length} characters")
-            print(f"Word Count: {doc.metadata.get('word_count', 0)} words")
-            print(f"{'=' * 80}\n")
-
-            documents.append({
-                'url': doc.url,
-                'title': doc.title,
-                'content': doc.content,
-                'content_length': doc.content_length,
-                'crawl_timestamp': doc.crawl_timestamp.isoformat(),
-                'http_status': doc.http_status,
-                'metadata': doc.metadata
-            })
-
-    except KeyboardInterrupt:
-        print("\n\nCrawl interrupted by user.")
-
-    except Exception as e:
-        print(f"\n\nError during crawl: {e}")
-        sys.exit(1)
-
-    # Get summary
-    summary = crawler.get_summary()
-    print(f"\n{'=' * 80}")
-    print("CRAWL SUMMARY")
-    print(f"{'=' * 80}")
-    print(f"Total Pages Processed: {summary.total_pages_processed}")
-    print(f"Total Errors: {summary.total_errors}")
-    print(f"Total Skipped: {summary.total_skipped}")
-    print(f"Total URLs Discovered: {summary.total_urls_discovered}")
-    print(f"Duration: {summary.duration_seconds:.2f} seconds")
-    print(f"documents: {documents}")
-
-    if summary.error_breakdown:
-        print(f"\nError Breakdown:")
-        for error_type, count in summary.error_breakdown.items():
-            print(f"  {error_type}: {count}")
-
-
-if __name__ == '__main__':
-    entry_url = "https://www.xxx.com"
-    max_pages = 20
-    delay_seconds = 1.0
-    timeout_seconds = 10
-    user_agent = "KnowledgeBaseCrawler/1.0"
-
-    main(entry_url, max_pages, delay_seconds, timeout_seconds, user_agent)

api/app/core/rag/crawler/content_extractor.py

@@ -1,233 +0,0 @@
-"""Content extractor for web crawler."""
-
-from bs4 import BeautifulSoup
-import re
-import logging
-
-from app.core.rag.crawler.models import ExtractedContent
-
-logger = logging.getLogger(__name__)
-
-
-class ContentExtractor:
-    """Extract clean, readable text from HTML pages."""
-    
-    # Tags to remove completely
-    REMOVE_TAGS = ['script', 'style', 'nav', 'header', 'footer', 'aside']
-    
-    # Tags that typically contain main content
-    MAIN_CONTENT_TAGS = ['article', 'main']
-    
-    # Content extraction tags
-    CONTENT_TAGS = ['p', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'li', 'td', 'th', 'section']
-    
-    def is_static_content(self, html: str) -> bool:
-        """
-        Determine if the HTML represents static content.
-        
-        Detects JavaScript-rendered content by checking for minimal body
-        with heavy script tag presence.
-        
-        Args:
-            html: Raw HTML string
-        
-        Returns:
-            bool: True if static, False if JavaScript-rendered
-        """
-        try:
-            soup = BeautifulSoup(html, 'lxml')
-            
-            # Count script tags
-            script_tags = soup.find_all('script')
-            script_count = len(script_tags)
-            
-            # Get body content (excluding scripts and styles)
-            body = soup.find('body')
-            if not body:
-                return False
-            
-            # Remove scripts and styles temporarily for text check
-            for tag in body.find_all(['script', 'style']):
-                tag.decompose()
-            
-            # Get text content
-            text = body.get_text(strip=True)
-            text_length = len(text)
-            
-            # If there's very little text but many scripts, likely JS-rendered
-            if script_count > 5 and text_length < 200:
-                logger.warning("Detected JavaScript-rendered content (many scripts, little text)")
-                return False
-            
-            # If there's no meaningful text, likely JS-rendered
-            if text_length < 50:
-                logger.warning("Detected JavaScript-rendered content (minimal text)")
-                return False
-            
-            return True
-            
-        except Exception as e:
-            logger.error(f"Error checking if content is static: {e}")
-            return True  # Assume static on error
-    
-    def extract(self, html: str, url: str) -> ExtractedContent:
-        """
-        Extract clean text content from HTML.
-        
-        Args:
-            html: Raw HTML string
-            url: Source URL (for context)
-        
-        Returns:
-            ExtractedContent: Contains title, text, metadata
-        """
-        try:
-            soup = BeautifulSoup(html, 'lxml')
-            
-            # Check if content is static
-            is_static = self.is_static_content(html)
-            
-            # Extract title
-            title = self._extract_title(soup)
-            
-            # Remove unwanted tags
-            for tag_name in self.REMOVE_TAGS:
-                for tag in soup.find_all(tag_name):
-                    tag.decompose()
-            
-            # Extract main content
-            text = self._extract_main_content(soup)
-            
-            # Normalize whitespace
-            text = self._normalize_whitespace(text)
-            
-            # Count words
-            word_count = len(text.split())
-            
-            logger.info(f"Extracted {word_count} words from {url}")
-            
-            return ExtractedContent(
-                title=title,
-                text=text,
-                is_static=is_static,
-                word_count=word_count,
-                metadata={'url': url}
-            )
-            
-        except Exception as e:
-            logger.error(f"Error extracting content from {url}: {e}")
-            return ExtractedContent(
-                title=url,
-                text="",
-                is_static=False,
-                word_count=0,
-                metadata={'url': url, 'error': str(e)}
-            )
-    
-    def _extract_title(self, soup: BeautifulSoup) -> str:
-        """
-        Extract title from HTML.
-        
-        Tries <title> tag first, then first <h1>.
-        
-        Args:
-            soup: BeautifulSoup object
-        
-        Returns:
-            str: Page title
-        """
-        # Try <title> tag
-        title_tag = soup.find('title')
-        if title_tag and title_tag.string:
-            return title_tag.string.strip()
-        
-        # Try first <h1>
-        h1_tag = soup.find('h1')
-        if h1_tag:
-            return h1_tag.get_text(strip=True)
-        
-        # Default to empty string
-        return ""
-    
-    def _extract_main_content(self, soup: BeautifulSoup) -> str:
-        """
-        Extract main content from HTML.
-        
-        Prioritizes semantic HTML5 elements like <article> and <main>.
-        
-        Args:
-            soup: BeautifulSoup object
-        
-        Returns:
-            str: Extracted text content
-        """
-        # Try to find main content area
-        main_content = None
-        
-        # Priority 1: <article> or <main> tags
-        for tag_name in self.MAIN_CONTENT_TAGS:
-            main_content = soup.find(tag_name)
-            if main_content:
-                logger.debug(f"Found main content in <{tag_name}> tag")
-                break
-        
-        # Priority 2: div with role="main"
-        if not main_content:
-            main_content = soup.find('div', role='main')
-            if main_content:
-                logger.debug("Found main content in div[role='main']")
-        
-        # Priority 3: Common class/id patterns
-        if not main_content:
-            for pattern in ['content', 'main', 'article', 'post']:
-                main_content = soup.find(['div', 'section'], class_=re.compile(pattern, re.I))
-                if main_content:
-                    logger.debug(f"Found main content with class pattern '{pattern}'")
-                    break
-                
-                main_content = soup.find(['div', 'section'], id=re.compile(pattern, re.I))
-                if main_content:
-                    logger.debug(f"Found main content with id pattern '{pattern}'")
-                    break
-        
-        # Fallback: use body
-        if not main_content:
-            main_content = soup.find('body')
-            logger.debug("Using <body> as main content (no specific content area found)")
-        
-        # Extract text from content tags
-        if main_content:
-            text_parts = []
-            for tag in main_content.find_all(self.CONTENT_TAGS):
-                text = tag.get_text(strip=True)
-                if text:
-                    text_parts.append(text)
-            
-            return '\n'.join(text_parts)
-        
-        return ""
-    
-    def _normalize_whitespace(self, text: str) -> str:
-        """
-        Normalize whitespace in text.
-        
-        - Collapse multiple spaces to single space
-        - Reduce excessive newlines to maximum 2
-        - Strip leading/trailing whitespace
-        
-        Args:
-            text: Text to normalize
-        
-        Returns:
-            str: Normalized text
-        """
-        # Collapse multiple spaces to single space
-        text = re.sub(r' +', ' ', text)
-        
-        # Reduce excessive newlines to maximum 2
-        text = re.sub(r'\n{3,}', '\n\n', text)
-        
-        # Strip leading/trailing whitespace
-        text = text.strip()
-        
-        return text

api/app/core/rag/crawler/http_fetcher.py

@@ -1,302 +0,0 @@
-"""HTTP fetcher for web crawler."""
-
-import requests
-import time
-import logging
-import re
-from typing import Optional, Dict
-
-
-from app.core.rag.crawler.models import FetchResult
-
-logger = logging.getLogger(__name__)
-
-
-class HTTPFetcher:
-    """Handle HTTP requests with retries, error handling, and response validation."""
-    
-    def __init__(
-        self,
-        timeout: int = 10,
-        max_retries: int = 3,
-        user_agent: str = "KnowledgeBaseCrawler/1.0"
-    ):
-        """
-        Initialize HTTP fetcher.
-        
-        Args:
-            timeout: Request timeout in seconds
-            max_retries: Maximum number of retry attempts
-            user_agent: User-Agent header value
-        """
-        self.timeout = timeout
-        self.max_retries = max_retries
-        self.user_agent = user_agent
-        
-        # Create session for connection pooling
-        self.session = requests.Session()
-        self.session.headers.update({
-            'User-Agent': user_agent
-        })
-    
-    def fetch(self, url: str) -> FetchResult:
-        """
-        Fetch a URL with retry logic and error handling.
-        
-        Args:
-            url: URL to fetch
-        
-        Returns:
-            FetchResult: Contains status_code, content, headers, error info
-        """
-        last_error = None
-        
-        for attempt in range(self.max_retries):
-            try:
-                # Calculate backoff delay for retries
-                if attempt > 0:
-                    backoff_delay = 2 ** (attempt - 1)  # 1s, 2s, 4s
-                    logger.info(f"Retry attempt {attempt + 1}/{self.max_retries} for {url} after {backoff_delay}s")
-                    time.sleep(backoff_delay)
-                
-                # Make HTTP request
-                response = self.session.get(
-                    url,
-                    timeout=self.timeout,
-                    allow_redirects=True
-                )
-                
-                # Handle different status codes
-                if response.status_code == 429:
-                    # Too Many Requests - backoff and retry
-                    logger.warning(f"429 Too Many Requests for {url}, backing off")
-                    if attempt < self.max_retries - 1:
-                        continue
-                
-                if response.status_code == 503:
-                    # Service Unavailable - pause and retry
-                    logger.warning(f"503 Service Unavailable for {url}")
-                    if attempt < self.max_retries - 1:
-                        time.sleep(5)  # Longer pause for 503
-                        continue
-                
-                # Success or client error (don't retry 4xx except 429)
-                if 200 <= response.status_code < 300:
-                    logger.info(f"Successfully fetched {url} (status: {response.status_code})")
-
-                    # Get correctly encoded content
-                    content = self._get_decoded_content(response)
-
-                    return FetchResult(
-                        url=url,
-                        final_url=response.url,
-                        status_code=response.status_code,
-                        content=content,
-                        headers=dict(response.headers),
-                        error=None,
-                        success=True
-                    )
-                elif response.status_code == 404:
-                    logger.info(f"404 Not Found: {url}")
-                    return FetchResult(
-                        url=url,
-                        final_url=response.url,
-                        status_code=response.status_code,
-                        content=None,
-                        headers=dict(response.headers),
-                        error="Not Found",
-                        success=False
-                    )
-                elif 400 <= response.status_code < 500:
-                    logger.warning(f"Client error {response.status_code} for {url}")
-                    return FetchResult(
-                        url=url,
-                        final_url=response.url,
-                        status_code=response.status_code,
-                        content=None,
-                        headers=dict(response.headers),
-                        error=f"Client error: {response.status_code}",
-                        success=False
-                    )
-                elif 500 <= response.status_code < 600:
-                    logger.error(f"Server error {response.status_code} for {url}")
-                    last_error = f"Server error: {response.status_code}"
-                    if attempt < self.max_retries - 1:
-                        continue
-                    return FetchResult(
-                        url=url,
-                        final_url=url,
-                        status_code=response.status_code,
-                        content=None,
-                        headers={},
-                        error=last_error,
-                        success=False
-                    )
-                
-            except requests.exceptions.Timeout:
-                last_error = "Request timeout"
-                logger.warning(f"Timeout fetching {url} (attempt {attempt + 1}/{self.max_retries})")
-                if attempt >= self.max_retries - 1:
-                    break
-                continue
-            
-            except requests.exceptions.SSLError as e:
-                last_error = f"SSL/TLS error: {str(e)}"
-                logger.error(f"SSL/TLS error for {url}: {e}")
-                return FetchResult(
-                    url=url,
-                    final_url=url,
-                    status_code=0,
-                    content=None,
-                    headers={},
-                    error=last_error,
-                    success=False
-                )
-            
-            except requests.exceptions.ConnectionError as e:
-                last_error = f"Connection error: {str(e)}"
-                logger.warning(f"Connection error for {url} (attempt {attempt + 1}/{self.max_retries}): {e}")
-                if attempt >= self.max_retries - 1:
-                    break
-                continue
-            
-            except requests.exceptions.RequestException as e:
-                last_error = f"Request error: {str(e)}"
-                logger.error(f"Request error for {url}: {e}")
-                if attempt >= self.max_retries - 1:
-                    break
-                continue
-        
-        # All retries exhausted
-        logger.error(f"Failed to fetch {url} after {self.max_retries} attempts: {last_error}")
-        return FetchResult(
-            url=url,
-            final_url=url,
-            status_code=0,
-            content=None,
-            headers={},
-            error=last_error or "Unknown error",
-            success=False
-        )
-
-    def _get_decoded_content(self, response) -> str:
-        """
-        Get correctly decoded content from response.
-
-        Handles encoding detection and fallback strategies:
-        1. Try encoding from HTML meta tags
-        2. Try response.encoding (from Content-Type header or detected)
-        3. Try UTF-8
-        4. Try common encodings (GB2312, GBK for Chinese, etc.)
-        5. Fall back to latin-1 with error replacement
-
-        Args:
-            response: requests.Response object
-
-        Returns:
-            str: Decoded content
-        """
-        # Try to detect encoding from HTML meta tags
-        meta_encoding = self._detect_encoding_from_meta(response.content)
-        if meta_encoding:
-            try:
-                content = response.content.decode(meta_encoding)
-                logger.info(f"Successfully decoded with meta tag encoding: {meta_encoding}")
-                return content
-            except (UnicodeDecodeError, LookupError) as e:
-                logger.warning(f"Failed to decode with meta encoding {meta_encoding}: {e}")
-
-        # Try response.encoding (from Content-Type header or detected by requests)
-        if response.encoding and response.encoding.lower() != 'iso-8859-1':
-            # Note: requests defaults to ISO-8859-1 if no charset in Content-Type,
-            # so we skip it here and try UTF-8 first
-            try:
-                return response.text
-            except (UnicodeDecodeError, LookupError) as e:
-                logger.warning(f"Failed to decode with detected encoding {response.encoding}: {e}")
-
-        # Try UTF-8 first (most common)
-        try:
-            return response.content.decode('utf-8')
-        except UnicodeDecodeError:
-            logger.debug("UTF-8 decoding failed, trying other encodings")
-
-        # Try common encodings for different languages
-        encodings_to_try = [
-            'gbk',  # Chinese (Simplified)
-            'gb2312',  # Chinese (Simplified, older)
-            'gb18030',  # Chinese (Simplified, extended)
-            'big5',  # Chinese (Traditional)
-            'shift_jis',  # Japanese
-            'euc-jp',  # Japanese
-            'euc-kr',  # Korean
-            'iso-8859-1',  # Western European
-            'windows-1252',  # Windows Western European
-            'windows-1251',  # Cyrillic
-        ]
-
-        for encoding in encodings_to_try:
-            try:
-                content = response.content.decode(encoding)
-                logger.info(f"Successfully decoded with {encoding}")
-                return content
-            except (UnicodeDecodeError, LookupError):
-                continue
-
-        # Last resort: use latin-1 with error replacement
-        logger.warning("All encoding attempts failed, using latin-1 with error replacement")
-        return response.content.decode('latin-1', errors='replace')
-
-    def _detect_encoding_from_meta(self, content: bytes) -> Optional[str]:
-        """
-        Detect encoding from HTML meta tags.
-
-        Looks for:
-        - <meta charset="...">
-        - <meta http-equiv="Content-Type" content="...; charset=...">
-
-        Args:
-            content: Raw response content (bytes)
-
-        Returns:
-            Optional[str]: Detected encoding or None
-        """
-        try:
-            # Only check first 2KB for performance
-            head = content[:2048]
-
-            # Try to decode as ASCII/Latin-1 to search for meta tags
-            try:
-                head_str = head.decode('ascii', errors='ignore')
-            except:
-                head_str = head.decode('latin-1', errors='ignore')
-
-            # Look for <meta charset="...">
-            charset_match = re.search(
-                r'<meta[^>]+charset=["\']?([a-zA-Z0-9_-]+)',
-                head_str,
-                re.IGNORECASE
-            )
-            if charset_match:
-                encoding = charset_match.group(1).lower()
-                logger.debug(f"Found charset in meta tag: {encoding}")
-                return encoding
-
-            # Look for <meta http-equiv="Content-Type" content="...; charset=...">
-            content_type_match = re.search(
-                r'<meta[^>]+http-equiv=["\']?content-type["\']?[^>]+content=["\']([^"\']+)',
-                head_str,
-                re.IGNORECASE
-            )
-            if content_type_match:
-                content_value = content_type_match.group(1)
-                charset_match = re.search(r'charset=([a-zA-Z0-9_-]+)', content_value, re.IGNORECASE)
-                if charset_match:
-                    encoding = charset_match.group(1).lower()
-                    logger.debug(f"Found charset in Content-Type meta: {encoding}")
-                    return encoding
-
-        except Exception as e:
-            logger.debug(f"Error detecting encoding from meta tags: {e}")
-
-        return None

api/app/core/rag/crawler/models.py

@@ -1,52 +0,0 @@
-"""Data models for web crawler."""
-
-from dataclasses import dataclass, field
-from datetime import datetime
-from typing import Dict, Any, Optional
-
-
-@dataclass
-class CrawledDocument:
-    """Represents a successfully processed web page with extracted content."""
-    url: str
-    title: str
-    content: str
-    content_length: int
-    crawl_timestamp: datetime
-    http_status: int
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-
-@dataclass
-class FetchResult:
-    """Represents the result of an HTTP fetch operation."""
-    url: str
-    final_url: str
-    status_code: int
-    content: Optional[str]
-    headers: Dict[str, str]
-    error: Optional[str]
-    success: bool
-
-
-@dataclass
-class ExtractedContent:
-    """Represents content extracted from HTML."""
-    title: str
-    text: str
-    is_static: bool
-    word_count: int
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-
-@dataclass
-class CrawlSummary:
-    """Represents statistics from a completed crawl."""
-    total_pages_processed: int
-    total_errors: int
-    total_skipped: int
-    total_urls_discovered: int
-    start_time: datetime
-    end_time: datetime
-    duration_seconds: float
-    error_breakdown: Dict[str, int] = field(default_factory=dict)

api/app/core/rag/crawler/rate_limiter.py

@@ -1,57 +0,0 @@
-"""Rate limiter for web crawler."""
-
-import time
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class RateLimiter:
-    """Enforce delays between requests to be polite to servers."""
-    
-    def __init__(self, delay_seconds: float = 1.0):
-        """
-        Initialize rate limiter.
-        
-        Args:
-            delay_seconds: Minimum delay between requests
-        """
-        self.delay_seconds = delay_seconds
-        self.last_request_time = 0.0
-        self.max_delay = 60.0  # Cap maximum delay at 60 seconds
-    
-    def wait(self):
-        """
-        Block until enough time has passed since last request.
-        Respects the configured delay.
-        """
-        current_time = time.time()
-        elapsed = current_time - self.last_request_time
-        
-        if elapsed < self.delay_seconds:
-            sleep_time = self.delay_seconds - elapsed
-            logger.debug(f"Rate limiting: sleeping for {sleep_time:.2f} seconds")
-            time.sleep(sleep_time)
-        
-        self.last_request_time = time.time()
-    
-    def set_delay(self, delay_seconds: float):
-        """
-        Update the delay (useful for respecting Crawl-delay from robots.txt).
-        
-        Args:
-            delay_seconds: New delay in seconds
-        """
-        self.delay_seconds = min(delay_seconds, self.max_delay)
-        logger.info(f"Rate limiter delay updated to {self.delay_seconds} seconds")
-    
-    def backoff(self, multiplier: float = 2.0):
-        """
-        Increase delay exponentially for backoff scenarios (429, 503 responses).
-        
-        Args:
-            multiplier: Factor to multiply current delay by
-        """
-        old_delay = self.delay_seconds
-        self.delay_seconds = min(self.delay_seconds * multiplier, self.max_delay)
-        logger.warning(f"Rate limiter backing off: {old_delay:.2f}s -> {self.delay_seconds:.2f}s")

api/app/core/rag/crawler/robots_parser.py

@@ -1,118 +0,0 @@
-"""Robots.txt parser for web crawler."""
-
-from urllib.robotparser import RobotFileParser
-from urllib.parse import urlparse, urljoin
-from typing import Optional
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class RobotsParser:
-    """Parse and check robots.txt compliance for URLs."""
-    
-    def __init__(self, user_agent: str, timeout: int = 10):
-        """
-        Initialize robots.txt parser.
-        
-        Args:
-            user_agent: User agent string to check permissions for
-            timeout: Timeout for fetching robots.txt
-        """
-        self.user_agent = user_agent
-        self.timeout = timeout
-        self._parsers = {}  # Cache parsers by domain
-    
-    def _get_robots_url(self, url: str) -> str:
-        """
-        Get the robots.txt URL for a given URL.
-        
-        Args:
-            url: URL to get robots.txt for
-        
-        Returns:
-            str: robots.txt URL
-        """
-        parsed = urlparse(url)
-        robots_url = f"{parsed.scheme}://{parsed.netloc}/robots.txt"
-        return robots_url
-    
-    def _get_parser(self, url: str) -> RobotFileParser:
-        """
-        Get or create a RobotFileParser for the domain.
-        
-        Args:
-            url: URL to get parser for
-        
-        Returns:
-            RobotFileParser: Parser for the domain
-        """
-        robots_url = self._get_robots_url(url)
-        
-        # Return cached parser if available
-        if robots_url in self._parsers:
-            return self._parsers[robots_url]
-        
-        # Create new parser
-        parser = RobotFileParser()
-        parser.set_url(robots_url)
-        
-        try:
-            # Fetch and parse robots.txt
-            parser.read()
-            logger.info(f"Successfully fetched robots.txt from {robots_url}")
-        except Exception as e:
-            # If robots.txt cannot be fetched, assume all URLs are allowed
-            logger.warning(f"Could not fetch robots.txt from {robots_url}: {e}. Assuming all URLs allowed.")
-            # Create a permissive parser
-            parser = RobotFileParser()
-            parser.parse([])  # Empty robots.txt allows everything
-        
-        # Cache the parser
-        self._parsers[robots_url] = parser
-        return parser
-    
-    def can_fetch(self, url: str) -> bool:
-        """
-        Check if the given URL can be fetched according to robots.txt.
-        
-        Args:
-            url: URL to check
-        
-        Returns:
-            bool: True if allowed, False if disallowed
-        """
-        try:
-            parser = self._get_parser(url)
-            allowed = parser.can_fetch(self.user_agent, url)
-            
-            if not allowed:
-                logger.info(f"URL disallowed by robots.txt: {url}")
-            
-            return allowed
-        except Exception as e:
-            logger.error(f"Error checking robots.txt for {url}: {e}")
-            # On error, assume allowed
-            return True
-    
-    def get_crawl_delay(self, url: str) -> Optional[float]:
-        """
-        Get the Crawl-delay directive from robots.txt if present.
-        
-        Args:
-            url: URL to get crawl delay for
-        
-        Returns:
-            Optional[float]: Delay in seconds, or None if not specified
-        """
-        try:
-            parser = self._get_parser(url)
-            delay = parser.crawl_delay(self.user_agent)
-            
-            if delay is not None:
-                logger.info(f"Crawl-delay from robots.txt: {delay} seconds")
-            
-            return delay
-        except Exception as e:
-            logger.error(f"Error getting crawl delay for {url}: {e}")
-            return None

api/app/core/rag/crawler/url_normalizer.py

@@ -1,171 +0,0 @@
-"""URL normalization and validation for web crawler."""
-
-from typing import Optional, List
-from urllib.parse import urlparse, urlunparse, parse_qs, urlencode, urljoin
-from bs4 import BeautifulSoup
-
-
-class URLNormalizer:
-    """Normalize and validate URLs for deduplication and domain checking."""
-    
-    # Common tracking parameters to remove
-    TRACKING_PARAMS = {
-        'utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
-        'fbclid', 'gclid', 'msclkid', '_ga', 'mc_cid', 'mc_eid'
-    }
-    
-    def __init__(self, base_domain: str):
-        """
-        Initialize URL normalizer with base domain.
-        
-        Args:
-            base_domain: The domain to use for same-domain checks
-        """
-        parsed = urlparse(base_domain)
-        self.base_domain = parsed.netloc.lower() # example.com:8000
-        self.base_scheme = parsed.scheme or 'https' # https
-    
-    def normalize(self, url: str) -> Optional[str]:
-        """
-        Normalize a URL for deduplication.
-        
-        Normalization rules:
-        1. Convert domain to lowercase
-        2. Remove fragments (#section)
-        3. Remove default ports (80 for http, 443 for https)
-        4. Remove trailing slashes (except for root)
-        5. Sort query parameters alphabetically
-        6. Remove common tracking parameters
-        
-        Args:
-            url: URL to normalize
-        
-        Returns:
-            Optional[str]: Normalized URL, or None if invalid
-        """
-        try:
-            parsed = urlparse(url)
-            
-            # Validate scheme
-            if parsed.scheme not in ('http', 'https'):
-                return None
-            
-            # Normalize domain to lowercase
-            netloc = parsed.netloc.lower()
-            
-            # Remove default ports
-            if ':' in netloc:
-                host, port = netloc.rsplit(':', 1)
-                if (parsed.scheme == 'http' and port == '80') or \
-                   (parsed.scheme == 'https' and port == '443'):
-                    netloc = host
-            
-            # Normalize path
-            path = parsed.path
-            # Remove trailing slash except for root
-            if path != '/' and path.endswith('/'):
-                path = path.rstrip('/')
-            # Ensure path starts with /
-            if not path:
-                path = '/'
-            
-            # Process query parameters
-            query = ''
-            if parsed.query:
-                # Parse query parameters
-                params = parse_qs(parsed.query, keep_blank_values=True)
-                # Remove tracking parameters
-                filtered_params = {
-                    k: v for k, v in params.items() 
-                    if k not in self.TRACKING_PARAMS
-                }
-                # Sort parameters alphabetically
-                if filtered_params:
-                    sorted_params = sorted(filtered_params.items())
-                    query = urlencode(sorted_params, doseq=True)
-            
-            # Reconstruct URL without fragment
-            normalized = urlunparse((
-                parsed.scheme,
-                netloc,
-                path,
-                parsed.params,
-                query,
-                ''  # Remove fragment
-            ))
-            
-            return normalized
-            
-        except Exception:
-            return None
-    
-    def is_same_domain(self, url: str) -> bool:
-        """
-        Check if URL belongs to the same domain as base_domain.
-        
-        Args:
-            url: URL to check
-        
-        Returns:
-            bool: True if same domain, False otherwise
-        """
-        try:
-            parsed = urlparse(url)
-            domain = parsed.netloc.lower()
-            
-            # Remove port if present
-            if ':' in domain:
-                domain = domain.split(':')[0]
-            
-            # Check if domains match
-            return domain == self.base_domain or domain == self.base_domain.split(':')[0]
-            
-        except Exception:
-            return False
-    
-    def extract_links(self, html: str, base_url: str) -> List[str]:
-        """
-        Extract and normalize all links from HTML.
-        
-        Args:
-            html: HTML content
-            base_url: Base URL for resolving relative links
-        
-        Returns:
-            List[str]: List of normalized absolute URLs
-        """
-        links = []
-        
-        try:
-            soup = BeautifulSoup(html, 'lxml')
-            
-            # Find all anchor tags
-            for anchor in soup.find_all('a', href=True):
-                href = anchor['href']
-                
-                # Skip empty hrefs
-                if not href or href.strip() == '':
-                    continue
-                
-                # Skip javascript: and mailto: links
-                if href.startswith(('javascript:', 'mailto:', 'tel:')):
-                    continue
-
-                normalized_url = None
-                # Check if href starts with http/https (absolute URL)
-                if href.startswith(('http://', 'https://')):
-                    if self.is_same_domain(href):
-                        normalized_url = self.normalize(href)
-                else:
-                    # Convert relative URL to absolute
-                    absolute_url = urljoin(base_url, href)
-                    # Normalize the URL
-                    normalized_url = self.normalize(absolute_url)
-                
-                if normalized_url:
-                    links.append(normalized_url)
-
-        except Exception:
-            pass
-        
-        return links

api/app/core/rag/crawler/web_crawler.py

@@ -1,215 +0,0 @@
-"""Main web crawler orchestrator."""
-
-from collections import deque
-from datetime import datetime
-from typing import Iterator, Optional, List, Set
-from urllib.parse import urlparse
-import logging
-
-from app.core.rag.crawler.url_normalizer import URLNormalizer
-from app.core.rag.crawler.robots_parser import RobotsParser
-from app.core.rag.crawler.rate_limiter import RateLimiter
-from app.core.rag.crawler.http_fetcher import HTTPFetcher
-from app.core.rag.crawler.content_extractor import ContentExtractor
-from app.core.rag.crawler.models import CrawledDocument, CrawlSummary
-
-logger = logging.getLogger(__name__)
-
-
-class WebCrawler:
-    """Main orchestrator for web crawling."""
-    
-    def __init__(
-        self,
-        entry_url: str,
-        max_pages: int = 200,
-        delay_seconds: float = 1.0,
-        timeout_seconds: int = 10,
-        user_agent: str = "KnowledgeBaseCrawler/1.0",
-        include_patterns: Optional[List[str]] = None,
-        exclude_patterns: Optional[List[str]] = None,
-        content_extractor: Optional[ContentExtractor] = None
-    ):
-        """
-        Initialize the web crawler.
-        
-        Args:
-            entry_url: Starting URL for the crawl
-            max_pages: Maximum number of pages to crawl (default: 200)
-            delay_seconds: Delay between requests in seconds (default: 1.0)
-            timeout_seconds: HTTP request timeout (default: 10)
-            user_agent: User-Agent header string
-            include_patterns: List of regex patterns for URLs to include
-            exclude_patterns: List of regex patterns for URLs to exclude
-            content_extractor: Custom content extractor (optional)
-        """
-        # Validate entry URL
-        parsed = urlparse(entry_url)
-        if not parsed.scheme or not parsed.netloc:
-            raise ValueError(f"Invalid entry URL: {entry_url}")
-        
-        self.entry_url = entry_url
-        self.max_pages = max_pages
-        self.user_agent = user_agent
-        
-        # Extract domain from entry URL
-        self.domain = parsed.netloc
-        
-        # Initialize components
-        self.url_normalizer = URLNormalizer(entry_url)
-        self.robots_parser = RobotsParser(user_agent, timeout_seconds)
-        self.rate_limiter = RateLimiter(delay_seconds)
-        self.http_fetcher = HTTPFetcher(timeout_seconds, max_retries=3, user_agent=user_agent)
-        self.content_extractor = content_extractor or ContentExtractor()
-        
-        # State management
-        self.url_queue: deque = deque()
-        self.visited_urls: Set[str] = set()
-        self.pages_processed = 0
-        
-        # Statistics
-        self.stats = {
-            'success': 0,
-            'errors': 0,
-            'skipped': 0,
-            'urls_discovered': 0,
-            'error_breakdown': {}
-        }
-        self.start_time: Optional[datetime] = None
-        self.end_time: Optional[datetime] = None
-    
-    def crawl(self) -> Iterator[CrawledDocument]:
-        """
-        Execute the crawl and yield documents as they are processed.
-        
-        Yields:
-            CrawledDocument: Structured document with extracted content
-        """
-        logger.info(f"Starting crawl from {self.entry_url} (max_pages: {self.max_pages})")
-        self.start_time = datetime.now()
-        
-        # Add entry URL to queue
-        normalized_entry = self.url_normalizer.normalize(self.entry_url)
-        if normalized_entry:
-            self.url_queue.append(normalized_entry)
-            self.stats['urls_discovered'] += 1
-        
-        # Check robots.txt and update rate limiter if needed
-        crawl_delay = self.robots_parser.get_crawl_delay(self.entry_url)
-        if crawl_delay:
-            self.rate_limiter.set_delay(crawl_delay)
-        
-        # Main crawl loop
-        while self.url_queue and self.pages_processed < self.max_pages:
-            url = self.url_queue.popleft()
-            
-            # Skip if already visited
-            if url in self.visited_urls:
-                continue
-            
-            # Mark as visited
-            self.visited_urls.add(url)
-            
-            # Check robots.txt permission
-            if not self.robots_parser.can_fetch(url):
-                logger.info(f"Skipping {url} (disallowed by robots.txt)")
-                self.stats['skipped'] += 1
-                continue
-            
-            # Apply rate limiting
-            self.rate_limiter.wait()
-            
-            # Fetch URL
-            logger.info(f"Fetching {url} ({self.pages_processed + 1}/{self.max_pages})")
-            fetch_result = self.http_fetcher.fetch(url)
-            
-            # Handle fetch errors
-            if not fetch_result.success:
-                self._record_error(fetch_result.error or "Unknown error")
-                continue
-            
-            # Check Content-Type
-            content_type = fetch_result.headers.get('Content-Type', '').lower()
-            if not any(substring in content_type for substring in ['text/html', 'application/xhtml+xml']):
-                logger.warning(f"Skipping {url} (Content-Type: {content_type})")
-                self.stats['skipped'] += 1
-                continue
-
-            # Extract content
-            try:
-                extracted = self.content_extractor.extract(fetch_result.content, url)
-                
-                # Check if static content
-                if not extracted.is_static:
-                    logger.warning(f"Skipping {url} (JavaScript-rendered content)")
-                    self.stats['skipped'] += 1
-                    continue
-                
-                # Create document
-                document = CrawledDocument(
-                    url=url,
-                    title=extracted.title,
-                    content=extracted.text,
-                    content_length=len(extracted.text),
-                    crawl_timestamp=datetime.now(),
-                    http_status=fetch_result.status_code,
-                    metadata={
-                        'word_count': extracted.word_count,
-                        'final_url': fetch_result.final_url
-                    }
-                )
-                
-                # Update statistics
-                self.pages_processed += 1
-                self.stats['success'] += 1
-                
-                # Extract and queue links
-                links = self.url_normalizer.extract_links(fetch_result.content, url)
-                for link in links:
-                    if link not in self.visited_urls and self.url_normalizer.is_same_domain(link):
-                        if link not in self.url_queue:
-                            self.url_queue.append(link)
-                            self.stats['urls_discovered'] += 1
-                
-                # Yield document
-                yield document
-                
-            except Exception as e:
-                logger.error(f"Error processing {url}: {e}")
-                self._record_error(f"Processing error: {str(e)}")
-                continue
-        
-        self.end_time = datetime.now()
-        logger.info(f"Crawl completed. Processed {self.pages_processed} pages.")
-    
-    def get_summary(self) -> CrawlSummary:
-        """
-        Get summary statistics after crawl completion.
-        
-        Returns:
-            CrawlSummary: Statistics including success/error/skip counts
-        """
-        if not self.start_time:
-            self.start_time = datetime.now()
-        if not self.end_time:
-            self.end_time = datetime.now()
-        
-        duration = (self.end_time - self.start_time).total_seconds()
-        
-        return CrawlSummary(
-            total_pages_processed=self.stats['success'],
-            total_errors=self.stats['errors'],
-            total_skipped=self.stats['skipped'],
-            total_urls_discovered=self.stats['urls_discovered'],
-            start_time=self.start_time,
-            end_time=self.end_time,
-            duration_seconds=duration,
-            error_breakdown=self.stats['error_breakdown']
-        )
-    
-    def _record_error(self, error: str):
-        """Record an error in statistics."""
-        self.stats['errors'] += 1
-        error_type = error.split(':')[0] if ':' in error else error
-        self.stats['error_breakdown'][error_type] = \
-            self.stats['error_breakdown'].get(error_type, 0) + 1

api/app/core/rag/integrations/__init__.py

@@ -1 +0,0 @@
-"""Integrations package for external services."""

api/app/core/rag/integrations/feishu/__init__.py

@@ -1 +0,0 @@
-"""Feishu integration module for document synchronization."""

api/app/core/rag/integrations/feishu/__main__.py

@@ -1,84 +0,0 @@
-"""Command-line interface for feishu integration."""
-
-import asyncio
-import sys
-from app.core.rag.integrations.feishu.client import FeishuAPIClient
-from app.core.rag.integrations.feishu.models import FileInfo
-
-
-def main(feishu_app_id: str,  # Feishu application ID
-               feishu_app_secret: str,  # Feishu application secret
-               feishu_folder_token: str,  # Feishu Folder Token
-               save_dir: str,       # save file directory
-               feishu_api_base_url: str = "https://open.feishu.cn/open-apis",  # Feishu API base URL
-               timeout: int = 30,  # Request timeout in seconds
-               max_retries: int = 3,  # Maximum number of retries
-               recursive: bool = True # recursive: Whether to sync subfolders recursively,
-               ):
-    """Main entry point for the feishuAPIClient."""
-    # Create feishuAPIClient
-    api_client = FeishuAPIClient(
-        app_id=feishu_app_id,
-        app_secret=feishu_app_secret,
-        api_base_url=feishu_api_base_url,
-        timeout=timeout,
-        max_retries=max_retries
-    )
-
-    # Get all files from folder
-    async def async_get_files(api_client: FeishuAPIClient, feishu_folder_token: str):
-        async with api_client as client:
-            if recursive:
-                files = await client.list_all_folder_files(feishu_folder_token, recursive=True)
-            else:
-                all_files = []
-                page_token = None
-                while True:
-                    files_page, page_token = await client.list_folder_files(
-                        feishu_folder_token, page_token
-                    )
-                    all_files.extend(files_page)
-                    if not page_token:
-                        break
-                files = all_files
-            return files
-    files = asyncio.run(async_get_files(api_client,feishu_folder_token))
-
-    # Filter out folders, only sync documents
-    # documents = [f for f in files if f.type in ["doc", "docx", "sheet", "bitable", "file", "slides"]]
-    documents = [f for f in files if f.type in ["doc", "docx", "sheet", "bitable", "file"]]
-
-    try:
-        for doc in documents:
-            print(f"\n{'=' * 80}")
-            print(f"token: {doc.token}")
-            print(f"name: {doc.name}")
-            print(f"type: {doc.type}")
-            print(f"created_time: {doc.created_time}")
-            print(f"modified_time: {doc.modified_time}")
-            print(f"owner_id: {doc.owner_id}")
-            print(f"url: {doc.url}")
-            print(f"{'=' * 80}\n")
-            # download document from Feishu FileInfo
-            async def async_download_document(api_client: FeishuAPIClient, doc: FileInfo, save_dir: str):
-                async with api_client as client:
-                    file_path = await client.download_document(document=doc, save_dir=save_dir)
-                    return file_path
-
-            file_path = asyncio.run(async_download_document(api_client, doc, save_dir))
-            print(file_path)
-
-    except KeyboardInterrupt:
-        print("\n\nfeishu integration interrupted by user.")
-
-    except Exception as e:
-        print(f"\n\nError during feishu integration: {e}")
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    feishu_app_id = ""
-    feishu_app_secret = ""
-    feishu_folder_token = ""
-    save_dir = "/Volumes/MacintoshBD/Repository/RedBearAI/MemoryBear/api/files/"
-    main(feishu_app_id, feishu_app_secret, feishu_folder_token, save_dir)

api/app/core/rag/integrations/feishu/client.py

@@ -1,452 +0,0 @@
-"""Feishu API client for document operations."""
-
-import asyncio
-import os
-import re
-from typing import Optional, Tuple, List
-from datetime import datetime, timedelta
-import httpx
-from cachetools import TTLCache
-import urllib.parse
-
-from app.core.rag.integrations.feishu.exceptions import (
-    FeishuAuthError,
-    FeishuAPIError,
-    FeishuNotFoundError,
-    FeishuPermissionError,
-    FeishuRateLimitError,
-    FeishuNetworkError,
-)
-from app.core.rag.integrations.feishu.models import FileInfo
-from app.core.rag.integrations.feishu.retry import with_retry
-
-
-class FeishuAPIClient:
-    """Feishu API client for document synchronization."""
-
-    def __init__(
-        self,
-        app_id: str,
-        app_secret: str,
-        api_base_url: str = "https://open.feishu.cn/open-apis",
-        timeout: int = 30,
-        max_retries: int = 3
-    ):
-        """
-        Initialize Feishu API client.
-        
-        Args:
-            app_id: Feishu application ID
-            app_secret: Feishu application secret
-            api_base_url: Feishu API base URL
-            timeout: Request timeout in seconds
-            max_retries: Maximum number of retries
-        """
-        self.app_id = app_id
-        self.app_secret = app_secret
-        self.api_base_url = api_base_url
-        self.timeout = timeout
-        self.max_retries = max_retries
-        self._http_client: Optional[httpx.AsyncClient] = None
-        self._token_cache: TTLCache = TTLCache(maxsize=1, ttl=7200 - 300)  # 2 hours - 5 minutes
-        self._token_lock = asyncio.Lock()
-
-    async def __aenter__(self):
-        """Async context manager entry."""
-        self._http_client = httpx.AsyncClient(
-            base_url=self.api_base_url,
-            timeout=self.timeout,
-            headers={"Content-Type": "application/json"}
-        )
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit."""
-        if self._http_client:
-            await self._http_client.aclose()
-
-    async def get_tenant_access_token(self) -> str:
-        """
-        Get tenant access token with caching.
-        
-        Returns:
-            Access token string
-            
-        Raises:
-            FeishuAuthError: If authentication fails
-        """
-        # Check cache first
-        cached_token = self._token_cache.get("access_token")
-        if cached_token:
-            return cached_token
-
-        # Use lock to prevent concurrent token requests
-        async with self._token_lock:
-            # Double-check cache after acquiring lock
-            cached_token = self._token_cache.get("access_token")
-            if cached_token:
-                return cached_token
-
-            # Request new token
-            try:
-                if not self._http_client:
-                    raise FeishuAuthError("HTTP client not initialized")
-
-                response = await self._http_client.post(
-                    "/auth/v3/tenant_access_token/internal",
-                    json={
-                        "app_id": self.app_id,
-                        "app_secret": self.app_secret
-                    }
-                )
-
-                data = response.json()
-
-                if data.get("code") != 0:
-                    error_msg = data.get("msg", "Unknown error")
-                    raise FeishuAuthError(
-                        f"Authentication failed: {error_msg}",
-                        error_code=str(data.get("code")),
-                        details=data
-                    )
-
-                token = data.get("tenant_access_token")
-                if not token:
-                    raise FeishuAuthError("No access token in response")
-
-                # Cache the token
-                self._token_cache["access_token"] = token
-
-                return token
-
-            except httpx.HTTPError as e:
-                raise FeishuAuthError(f"HTTP error during authentication: {str(e)}")
-            except Exception as e:
-                if isinstance(e, FeishuAuthError):
-                    raise
-                raise FeishuAuthError(f"Unexpected error during authentication: {str(e)}")
-
-    @with_retry
-    async def list_folder_files(
-            self,
-            folder_token: str,
-            page_token: Optional[str] = None
-    ) -> Tuple[List[FileInfo], Optional[str]]:
-        """
-        Get list of files in a folder with pagination support.
-        
-        Args:
-            folder_token: Folder token
-            page_token: Page token for pagination
-            
-        Returns:
-            Tuple of (list of FileInfo, next page token)
-            
-        Raises:
-            FeishuAPIError: If API call fails
-            FeishuNotFoundError: If folder not found
-            FeishuPermissionError: If permission denied
-        """
-        try:
-            token = await self.get_tenant_access_token()
-
-            if not self._http_client:
-                raise FeishuAPIError("HTTP client not initialized")
-
-            # Build request parameters
-            params = {"page_size": 200, "folder_token": folder_token}
-            if page_token:
-                params["page_token"] = page_token
-
-            # Make API request
-            response = await self._http_client.get(
-                f"/drive/v1/files",
-                params=params,
-                headers={"Authorization": f"Bearer {token}"}
-            )
-
-            data = response.json()
-            # print(f"get files: {data}")
-
-            # Handle errors
-            if data.get("code") != 0:
-                error_code = data.get("code")
-                error_msg = data.get("msg", "Unknown error")
-
-                if error_code == 404 or error_code == 230005:
-                    raise FeishuNotFoundError(
-                        f"Folder not found: {error_msg}",
-                        error_code=str(error_code),
-                        details=data
-                    )
-                elif error_code == 403 or error_code == 230003:
-                    raise FeishuPermissionError(
-                        f"Permission denied: {error_msg}",
-                        error_code=str(error_code),
-                        details=data
-                    )
-                else:
-                    raise FeishuAPIError(
-                        f"API error: {error_msg}",
-                        error_code=str(error_code),
-                        details=data
-                    )
-
-            # Parse response
-            files_data = data.get("data", {}).get("files", [])
-            next_page_token = data.get("data", {}).get("next_page_token", None)
-
-            # Convert to FileInfo objects
-            files = []
-            for file_data in files_data:
-                try:
-                    file_info = FileInfo(
-                        token=file_data.get("token", ""),
-                        name=file_data.get("name", ""),
-                        type=file_data.get("type", ""),
-                        created_time=datetime.fromtimestamp(int(file_data.get("created_time", 0))),
-                        modified_time=datetime.fromtimestamp(int(file_data.get("modified_time", 0))),
-                        owner_id=file_data.get("owner_id", ""),
-                        url=file_data.get("url", "")
-                    )
-                    files.append(file_info)
-                except (ValueError, TypeError) as e:
-                    # Skip invalid file entries
-                    continue
-
-            return files, next_page_token
-
-        except httpx.HTTPError as e:
-            raise FeishuAPIError(f"HTTP error: {str(e)}")
-        except Exception as e:
-            if isinstance(e, (FeishuAPIError, FeishuNotFoundError, FeishuPermissionError)):
-                raise
-            raise FeishuAPIError(f"Unexpected error: {str(e)}")
-
-    async def list_all_folder_files(
-            self,
-            folder_token: str,
-            recursive: bool = True
-    ) -> List[FileInfo]:
-        """
-        Get all files in a folder, handling pagination automatically.
-
-        Args:
-            folder_token: Folder token
-            recursive: Whether to recursively get files from subfolders
-
-        Returns:
-            List of all FileInfo objects
-
-        Raises:
-            FeishuAPIError: If API call fails
-        """
-        all_files = []
-        page_token = None
-
-        # Get all files with pagination
-        while True:
-            files, page_token = await self.list_folder_files(folder_token, page_token)
-            all_files.extend(files)
-
-            if not page_token:
-                break
-
-        # Recursively get files from subfolders if requested
-        if recursive:
-            subfolders = [f for f in all_files if f.type == "folder"]
-            for subfolder in subfolders:
-                try:
-                    subfolder_files = await self.list_all_folder_files(
-                        subfolder.token,
-                        recursive=True
-                    )
-                    all_files.extend(subfolder_files)
-                except Exception:
-                    # Continue with other folders if one fails
-                    continue
-
-        return all_files
-
-    @with_retry
-    async def download_document(
-            self,
-            document: FileInfo,
-            save_dir: str
-    ) -> str:
-        """
-        download document content.
-        
-        Args:
-            document: Document FileInfo
-            save_dir: save dir
-            
-        Returns:
-            file_full_path
-            
-        Raises:
-            FeishuAPIError: If API call fails
-            FeishuNotFoundError: If document not found
-            FeishuPermissionError: If permission denied
-        """
-        try:
-            token = await self.get_tenant_access_token()
-
-            if not self._http_client:
-                raise FeishuAPIError("HTTP client not initialized")
-
-            # Different API endpoints for different document types
-            if document.type == "doc" or document.type == "docx" or document.type == "sheet" or document.type == "bitable":
-                return await self._export_file(document, token, save_dir)
-            elif document.type == "file" or document.type == "slides":
-                return await self._download_file(document, token, save_dir)
-            else:
-                raise FeishuAPIError(f"Unsupported document type: {document.type}")
-
-        except Exception as e:
-            if isinstance(e, (FeishuAPIError, FeishuNotFoundError, FeishuPermissionError)):
-                raise
-            raise FeishuAPIError(f"Unexpected error: {str(e)}")
-
-    async def _export_file(self, document: FileInfo, access_token: str, save_dir: str) -> str:
-        """export file for feishu online file type."""
-        try:
-            # 1.创建导出任务
-            file_extension = "pdf"
-            match document.type:
-                case "doc":
-                    file_extension = "doc"
-                case "docx":
-                    file_extension = "docx"
-                case "sheet":
-                    file_extension = "xlsx"
-                case "bitable":
-                    file_extension = "xlsx"
-                case _:
-                    file_extension = "pdf"
-            response = await self._http_client.post(
-                "/drive/v1/export_tasks",
-                json={
-                    "file_extension": file_extension,
-                    "token": document.token,
-                    "type": document.type
-                },
-                headers={"Authorization": f"Bearer {access_token}"}
-            )
-            data = response.json()
-            print(f"1.创建导出任务: {data}")
-
-            if data.get("code") != 0:
-                error_code = data.get("code")
-                error_msg = data.get("msg", "Unknown error")
-                raise FeishuAPIError(
-                    f"API error: {error_msg}",
-                    error_code=str(error_code),
-                    details=data
-                )
-
-            ticket = data.get("data", {}).get("ticket", None)
-            if not ticket:
-                raise FeishuAuthError("No ticket in response")
-
-            # 2.轮序查询导出任务结果
-            max_retries = 10  # 最大轮询次数
-            poll_interval = 2  # 每次轮询间隔时间（秒）
-            file_token = None
-            for attempt in range(max_retries):
-                # 查询导出任务
-                response = await self._http_client.get(
-                    f"/drive/v1/export_tasks/{ticket}",
-                    params={"token": document.token},
-                    headers={"Authorization": f"Bearer {access_token}"}
-                )
-                data = response.json()
-                print(f"2. 尝试查询导出任务结果 (第{attempt + 1}次): {data}")
-
-                if data.get("code") != 0:
-                    error_code = data.get("code")
-                    error_msg = data.get("msg", "Unknown error")
-                    raise FeishuAPIError(
-                        f"API error: {error_msg}",
-                        error_code=str(error_code),
-                        details=data,
-                    )
-
-                # 检查导出任务结果
-                file_token = data.get("data", {}).get("result", {}).get("file_token", None)
-                if file_token:
-                    # 如果导出任务成功生成 file_token，则退出轮询
-                    break
-
-                # 如果结果还没准备好，等待一段时间再进行下一次轮询
-                await asyncio.sleep(poll_interval)
-
-            if not file_token:
-                raise FeishuAPIError("Export task did not complete within the allowed time")
-
-            # 3.下载导出任务
-            response = await self._http_client.get(
-                f"/drive/v1/export_tasks/file/{file_token}/download",
-                headers={"Authorization": f"Bearer {access_token}"}
-            )
-            response.raise_for_status()
-            print(f'3.下载导出任务: {response.headers.get("Content-Disposition")}')
-
-            file_full_path = os.path.join(save_dir, document.name + "." + file_extension)
-            if os.path.exists(file_full_path):
-                os.remove(file_full_path)  # Delete a single file
-            with open(file_full_path, "wb") as file:
-                file.write(response.content)
-
-            return file_full_path
-
-        except httpx.HTTPError as e:
-            raise FeishuAPIError(f"HTTP error: {str(e)}")
-        except Exception as e:
-            raise FeishuAPIError(f"Unexpected error during file download: {str(e)}")
-
-    async def _download_file(self, document: FileInfo, access_token: str, save_dir: str) -> str:
-        """download file for file type."""
-        try:
-            response = await self._http_client.get(
-                f"/drive/v1/files/{document.token}/download",
-                headers={"Authorization": f"Bearer {access_token}"}
-            )
-            response.raise_for_status()
-
-            filename_header = response.headers.get("Content-Disposition")
-
-            # 最终的文件名（初始化为 None）
-            filename = None
-            if filename_header:
-                # 优先解析 filename* 格式
-                match = re.search(r"filename\*=([^']*)''([^;]+)", filename_header)
-                if match:
-                    # 使用 `filename*` 提取（已编码）
-                    encoding = match.group(1)  # 编码部分（如 UTF-8）
-                    encoded_filename = match.group(2)  # 文件名部分
-                    filename = urllib.parse.unquote(encoded_filename)  # 解码 URL 编码的文件名
-
-                # 如果 `filename*` 不存在，回退到解析 `filename`
-                if not filename:
-                    match = re.search(r'filename="([^"]+)"', filename_header)
-                    if match:
-                        filename = match.group(1)
-            # 如果文件名仍为 None，则使用默认文件名
-            if not filename:
-                filename = f"{document.name}.pdf"
-            # 确保文件名合法，替换非法字符
-            filename = re.sub(r'[\/:*?"<>|]', '_', filename)
-
-            file_full_path = os.path.join(save_dir, filename)
-            if os.path.exists(file_full_path):
-                os.remove(file_full_path) # Delete a single file
-            with open(file_full_path, "wb") as file:
-                file.write(response.content)
-
-            return file_full_path
-
-        except httpx.HTTPError as e:
-            raise FeishuAPIError(f"HTTP error: {str(e)}")
-        except Exception as e:
-            raise FeishuAPIError(f"Unexpected error during file download: {str(e)}")

api/app/core/rag/integrations/feishu/exceptions.py

@@ -1,46 +0,0 @@
-"""Exception classes for Feishu integration."""
-
-
-class FeishuError(Exception):
-    """Base exception for all Feishu-related errors."""
-    
-    def __init__(self, message: str, error_code: str = None, details: dict = None):
-        super().__init__(message)
-        self.message = message
-        self.error_code = error_code
-        self.details = details or {}
-
-
-class FeishuAuthError(FeishuError):
-    """Authentication error with Feishu API."""
-    pass
-
-
-class FeishuAPIError(FeishuError):
-    """General API error from Feishu."""
-    pass
-
-
-class FeishuNotFoundError(FeishuError):
-    """Resource not found error (404)."""
-    pass
-
-
-class FeishuPermissionError(FeishuError):
-    """Permission denied error (403)."""
-    pass
-
-
-class FeishuRateLimitError(FeishuError):
-    """Rate limit exceeded error (429)."""
-    pass
-
-
-class FeishuNetworkError(FeishuError):
-    """Network-related error (timeout, connection failure)."""
-    pass
-
-
-class FeishuDataError(FeishuError):
-    """Data parsing or validation error."""
-    pass

api/app/core/rag/integrations/feishu/models.py

@@ -1,17 +0,0 @@
-"""Data models for Feishu integration."""
-
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Dict, Any, List, Optional
-
-
-@dataclass
-class FileInfo:
-    """File information from Feishu."""
-    token: str
-    name: str
-    type: str  # doc/docx/sheet/bitable/file/slides/folder
-    created_time: datetime
-    modified_time: datetime
-    owner_id: str
-    url: str

api/app/core/rag/integrations/feishu/retry.py

@@ -1,137 +0,0 @@
-"""Retry strategy for Feishu API calls."""
-
-import asyncio
-import functools
-from typing import Callable, TypeVar
-import httpx
-
-from app.core.rag.integrations.feishu.exceptions import (
-    FeishuAuthError,
-    FeishuPermissionError,
-    FeishuNotFoundError,
-    FeishuRateLimitError,
-    FeishuNetworkError,
-    FeishuDataError,
-    FeishuAPIError,
-)
-
-T = TypeVar('T')
-
-
-class RetryStrategy:
-    """Retry strategy for API calls."""
-    
-    # Retryable error types
-    RETRYABLE_ERRORS = (
-        FeishuNetworkError,
-        FeishuRateLimitError,
-        httpx.TimeoutException,
-        httpx.ConnectError,
-        httpx.ReadError,
-    )
-    
-    # Non-retryable error types
-    NON_RETRYABLE_ERRORS = (
-        FeishuAuthError,
-        FeishuPermissionError,
-        FeishuNotFoundError,
-        FeishuDataError,
-    )
-    
-    # Retry configuration
-    MAX_RETRIES = 3
-    BACKOFF_DELAYS = [1, 2, 4]  # seconds
-    
-    @classmethod
-    def is_retryable(cls, error: Exception) -> bool:
-        """Check if an error is retryable."""
-        # Check for specific retryable errors
-        if isinstance(error, cls.RETRYABLE_ERRORS):
-            return True
-        
-        # Check for non-retryable errors
-        if isinstance(error, cls.NON_RETRYABLE_ERRORS):
-            return False
-        
-        # Check for HTTP status codes
-        if isinstance(error, httpx.HTTPStatusError):
-            status_code = error.response.status_code
-            # Retry on 429 (rate limit), 503 (service unavailable), 502 (bad gateway)
-            if status_code in [429, 502, 503]:
-                return True
-            # Don't retry on 4xx errors (except 429)
-            if 400 <= status_code < 500:
-                return False
-            # Retry on 5xx errors
-            if 500 <= status_code < 600:
-                return True
-        
-        # Check for FeishuAPIError with specific codes
-        if isinstance(error, FeishuAPIError):
-            if error.error_code:
-                # Rate limit error codes
-                if error.error_code in ["99991400", "99991401"]:
-                    return True
-        
-        return False
-    
-    @classmethod
-    async def execute_with_retry(
-        cls,
-        func: Callable[..., T],
-        *args,
-        **kwargs
-    ) -> T:
-        """
-        Execute a function with retry logic.
-        
-        Args:
-            func: Async function to execute
-            *args: Positional arguments for the function
-            **kwargs: Keyword arguments for the function
-            
-        Returns:
-            Function result
-            
-        Raises:
-            Exception: The last exception if all retries fail
-        """
-        last_exception = None
-        
-        for attempt in range(cls.MAX_RETRIES + 1):
-            try:
-                return await func(*args, **kwargs)
-            except Exception as e:
-                last_exception = e
-                
-                # Don't retry if not retryable
-                if not cls.is_retryable(e):
-                    raise
-                
-                # Don't retry if this was the last attempt
-                if attempt >= cls.MAX_RETRIES:
-                    raise
-                
-                # Wait before retrying
-                delay = cls.BACKOFF_DELAYS[attempt] if attempt < len(cls.BACKOFF_DELAYS) else cls.BACKOFF_DELAYS[-1]
-                await asyncio.sleep(delay)
-        
-        # Should not reach here, but raise last exception if we do
-        if last_exception:
-            raise last_exception
-
-
-def with_retry(func: Callable[..., T]) -> Callable[..., T]:
-    """
-    Decorator to add retry logic to async functions.
-    
-    Usage:
-        @with_retry
-        async def my_api_call():
-            ...
-    """
-    @functools.wraps(func)
-    async def wrapper(*args, **kwargs):
-        return await RetryStrategy.execute_with_retry(func, *args, **kwargs)
-    
-    return wrapper

api/app/core/rag/integrations/yuque/__init__.py

@@ -1 +0,0 @@
-"""Yuque integration module for document synchronization."""

api/app/core/rag/integrations/yuque/__main__.py

@@ -1,77 +0,0 @@
-"""Main entry point for Yuque integration testing."""
-
-import asyncio
-import sys
-from app.core.rag.integrations.yuque.client import YuqueAPIClient
-from app.core.rag.integrations.yuque.models import YuqueDocInfo
-
-
-def main(yuque_user_id: str,  # yuque User ID
-               yuque_token: str,    # yuque Token
-               save_dir: str,       # save file directory
-               ):
-    """Main entry point for the YuqueAPIClient."""
-    # Create feishuAPIClient
-    api_client = YuqueAPIClient(
-        user_id=yuque_user_id,
-        token=yuque_token
-    )
-
-    # Get all files from all repos
-    async def async_get_files(api_client: YuqueAPIClient):
-        async with api_client as client:
-            print("\n=== Fetching repositories ===")
-            repos = await client.get_user_repos()
-            print(f"Found {len(repos)} repositories:")
-            all_files = []
-            for repo in repos:
-                # Get documents from repository
-                print(f"\n=== Fetching documents from '{repo.name}' ===")
-                docs = await client.get_repo_docs(repo.id)
-                all_files.extend(docs)
-            return all_files
-    files = asyncio.run(async_get_files(api_client))
-
-    try:
-        for doc in files:
-            print(f"\n{'=' * 80}")
-            print(f"id: {doc.id}")
-            print(f"type: {doc.type}")
-            print(f"slug: {doc.slug}")
-            print(f"title: {doc.title}")
-            print(f"book_id: {doc.book_id}")
-            # print(f"format: {doc.format}")
-            # print(f"body: {doc.body}")
-            # print(f"body_draft: {doc.body_draft}")
-            # print(f"body_html: {doc.body_html}")
-            print(f"public: {doc.public}")
-            print(f"status: {doc.status}")
-            print(f"created_at: {doc.created_at}")
-            print(f"updated_at: {doc.updated_at}")
-            print(f"published_at: {doc.published_at}")
-            print(f"word_count: {doc.word_count}")
-            print(f"cover: {doc.cover}")
-            print(f"description: {doc.description}")
-            print(f"{'=' * 80}\n")
-            # download document from Feishu FileInfo
-            async def async_download_document(api_client: YuqueAPIClient, doc: YuqueDocInfo, save_dir: str):
-                async with api_client as client:
-                    file_path = await client.download_document(doc, save_dir)
-                    return file_path
-
-            file_path = asyncio.run(async_download_document(api_client, doc, save_dir))
-            print(file_path)
-
-    except KeyboardInterrupt:
-        print("\n\nfeishu integration interrupted by user.")
-
-    except Exception as e:
-        print(f"\n\nError during feishu integration: {e}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    yuque_user_id = ""
-    yuque_token = ""
-    save_dir = "/Volumes/MacintoshBD/Repository/RedBearAI/MemoryBear/api/files/"
-    main(yuque_user_id, yuque_token, save_dir)