Revert "model and statistic"

.gitignore

@@ -21,7 +21,6 @@ examples/
 
 # Temporary outputs
 .DS_Store
-.hypothesis/
 time.log
 celerybeat-schedule.db
 search_results.json
@@ -29,7 +28,6 @@ search_results.json
 api/migrations/versions
 tmp
 files
-powers/ 
 
 # Exclude dep files
 huggingface.co/
@@ -38,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

README.md

@@ -226,8 +226,8 @@ REDIS_PORT=6379
 REDIS_DB=1 
 
 # Celery (Using Redis as broker)
-REDIS_DB_CELERY_BROKER=1
-REDIS_DB_CELERY_BACKEND=2
+BROKER_URL=redis://127.0.0.1:6379/0
+RESULT_BACKEND=redis://127.0.0.1:6379/0
 
 # JWT Secret Key (Formation method: openssl rand -hex 32)
 SECRET_KEY=your-secret-key-here

README_CN.md

@@ -201,8 +201,8 @@ REDIS_PORT=6379
 REDIS_DB=1 
 
 # Celery (使用Redis作为broker)
-REDIS_DB_CELERY_BROKER=1
-REDIS_DB_CELERY_BACKEND=2
+BROKER_URL=redis://127.0.0.1:6379/0
+RESULT_BACKEND=redis://127.0.0.1:6379/0
 
 # JWT密钥 (生成方式: openssl rand -hex 32)
 SECRET_KEY=your-secret-key-here

api/Dockerfile

@@ -45,8 +45,7 @@ RUN --mount=type=cache,id=mem_apt,target=/var/cache/apt,sharing=locked \
     apt install -y libpython3-dev libgtk-4-1 libnss3 xdg-utils libgbm-dev && \
     apt install -y libjemalloc-dev && \
     apt install -y python3-pip pipx nginx unzip curl wget git vim less && \
-    apt install -y ghostscript && \
-    apt install -y libmagic1
+    apt install -y ghostscript
 
 RUN if [ "$NEED_MIRROR" == "1" ]; then \
         pip3 config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple && \

api/app/aioRedis.py

@@ -10,6 +10,7 @@ from app.core.config import settings
 # 设置日志记录器
 logger = logging.getLogger(__name__)
 
+
 # 创建连接池
 pool = ConnectionPool.from_url(
     f"redis://{settings.REDIS_HOST}:{settings.REDIS_PORT}",
@@ -20,7 +21,6 @@ pool = ConnectionPool.from_url(
 )
 aio_redis = redis.StrictRedis(connection_pool=pool)
 
-
 async def get_redis_connection():
     """获取Redis连接"""
     try:
@@ -29,8 +29,7 @@ async def get_redis_connection():
         logger.error(f"Redis连接失败: {str(e)}")
         return None
 
-
-async def aio_redis_set(key: str, val: str | dict, expire: int = None):
+async def aio_redis_set(key: str, val: str|dict, expire: int = None):
     """设置Redis键值
     
     Args:
@@ -41,7 +40,7 @@ async def aio_redis_set(key: str, val: str | dict, expire: int = None):
     try:
         if isinstance(val, dict):
             val = json.dumps(val, ensure_ascii=False)
-
+        
         if expire is not None:
             # 设置带过期时间的键值
             await aio_redis.set(key, val, ex=expire)
@@ -51,7 +50,6 @@ async def aio_redis_set(key: str, val: str | dict, expire: int = None):
     except Exception as e:
         logger.error(f"Redis set错误: {str(e)}")
 
-
 async def aio_redis_get(key: str):
     """获取Redis键值"""
     try:
@@ -60,7 +58,6 @@ async def aio_redis_get(key: str):
         logger.error(f"Redis get错误: {str(e)}")
         return None
 
-
 async def aio_redis_delete(key: str):
     """删除Redis键"""
     try:
@@ -69,7 +66,6 @@ async def aio_redis_delete(key: str):
         logger.error(f"Redis delete错误: {str(e)}")
         return None
 
-
 async def aio_redis_publish(channel: str, message: Dict[str, Any]) -> bool:
     """发布消息到Redis频道"""
     try:
@@ -82,10 +78,9 @@ async def aio_redis_publish(channel: str, message: Dict[str, Any]) -> bool:
         logger.error(f"Redis发布错误: {str(e)}")
         return False
 
-
 class RedisSubscriber:
     """Redis订阅器"""
-
+    
     def __init__(self, channel: str):
         self.channel = channel
         self.conn = None
@@ -93,25 +88,25 @@ class RedisSubscriber:
         self.is_closed = False
         self._queue = asyncio.Queue()
         self._task = None
-
+    
     async def start(self):
         """开始订阅"""
         if self.is_closed or self._task:
             return
-
+            
         self._task = asyncio.create_task(self._receive_messages())
         logger.info(f"开始订阅: {self.channel}")
-
+    
     async def _receive_messages(self):
         """接收消息"""
         try:
             self.conn = await get_redis_connection()
             if not self.conn:
                 return
-
+                
             self.pubsub = self.conn.pubsub()
             await self.pubsub.subscribe(self.channel)
-
+            
             while not self.is_closed:
                 try:
                     message = await self.pubsub.get_message(ignore_subscribe_messages=True, timeout=0.01)
@@ -132,7 +127,7 @@ class RedisSubscriber:
         finally:
             await self._queue.put(None)
             await self._cleanup()
-
+    
     async def _cleanup(self):
         """清理资源"""
         if self.pubsub:
@@ -146,7 +141,7 @@ class RedisSubscriber:
                 await self.conn.close()
             except Exception:
                 pass
-
+    
     async def get_message(self) -> Optional[Dict[str, Any]]:
         """获取消息"""
         if self.is_closed:
@@ -158,7 +153,7 @@ class RedisSubscriber:
         except Exception as e:
             logger.error(f"获取消息错误: {str(e)}")
             return None
-
+    
     async def close(self):
         """关闭订阅器"""
         if self.is_closed:
@@ -168,33 +163,32 @@ class RedisSubscriber:
             self._task.cancel()
         await self._cleanup()
 
-
 class RedisPubSubManager:
     """Redis发布订阅管理器"""
-
+    
     def __init__(self):
         self.subscribers = {}
-
+    
     async def publish(self, channel: str, message: Dict[str, Any]) -> bool:
         return await aio_redis_publish(channel, message)
-
+    
     def get_subscriber(self, channel: str) -> RedisSubscriber:
         if channel in self.subscribers:
             subscriber = self.subscribers[channel]
             if not subscriber.is_closed:
                 return subscriber
-
+        
         subscriber = RedisSubscriber(channel)
         self.subscribers[channel] = subscriber
         return subscriber
-
+    
     def cancel_subscription(self, channel: str) -> bool:
         if channel in self.subscribers:
             asyncio.create_task(self.subscribers[channel].close())
             del self.subscribers[channel]
             return True
         return False
-
+    
     def cancel_all_subscriptions(self) -> int:
         count = len(self.subscribers)
         for subscriber in self.subscribers.values():
@@ -202,6 +196,6 @@ class RedisPubSubManager:
         self.subscribers.clear()
         return count
 
-
 # 全局实例
 pubsub_manager = RedisPubSubManager()
+

api/app/cache/__init__.py

@@ -3,8 +3,9 @@ Cache 缓存模块
 
 提供各种缓存功能的统一入口
 """
-from .memory import InterestMemoryCache
+from .memory import EmotionMemoryCache, ImplicitMemoryCache
 
 __all__ = [
-    "InterestMemoryCache",
+    "EmotionMemoryCache",
+    "ImplicitMemoryCache",
 ]

api/app/cache/memory/__init__.py

@@ -3,10 +3,10 @@ Memory 缓存模块
 
 提供记忆系统相关的缓存功能
 """
-from .interest_memory import InterestMemoryCache
-from .activity_stats_cache import ActivityStatsCache
+from .emotion_memory import EmotionMemoryCache
+from .implicit_memory import ImplicitMemoryCache
 
 __all__ = [
-    "InterestMemoryCache",
-    "ActivityStatsCache",
+    "EmotionMemoryCache",
+    "ImplicitMemoryCache",
 ]

api/app/cache/memory/activity_stats_cache.py

@@ -1,124 +0,0 @@
-"""
-Recent Activity Stats Cache
-
-记忆提取活动统计缓存模块
-用于缓存每次记忆提取流程的统计数据，按 workspace_id 存储，24小时后释放
-查询命令：cache:memory:activity_stats:by_workspace:7de31a97-40a6-4fc0-b8d3-15c89f523843
-"""
-import json
-import logging
-from typing import Optional, Dict, Any
-from datetime import datetime
-
-from app.aioRedis import aio_redis
-
-logger = logging.getLogger(__name__)
-
-# 缓存过期时间：24小时
-ACTIVITY_STATS_CACHE_EXPIRE = 86400
-
-
-class ActivityStatsCache:
-    """记忆提取活动统计缓存类"""
-
-    PREFIX = "cache:memory:activity_stats"
-
-    @classmethod
-    def _get_key(cls, workspace_id: str) -> str:
-        """生成 Redis key
-
-        Args:
-            workspace_id: 工作空间ID
-
-        Returns:
-            完整的 Redis key
-        """
-        return f"{cls.PREFIX}:by_workspace:{workspace_id}"
-
-    @classmethod
-    async def set_activity_stats(
-        cls,
-        workspace_id: str,
-        stats: Dict[str, Any],
-        expire: int = ACTIVITY_STATS_CACHE_EXPIRE,
-    ) -> bool:
-        """设置记忆提取活动统计缓存
-
-        Args:
-            workspace_id: 工作空间ID
-            stats: 统计数据，格式：
-                {
-                    "chunk_count": int,
-                    "statements_count": int,
-                    "triplet_entities_count": int,
-                    "triplet_relations_count": int,
-                    "temporal_count": int,
-                }
-            expire: 过期时间（秒），默认24小时
-
-        Returns:
-            是否设置成功
-        """
-        try:
-            key = cls._get_key(workspace_id)
-            payload = {
-                "stats": stats,
-                "generated_at": datetime.now().isoformat(),
-                "workspace_id": workspace_id,
-                "cached": True,
-            }
-            value = json.dumps(payload, 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_activity_stats(
-        cls,
-        workspace_id: str,
-    ) -> Optional[Dict[str, Any]]:
-        """获取记忆提取活动统计缓存
-
-        Args:
-            workspace_id: 工作空间ID
-
-        Returns:
-            统计数据字典，缓存不存在或已过期返回 None
-        """
-        try:
-            key = cls._get_key(workspace_id)
-            value = await aio_redis.get(key)
-            if value:
-                payload = json.loads(value)
-                logger.info(f"命中活动统计缓存: {key}")
-                return payload
-            logger.info(f"活动统计缓存不存在或已过期: {key}")
-            return None
-        except Exception as e:
-            logger.error(f"获取活动统计缓存失败: {e}", exc_info=True)
-            return None
-
-    @classmethod
-    async def delete_activity_stats(
-        cls,
-        workspace_id: str,
-    ) -> bool:
-        """删除记忆提取活动统计缓存
-
-        Args:
-            workspace_id: 工作空间ID
-
-        Returns:
-            是否删除成功
-        """
-        try:
-            key = cls._get_key(workspace_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

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/cache/memory/interest_memory.py

@@ -1,122 +0,0 @@
-"""
-Interest Distribution Cache
-
-兴趣分布缓存模块
-用于缓存用户的兴趣分布标签数据，避免重复调用模型生成
-"""
-import json
-import logging
-from typing import Optional, List, Dict, Any
-from datetime import datetime
-
-from app.aioRedis import aio_redis
-
-logger = logging.getLogger(__name__)
-
-# 缓存过期时间：24小时
-INTEREST_CACHE_EXPIRE = 86400
-
-
-class InterestMemoryCache:
-    """兴趣分布缓存类"""
-
-    PREFIX = "cache:memory:interest_distribution"
-
-    @classmethod
-    def _get_key(cls, end_user_id: str, language: str) -> str:
-        """生成 Redis key
-
-        Args:
-            end_user_id: 用户ID
-            language: 语言类型
-
-        Returns:
-            完整的 Redis key
-        """
-        return f"{cls.PREFIX}:by_user:{end_user_id}:{language}"
-
-    @classmethod
-    async def set_interest_distribution(
-        cls,
-        end_user_id: str,
-        language: str,
-        data: List[Dict[str, Any]],
-        expire: int = INTEREST_CACHE_EXPIRE,
-    ) -> bool:
-        """设置用户兴趣分布缓存
-
-        Args:
-            end_user_id: 用户ID
-            language: 语言类型
-            data: 兴趣分布列表，格式 [{"name": "...", "frequency": ...}, ...]
-            expire: 过期时间（秒），默认24小时
-
-        Returns:
-            是否设置成功
-        """
-        try:
-            key = cls._get_key(end_user_id, language)
-            payload = {
-                "data": data,
-                "generated_at": datetime.now().isoformat(),
-                "cached": True,
-            }
-            value = json.dumps(payload, 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_interest_distribution(
-        cls,
-        end_user_id: str,
-        language: str,
-    ) -> Optional[List[Dict[str, Any]]]:
-        """获取用户兴趣分布缓存
-
-        Args:
-            end_user_id: 用户ID
-            language: 语言类型
-
-        Returns:
-            兴趣分布列表，缓存不存在或已过期返回 None
-        """
-        try:
-            key = cls._get_key(end_user_id, language)
-            value = await aio_redis.get(key)
-            if value:
-                payload = json.loads(value)
-                logger.info(f"命中兴趣分布缓存: {key}")
-                return payload.get("data")
-            logger.info(f"兴趣分布缓存不存在或已过期: {key}")
-            return None
-        except Exception as e:
-            logger.error(f"获取兴趣分布缓存失败: {e}", exc_info=True)
-            return None
-
-    @classmethod
-    async def delete_interest_distribution(
-        cls,
-        end_user_id: str,
-        language: str,
-    ) -> bool:
-        """删除用户兴趣分布缓存
-
-        Args:
-            end_user_id: 用户ID
-            language: 语言类型
-
-        Returns:
-            是否删除成功
-        """
-        try:
-            key = cls._get_key(end_user_id, language)
-            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

api/app/celery_app.py

@@ -3,52 +3,18 @@ import platform
 from datetime import timedelta
 from urllib.parse import quote
 
-from celery import Celery
-from celery.schedules import crontab
-
 from app.core.config import settings
-from app.core.logging_config import get_logger
-
-logger = get_logger(__name__)
-
-# macOS fork() safety - must be set before any Celery initialization
-if platform.system() == 'Darwin':
-    os.environ.setdefault('OBJC_DISABLE_INITIALIZE_FORK_SAFETY', 'YES')
+from celery import Celery
 
 # 创建 Celery 应用实例
-# broker: 任务队列（使用 Redis DB，由 CELERY_BROKER_DB 指定）
-# backend: 结果存储（使用 Redis DB，由 CELERY_BACKEND_DB 指定）
-# NOTE: 不要在 .env 中设置 BROKER_URL / RESULT_BACKEND / CELERY_BROKER / CELERY_BACKEND，
-#       这些名称会被 Celery CLI 的 Click 框架劫持，详见 docs/celery-env-bug-report.md
-
-# Build canonical broker/backend URLs and force them into os.environ so that
-# Celery's Settings.broker_url property (which checks CELERY_BROKER_URL first)
-# cannot be overridden by stray env vars.
-# See: https://github.com/celery/celery/issues/4284
-_broker_url = f"redis://:{quote(settings.REDIS_PASSWORD)}@{settings.REDIS_HOST}:{settings.REDIS_PORT}/{settings.REDIS_DB_CELERY_BROKER}"
-_backend_url = f"redis://:{quote(settings.REDIS_PASSWORD)}@{settings.REDIS_HOST}:{settings.REDIS_PORT}/{settings.REDIS_DB_CELERY_BACKEND}"
-os.environ["CELERY_BROKER_URL"] = _broker_url
-os.environ["CELERY_RESULT_BACKEND"] = _backend_url
-# Neutralize legacy Celery env vars that can be hijacked by Celery's CLI/Click
-# integration and accidentally override our canonical URLs.
-os.environ.pop("BROKER_URL", None)
-os.environ.pop("RESULT_BACKEND", None)
-os.environ.pop("CELERY_BROKER", None)
-os.environ.pop("CELERY_BACKEND", None)
-
+# broker: 任务队列（使用 Redis DB 0）
+# backend: 结果存储（使用 Redis DB 10）
 celery_app = Celery(
     "redbear_tasks",
-    broker=_broker_url,
-    backend=_backend_url,
+    broker=f"redis://:{quote(settings.REDIS_PASSWORD)}@{settings.REDIS_HOST}:{settings.REDIS_PORT}/{settings.CELERY_BROKER}",
+    backend=f"redis://:{quote(settings.REDIS_PASSWORD)}@{settings.REDIS_HOST}:{settings.REDIS_PORT}/{settings.CELERY_BACKEND}",
 )
 
-logger.info(
-    "Celery app initialized",
-    extra={
-        "broker": _broker_url.replace(quote(settings.REDIS_PASSWORD), "***"),
-        "backend": _backend_url.replace(quote(settings.REDIS_PASSWORD), "***"),
-    },
-)
 # Default queue for unrouted tasks
 celery_app.conf.task_default_queue = 'memory_tasks'
 
@@ -63,17 +29,17 @@ celery_app.conf.update(
     accept_content=['json'],
     result_serializer='json',
     
-    # # 时区
-    # timezone='Asia/Shanghai',
-    # enable_utc=False,
+    # 时区
+    timezone='Asia/Shanghai',
+    enable_utc=True,
     
     # 任务追踪
     task_track_started=True,
     task_ignore_result=False,
     
     # 超时设置
-    task_time_limit=3600,  # 60分钟硬超时
-    task_soft_time_limit=3000,  # 50分钟软超时
+    task_time_limit=1800,  # 30分钟硬超时
+    task_soft_time_limit=1500,  # 25分钟软超时
     
     # Worker 设置 (per-worker settings are in docker-compose command line)
     worker_prefetch_multiplier=1,  # Don't hoard tasks, fairer distribution
@@ -97,24 +63,15 @@ celery_app.conf.update(
         'app.core.memory.agent.read_message': {'queue': 'memory_tasks'},
         'app.core.memory.agent.write_message': {'queue': 'memory_tasks'},
         
-        # Long-term storage tasks → memory_tasks queue (batched write strategies)
-        'app.core.memory.agent.long_term_storage.window': {'queue': 'memory_tasks'},
-        'app.core.memory.agent.long_term_storage.time': {'queue': 'memory_tasks'},
-        'app.core.memory.agent.long_term_storage.aggregate': {'queue': 'memory_tasks'},
-        
         # 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.tasks.init_implicit_emotions_for_users': {'queue': 'periodic_tasks'},
-        'app.tasks.init_interest_distribution_for_users': {'queue': 'periodic_tasks'},
+        # Beat/periodic tasks → document_tasks queue (prefork worker)
+        'app.tasks.workspace_reflection_task': {'queue': 'document_tasks'},
+        'app.tasks.regenerate_memory_cache': {'queue': 'document_tasks'},
+        'app.tasks.run_forgetting_cycle_task': {'queue': 'document_tasks'},
+        'app.controllers.memory_storage_controller.search_all': {'queue': 'document_tasks'},
     },
 )
 
@@ -122,16 +79,12 @@ celery_app.conf.update(
 celery_app.autodiscover_tasks(['app'])
 
 # Celery Beat schedule for periodic tasks
-memory_increment_schedule = crontab(hour=settings.MEMORY_INCREMENT_HOUR, minute=settings.MEMORY_INCREMENT_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=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,
-)
+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",
@@ -150,16 +103,16 @@ beat_schedule_config = {
             "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": (),
-    },
 }
 
+# 如果配置了默认工作空间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/config/__init__.py

@@ -1 +0,0 @@
-"""Configuration module for application settings."""

api/app/config/default_ontology_config.py

@@ -1,239 +0,0 @@
-"""默认本体场景配置
-
-本模块定义系统预设的本体场景和实体类型配置。
-这些配置用于在工作空间创建时自动初始化默认场景。
-支持中英文双语配置，根据用户语言偏好创建对应语言的场景。
-"""
-
-# 在线教育场景配置
-ONLINE_EDUCATION_SCENE = {
-    "name_chinese": "在线教育",
-    "name_english": "Online Education",
-    "description_chinese": "适用于在线教育平台的本体建模，包含学生、教师、课程等核心实体类型",
-    "description_english": "Ontology modeling for online education platforms, including core entity types such as students, teachers, and courses",
-    "types": [
-        {
-            "name_chinese": "学生",
-            "name_english": "Student",
-            "description_chinese": "在教育系统中接受教育的个体，包含姓名、学号、年级、班级等属性",
-            "description_english": "Individuals receiving education in the education system, including attributes such as name, student ID, grade, and class"
-        },
-        {
-            "name_chinese": "教师",
-            "name_english": "Teacher",
-            "description_chinese": "在教育系统中提供教学服务的个体，包含姓名、工号、任教学科、职称等属性",
-            "description_english": "Individuals providing teaching services in the education system, including attributes such as name, employee ID, teaching subject, and title"
-        },
-        {
-            "name_chinese": "课程",
-            "name_english": "Course",
-            "description_chinese": "教育系统中的教学内容单元，包含课程名称、课程代码、学分、学时等属性",
-            "description_english": "Teaching content units in the education system, including attributes such as course name, course code, credits, and class hours"
-        },
-        {
-            "name_chinese": "作业",
-            "name_english": "Assignment",
-            "description_chinese": "课程中布置的学习任务，包含作业标题、截止日期、所属课程、提交状态等属性",
-            "description_english": "Learning tasks assigned in courses, including attributes such as assignment title, deadline, course, and submission status"
-        },
-        {
-            "name_chinese": "成绩",
-            "name_english": "Grade",
-            "description_chinese": "学生学习成果的评价结果，包含分数、评级、考试类型、所属课程等属性",
-            "description_english": "Evaluation results of student learning outcomes, including attributes such as score, rating, exam type, and course"
-        },
-        {
-            "name_chinese": "考试",
-            "name_english": "Exam",
-            "description_chinese": "评估学生学习成果的测试活动，包含考试名称、时间、地点、科目等属性",
-            "description_english": "Test activities to assess student learning outcomes, including attributes such as exam name, time, location, and subject"
-        },
-        {
-            "name_chinese": "教室",
-            "name_english": "Classroom",
-            "description_chinese": "进行教学活动的物理或虚拟空间，包含教室编号、容量、设备等属性",
-            "description_english": "Physical or virtual spaces for teaching activities, including attributes such as classroom number, capacity, and equipment"
-        },
-        {
-            "name_chinese": "学科",
-            "name_english": "Subject",
-            "description_chinese": "知识的分类领域，包含学科名称、代码、所属院系等属性",
-            "description_english": "Classification domains of knowledge, including attributes such as subject name, code, and department"
-        },
-        {
-            "name_chinese": "教材",
-            "name_english": "Textbook",
-            "description_chinese": "教学使用的书籍或资料，包含书名、作者、出版社、ISBN等属性",
-            "description_english": "Books or materials used for teaching, including attributes such as title, author, publisher, and ISBN"
-        },
-        {
-            "name_chinese": "班级",
-            "name_english": "Class",
-            "description_chinese": "学生的组织单位，包含班级名称、年级、人数、班主任等属性",
-            "description_english": "Organizational units of students, including attributes such as class name, grade, number of students, and class teacher"
-        },
-        {
-            "name_chinese": "学期",
-            "name_english": "Semester",
-            "description_chinese": "教学时间的划分单位，包含学期名称、开始时间、结束时间等属性",
-            "description_english": "Time division units for teaching, including attributes such as semester name, start time, and end time"
-        },
-        {
-            "name_chinese": "课时",
-            "name_english": "Class Hour",
-            "description_chinese": "课程的时间单位，包含上课时间、地点、教师、课程等属性",
-            "description_english": "Time units of courses, including attributes such as class time, location, teacher, and course"
-        },
-        {
-            "name_chinese": "教学计划",
-            "name_english": "Teaching Plan",
-            "description_chinese": "课程的教学安排，包含教学目标、内容安排、进度计划等属性",
-            "description_english": "Teaching arrangements for courses, including attributes such as teaching objectives, content arrangement, and progress plan"
-        }
-    ]
-}
-
-# 情感陪伴场景配置
-EMOTIONAL_COMPANION_SCENE = {
-    "name_chinese": "情感陪伴",
-    "name_english": "Emotional Companion",
-    "description_chinese": "适用于情感陪伴应用的本体建模，包含用户、情绪、活动等核心实体类型",
-    "description_english": "Ontology modeling for emotional companion applications, including core entity types such as users, emotions, and activities",
-    "types": [
-        {
-            "name_chinese": "用户",
-            "name_english": "User",
-            "description_chinese": "使用情感陪伴服务的个体，包含姓名、昵称、性格特征、偏好等属性",
-            "description_english": "Individuals using emotional companion services, including attributes such as name, nickname, personality traits, and preferences"
-        },
-        {
-            "name_chinese": "情绪",
-            "name_english": "Emotion",
-            "description_chinese": "用户的情感状态，包含情绪类型、强度、触发原因、持续时间等属性",
-            "description_english": "Emotional states of users, including attributes such as emotion type, intensity, trigger cause, and duration"
-        },
-        {
-            "name_chinese": "活动",
-            "name_english": "Activity",
-            "description_chinese": "用户参与的各类活动，包含活动名称、类型、参与者、时间地点等属性",
-            "description_english": "Various activities users participate in, including attributes such as activity name, type, participants, time, and location"
-        },
-        {
-            "name_chinese": "对话",
-            "name_english": "Conversation",
-            "description_chinese": "用户之间的交流记录，包含对话主题、参与者、时间、关键内容等属性",
-            "description_english": "Communication records between users, including attributes such as conversation topic, participants, time, and key content"
-        },
-        {
-            "name_chinese": "兴趣爱好",
-            "name_english": "Hobby",
-            "description_chinese": "用户的兴趣和爱好，包含爱好名称、类别、熟练程度、相关活动等属性",
-            "description_english": "User interests and hobbies, including attributes such as hobby name, category, proficiency level, and related activities"
-        },
-        {
-            "name_chinese": "日常事件",
-            "name_english": "Daily Event",
-            "description_chinese": "用户日常生活中的事件，包含事件描述、时间、地点、相关人物等属性",
-            "description_english": "Events in users' daily lives, including attributes such as event description, time, location, and related people"
-        },
-        {
-            "name_chinese": "关系",
-            "name_english": "Relationship",
-            "description_chinese": "用户之间的社会关系，包含关系类型、亲密度、建立时间等属性",
-            "description_english": "Social relationships between users, including attributes such as relationship type, intimacy, and establishment time"
-        },
-        {
-            "name_chinese": "回忆",
-            "name_english": "Memory",
-            "description_chinese": "用户的重要记忆片段，包含回忆内容、时间、地点、相关人物等属性",
-            "description_english": "Important memory fragments of users, including attributes such as memory content, time, location, and related people"
-        },
-        {
-            "name_chinese": "地点",
-            "name_english": "Location",
-            "description_chinese": "用户活动的地理位置，包含地点名称、地址、类型、相关事件等属性",
-            "description_english": "Geographic locations of user activities, including attributes such as location name, address, type, and related events"
-        },
-        {
-            "name_chinese": "时间节点",
-            "name_english": "Time Point",
-            "description_chinese": "重要的时间标记，包含日期、事件、意义等属性",
-            "description_english": "Important time markers, including attributes such as date, event, and significance"
-        },
-        {
-            "name_chinese": "目标",
-            "name_english": "Goal",
-            "description_chinese": "用户设定的目标，包含目标描述、截止时间、完成状态、相关活动等属性",
-            "description_english": "Goals set by users, including attributes such as goal description, deadline, completion status, and related activities"
-        },
-        {
-            "name_chinese": "成就",
-            "name_english": "Achievement",
-            "description_chinese": "用户获得的成就，包含成就名称、获得时间、描述、相关目标等属性",
-            "description_english": "Achievements obtained by users, including attributes such as achievement name, acquisition time, description, and related goals"
-        }
-    ]
-}
-
-# 导出默认场景列表
-DEFAULT_SCENES = [ONLINE_EDUCATION_SCENE, EMOTIONAL_COMPANION_SCENE]
-
-
-def get_scene_name(scene_config: dict, language: str = "zh") -> str:
-    """获取场景名称（根据语言）
-    
-    Args:
-        scene_config: 场景配置字典
-        language: 语言类型 ("zh" 或 "en")
-        
-    Returns:
-        对应语言的场景名称
-    """
-    if language == "en":
-        return scene_config.get("name_english", scene_config.get("name_chinese"))
-    return scene_config.get("name_chinese")
-
-
-def get_scene_description(scene_config: dict, language: str = "zh") -> str:
-    """获取场景描述（根据语言）
-    
-    Args:
-        scene_config: 场景配置字典
-        language: 语言类型 ("zh" 或 "en")
-        
-    Returns:
-        对应语言的场景描述
-    """
-    if language == "en":
-        return scene_config.get("description_english", scene_config.get("description_chinese"))
-    return scene_config.get("description_chinese")
-
-
-def get_type_name(type_config: dict, language: str = "zh") -> str:
-    """获取类型名称（根据语言）
-    
-    Args:
-        type_config: 类型配置字典
-        language: 语言类型 ("zh" 或 "en")
-        
-    Returns:
-        对应语言的类型名称
-    """
-    if language == "en":
-        return type_config.get("name_english", type_config.get("name_chinese"))
-    return type_config.get("name_chinese")
-
-
-def get_type_description(type_config: dict, language: str = "zh") -> str:
-    """获取类型描述（根据语言）
-    
-    Args:
-        type_config: 类型配置字典
-        language: 语言类型 ("zh" 或 "en")
-        
-    Returns:
-        对应语言的类型描述
-    """
-    if language == "en":
-        return type_config.get("description_english", type_config.get("description_chinese"))
-    return type_config.get("description_chinese")

api/app/config/default_ontology_initializer.py

@@ -1,249 +0,0 @@
-# -*- coding: utf-8 -*-
-"""默认本体场景初始化器
-
-本模块提供默认本体场景和类型的自动初始化功能。
-在工作空间创建时，自动添加预设的本体场景和实体类型。
-
-Classes:
-    DefaultOntologyInitializer: 默认本体场景初始化器
-"""
-
-import logging
-from typing import List, Optional, Tuple
-from uuid import UUID
-
-from sqlalchemy.orm import Session
-
-from app.config.default_ontology_config import (
-    DEFAULT_SCENES,
-    get_scene_name,
-    get_scene_description,
-    get_type_name,
-    get_type_description,
-)
-from app.core.logging_config import get_business_logger
-from app.repositories.ontology_scene_repository import OntologySceneRepository
-from app.repositories.ontology_class_repository import OntologyClassRepository
-
-
-class DefaultOntologyInitializer:
-    """默认本体场景初始化器
-    
-    负责在工作空间创建时自动初始化默认的本体场景和类型。
-    遵循最小侵入原则，确保初始化失败不阻止工作空间创建。
-    
-    Attributes:
-        db: 数据库会话
-        scene_repo: 场景Repository
-        class_repo: 类型Repository
-        logger: 业务日志记录器
-    """
-    
-    def __init__(self, db: Session):
-        """初始化
-        
-        Args:
-            db: 数据库会话
-        """
-        self.db = db
-        self.scene_repo = OntologySceneRepository(db)
-        self.class_repo = OntologyClassRepository(db)
-        self.logger = get_business_logger()
-    
-    def initialize_default_scenes(
-        self,
-        workspace_id: UUID,
-        language: str = "zh"
-    ) -> Tuple[bool, str]:
-        """为工作空间初始化默认场景
-        
-        创建两个默认场景（在线教育、情感陪伴）及其对应的实体类型。
-        如果创建失败，记录错误日志但不抛出异常。
-        
-        Args:
-            workspace_id: 工作空间ID
-            language: 语言类型 ("zh" 或 "en")，默认为 "zh"
-            
-        Returns:
-            Tuple[bool, str]: (是否成功, 错误信息)
-        """
-        try:
-            self.logger.info(
-                f"开始初始化默认本体场景 - workspace_id={workspace_id}, language={language}"
-            )
-            
-            scenes_created = 0
-            total_types_created = 0
-            
-            # 遍历默认场景配置
-            for scene_config in DEFAULT_SCENES:
-                scene_name = get_scene_name(scene_config, language)
-                
-                # 创建场景及其类型
-                scene_id = self._create_scene_with_types(workspace_id, scene_config, language)
-                
-                if scene_id:
-                    scenes_created += 1
-                    # 统计类型数量
-                    types_count = len(scene_config.get("types", []))
-                    total_types_created += types_count
-                    
-                    self.logger.info(
-                        f"场景创建成功 - scene_name={scene_name}, "
-                        f"scene_id={scene_id}, types_count={types_count}, language={language}"
-                    )
-                else:
-                    self.logger.warning(
-                        f"场景创建失败 - scene_name={scene_name}, "
-                        f"workspace_id={workspace_id}, language={language}"
-                    )
-            
-            # 记录总体结果
-            self.logger.info(
-                f"默认场景初始化完成 - workspace_id={workspace_id}, "
-                f"language={language}, scenes_created={scenes_created}, "
-                f"total_types_created={total_types_created}"
-            )
-            
-            # 如果至少创建了一个场景，视为成功
-            if scenes_created > 0:
-                return True, ""
-            else:
-                error_msg = "所有默认场景创建失败"
-                self.logger.error(
-                    f"默认场景初始化失败 - workspace_id={workspace_id}, "
-                    f"language={language}, error={error_msg}"
-                )
-                return False, error_msg
-                
-        except Exception as e:
-            error_msg = f"默认场景初始化异常: {str(e)}"
-            self.logger.error(
-                f"默认场景初始化异常 - workspace_id={workspace_id}, "
-                f"language={language}, error={str(e)}",
-                exc_info=True
-            )
-            return False, error_msg
-    
-    def _create_scene_with_types(
-        self,
-        workspace_id: UUID,
-        scene_config: dict,
-        language: str = "zh"
-    ) -> Optional[UUID]:
-        """创建场景及其类型
-        
-        Args:
-            workspace_id: 工作空间ID
-            scene_config: 场景配置字典
-            language: 语言类型 ("zh" 或 "en")
-            
-        Returns:
-            Optional[UUID]: 创建的场景ID，失败返回None
-        """
-        try:
-            scene_name = get_scene_name(scene_config, language)
-            scene_description = get_scene_description(scene_config, language)
-            
-            # 检查是否已存在同名场景（支持向后兼容）
-            existing_scene = self.scene_repo.get_by_name(scene_name, workspace_id)
-            if existing_scene:
-                self.logger.info(
-                    f"场景已存在，跳过创建 - scene_name={scene_name}, "
-                    f"workspace_id={workspace_id}, scene_id={existing_scene.scene_id}, "
-                    f"language={language}"
-                )
-                return None
-            
-            # 创建场景记录，设置 is_system_default=true
-            scene_data = {
-                "scene_name": scene_name,
-                "scene_description": scene_description
-            }
-            
-            scene = self.scene_repo.create(scene_data, workspace_id)
-            
-            # 设置系统默认标识
-            scene.is_system_default = True
-            self.db.flush()
-            
-            self.logger.info(
-                f"场景创建成功 - scene_name={scene_name}, "
-                f"scene_id={scene.scene_id}, is_system_default=True, language={language}"
-            )
-            
-            # 批量创建类型
-            types_config = scene_config.get("types", [])
-            types_created = self._batch_create_types(scene.scene_id, types_config, language)
-            
-            self.logger.info(
-                f"场景类型创建完成 - scene_id={scene.scene_id}, "
-                f"types_created={types_created}/{len(types_config)}, language={language}"
-            )
-            
-            return scene.scene_id
-            
-        except Exception as e:
-            scene_name = get_scene_name(scene_config, language)
-            self.logger.error(
-                f"场景创建失败 - scene_name={scene_name}, "
-                f"workspace_id={workspace_id}, language={language}, error={str(e)}",
-                exc_info=True
-            )
-            return None
-    
-    def _batch_create_types(
-        self,
-        scene_id: UUID,
-        types_config: List[dict],
-        language: str = "zh"
-    ) -> int:
-        """批量创建实体类型
-        
-        Args:
-            scene_id: 场景ID
-            types_config: 类型配置列表
-            language: 语言类型 ("zh" 或 "en")
-            
-        Returns:
-            int: 成功创建的类型数量
-        """
-        created_count = 0
-        
-        for type_config in types_config:
-            try:
-                type_name = get_type_name(type_config, language)
-                type_description = get_type_description(type_config, language)
-                
-                # 创建类型数据
-                class_data = {
-                    "class_name": type_name,
-                    "class_description": type_description
-                }
-                
-                # 创建类型
-                ontology_class = self.class_repo.create(class_data, scene_id)
-                
-                # 设置系统默认标识
-                ontology_class.is_system_default = True
-                self.db.flush()
-                
-                created_count += 1
-                
-                self.logger.debug(
-                    f"类型创建成功 - class_name={type_name}, "
-                    f"class_id={ontology_class.class_id}, "
-                    f"scene_id={scene_id}, is_system_default=True, language={language}"
-                )
-                
-            except Exception as e:
-                type_name = get_type_name(type_config, language)
-                self.logger.warning(
-                    f"单个类型创建失败，继续创建其他类型 - "
-                    f"class_name={type_name}, scene_id={scene_id}, "
-                    f"language={language}, error={str(e)}"
-                )
-                # 继续创建其他类型
-                continue
-        
-        return created_count

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,12 @@ from . import (
     upload_controller,
     user_controller,
     user_memory_controllers,
+    workflow_controller,
     workspace_controller,
-    ontology_controller,
-    skill_controller
+    memory_forget_controller,
+    home_page_controller,
+    memory_perceptual_controller,
+    memory_working_controller,
 )
 
 # 创建管理端 API 路由器
@@ -62,8 +61,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 +77,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)
@@ -92,7 +90,5 @@ manager_router.include_router(implicit_memory_controller.router)
 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

@@ -1,12 +1,9 @@
 import uuid
-import io
 from typing import Optional, Annotated
 
-import yaml
-from fastapi import APIRouter, Depends, Path, Form, UploadFile, File
+from fastapi import APIRouter, Depends, Path
 from fastapi.responses import StreamingResponse
 from sqlalchemy.orm import Session
-from urllib.parse import quote
 
 from app.core.error_codes import BizCode
 from app.core.logging_config import get_business_logger
@@ -20,14 +17,11 @@ from app.repositories.end_user_repository import EndUserRepository
 from app.schemas import app_schema
 from app.schemas.response_schema import PageData, PageMeta
 from app.schemas.workflow_schema import WorkflowConfig as WorkflowConfigSchema
-from app.schemas.workflow_schema import WorkflowConfigUpdate, WorkflowImportSave
+from app.schemas.workflow_schema import WorkflowConfigUpdate
 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.app_statistics_service import AppStatisticsService
-from app.services.workflow_import_service import WorkflowImportService
 from app.services.workflow_service import WorkflowService, get_workflow_service
-from app.services.app_dsl_service import AppDslService
 
 router = APIRouter(prefix="/apps", tags=["Apps"])
 logger = get_business_logger()
@@ -70,7 +64,7 @@ def list_apps(
 
     # 当 ids 存在且不为 None 时，根据 ids 获取应用
     if ids is not None:
-        app_ids = [app_id.strip() for app_id in ids.split(',') if app_id.strip()]
+        app_ids = [id.strip() for id in ids.split(',') if id.strip()]
         items_orm = app_service.get_apps_by_ids(db, app_ids, workspace_id)
         items = [service._convert_to_schema(app, workspace_id) for app in items_orm]
         return success(data=items)
@@ -399,10 +393,10 @@ async def draft_run(
     from app.models import AgentConfig, ModelConfig
     from sqlalchemy import select
     from app.core.exceptions import BusinessException
-    from app.services.draft_run_service import AgentRunService
+    from app.services.draft_run_service import DraftRunService
 
     service = AppService(db)
-    draft_service = AgentRunService(db)
+    draft_service = DraftRunService(db)
 
     # 1. 验证应用
     app = service._get_app_or_404(app_id)
@@ -460,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
 
@@ -482,13 +475,12 @@ 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)
             }
         )
 
-        from app.services.draft_run_service import AgentRunService
-        draft_service = AgentRunService(db)
+        from app.services.draft_run_service import DraftRunService
+        draft_service = DraftRunService(db)
         result = await draft_service.run(
             agent_config=agent_cfg,
             model_config=model_config,
@@ -498,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(
@@ -792,8 +783,8 @@ async def draft_run_compare(
     # 流式返回
     if payload.stream:
         async def event_generator():
-            from app.services.draft_run_service import AgentRunService
-            draft_service = AgentRunService(db)
+            from app.services.draft_run_service import DraftRunService
+            draft_service = DraftRunService(db)
             async for event in draft_service.run_compare_stream(
                     agent_config=agent_cfg,
                     models=model_configs,
@@ -807,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
 
@@ -823,8 +813,8 @@ async def draft_run_compare(
         )
 
     # 非流式返回
-    from app.services.draft_run_service import AgentRunService
-    draft_service = AgentRunService(db)
+    from app.services.draft_run_service import DraftRunService
+    draft_service = DraftRunService(db)
     result = await draft_service.run_compare(
         agent_config=agent_cfg,
         models=model_configs,
@@ -838,8 +828,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
     )
 
     logger.info(
@@ -883,187 +872,3 @@ async def update_workflow_config(
     workspace_id = current_user.current_workspace_id
     cfg = app_service.update_workflow_config(db, app_id=app_id, data=payload, workspace_id=workspace_id)
     return success(data=WorkflowConfigSchema.model_validate(cfg))
-
-
-@router.get("/{app_id}/workflow/export")
-@cur_workspace_access_guard()
-async def export_workflow_config(
-        app_id: uuid.UUID,
-        db: Annotated[Session, Depends(get_db)],
-        current_user: Annotated[User, Depends(get_current_user)]
-):
-    """导出工作流配置为YAML文件"""
-    workflow_service = WorkflowService(db)
-
-    return success(data={
-        "content": workflow_service.export_workflow_dsl(app_id=app_id),
-    })
-
-
-@router.post("/workflow/import")
-@cur_workspace_access_guard()
-async def import_workflow_config(
-        file: UploadFile = File(...),
-        platform: str = Form(...),
-        app_id: str = Form(None),
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-
-):
-    """从YAML内容导入工作流配置"""
-    if not file.filename.lower().endswith((".yaml", ".yml")):
-        return fail(msg="Only yaml file is allowed", code=BizCode.BAD_REQUEST)
-
-    raw_text = (await file.read()).decode("utf-8")
-    import_service = WorkflowImportService(db)
-    config = yaml.safe_load(raw_text)
-    result = await import_service.upload_config(platform, config)
-    return success(data=result)
-
-
-@router.post("/workflow/import/save")
-@cur_workspace_access_guard()
-async def save_workflow_import(
-        data: WorkflowImportSave,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    import_service = WorkflowImportService(db)
-    app = await import_service.save_workflow(
-        user_id=current_user.id,
-        workspace_id=current_user.current_workspace_id,
-        temp_id=data.temp_id,
-        name=data.name,
-        description=data.description,
-    )
-    return success(data=app_schema.App.model_validate(app))
-
-
-@router.get("/{app_id}/statistics", summary="应用统计数据")
-@cur_workspace_access_guard()
-def get_app_statistics(
-        app_id: uuid.UUID,
-        start_date: int,
-        end_date: int,
-        db: Session = Depends(get_db),
-        current_user=Depends(get_current_user),
-):
-    """获取应用统计数据
-
-    Args:
-        app_id: 应用ID
-        start_date: 开始时间戳（毫秒）
-        end_date: 结束时间戳（毫秒）
-        db: 数据库连接
-        current_user: 当前用户
-
-    Returns:
-        - daily_conversations: 每日会话数统计
-        - total_conversations: 总会话数
-        - daily_new_users: 每日新增用户数
-        - total_new_users: 总新增用户数
-        - daily_api_calls: 每日API调用次数
-        - total_api_calls: 总API调用次数
-        - daily_tokens: 每日token消耗
-        - total_tokens: 总token消耗
-    """
-    workspace_id = current_user.current_workspace_id
-    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: 结束时间戳（毫秒）
-        db: 数据库连接
-        current_user: 当前用户
-    
-    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)
-
-
-@router.get("/{app_id}/export", summary="导出应用配置为 YAML 文件")
-@cur_workspace_access_guard()
-async def export_app(
-        app_id: uuid.UUID,
-        db: Annotated[Session, Depends(get_db)],
-        current_user: Annotated[User, Depends(get_current_user)],
-        release_id: Optional[uuid.UUID] = None
-):
-    """导出 agent / multi_agent / workflow 应用配置为 YAML 文件流。
-    release_id: 指定发布版本id，不传则导出当前草稿配置。
-    """
-    yaml_str, filename = AppDslService(db).export_dsl(app_id, release_id)
-    encoded = quote(filename, safe=".")
-    yaml_bytes = yaml_str.encode("utf-8")
-    file_stream = io.BytesIO(yaml_bytes)
-    file_stream.seek(0)
-    return StreamingResponse(
-        file_stream,
-        media_type="application/octet-stream; charset=utf-8",
-        headers={"Content-Disposition": f"attachment; filename={encoded}",
-                 "Content-Length": str(len(yaml_bytes))}
-    )
-
-
-@router.post("/import", summary="从 YAML 文件导入应用")
-@cur_workspace_access_guard()
-async def import_app(
-        file: UploadFile = File(...),
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """从 YAML 文件导入 agent / multi_agent / workflow 应用。
-    跨空间/跨租户导入时，模型/工具/知识库会按名称匹配，匹配不到则置空并返回 warnings。
-    """
-    if not file.filename.lower().endswith((".yaml", ".yml")):
-        return fail(msg="仅支持 YAML 文件", code=BizCode.BAD_REQUEST)
-
-    raw = (await file.read()).decode("utf-8")
-    dsl = yaml.safe_load(raw)
-    if not dsl or "app" not in dsl:
-        return fail(msg="YAML 格式无效，缺少 app 字段", code=BizCode.BAD_REQUEST)
-
-    new_app, warnings = AppDslService(db).import_dsl(
-        dsl=dsl,
-        workspace_id=current_user.current_workspace_id,
-        tenant_id=current_user.tenant_id,
-        user_id=current_user.id,
-    )
-    return success(
-        data={"app": app_schema.App.model_validate(new_app), "warnings": warnings},
-        msg="应用导入成功" + ("，但部分资源需手动配置" if warnings else "")
-    )

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/chunk_controller.py

@@ -441,14 +441,14 @@ async def retrieve_chunks(
     # 1 participle search, 2 semantic search, 3 hybrid search
     match retrieve_data.retrieve_type:
         case chunk_schema.RetrieveType.PARTICIPLE:
-            rs = vector_service.search_by_full_text(query=retrieve_data.query, top_k=retrieve_data.top_k, indices=indices, score_threshold=retrieve_data.similarity_threshold, file_names_filter=retrieve_data.file_names_filter)
+            rs = vector_service.search_by_full_text(query=retrieve_data.query, top_k=retrieve_data.top_k, indices=indices, score_threshold=retrieve_data.similarity_threshold)
             return success(data=rs, msg="retrieval successful")
         case chunk_schema.RetrieveType.SEMANTIC:
-            rs = vector_service.search_by_vector(query=retrieve_data.query, top_k=retrieve_data.top_k, indices=indices, score_threshold=retrieve_data.vector_similarity_weight, file_names_filter=retrieve_data.file_names_filter)
+            rs = vector_service.search_by_vector(query=retrieve_data.query, top_k=retrieve_data.top_k, indices=indices, score_threshold=retrieve_data.vector_similarity_weight)
             return success(data=rs, msg="retrieval successful")
         case _:
-            rs1 = vector_service.search_by_vector(query=retrieve_data.query, top_k=retrieve_data.top_k, indices=indices, score_threshold=retrieve_data.vector_similarity_weight, file_names_filter=retrieve_data.file_names_filter)
-            rs2 = vector_service.search_by_full_text(query=retrieve_data.query, top_k=retrieve_data.top_k, indices=indices, score_threshold=retrieve_data.similarity_threshold, file_names_filter=retrieve_data.file_names_filter)
+            rs1 = vector_service.search_by_vector(query=retrieve_data.query, top_k=retrieve_data.top_k, indices=indices, score_threshold=retrieve_data.vector_similarity_weight)
+            rs2 = vector_service.search_by_full_text(query=retrieve_data.query, top_k=retrieve_data.top_k, indices=indices, score_threshold=retrieve_data.similarity_threshold)
             # Efficient deduplication
             seen_ids = set()
             unique_rs = []

api/app/controllers/emotion_config_controller.py

@@ -7,11 +7,10 @@ Routes:
     GET /memory/config/emotion - 获取情绪引擎配置
     POST /memory/config/emotion - 更新情绪引擎配置
 """
-import uuid
 
 from fastapi import APIRouter, Depends, Query, HTTPException, status
 from pydantic import BaseModel, Field
-from typing import Optional, Union
+from typing import Optional
 from sqlalchemy.orm import Session
 from uuid import UUID
 
@@ -22,7 +21,6 @@ from app.schemas.response_schema import ApiResponse
 from app.services.emotion_config_service import EmotionConfigService
 from app.core.logging_config import get_api_logger
 from app.db import get_db
-from app.utils.config_utils import resolve_config_id
 
 # 获取API专用日志器
 api_logger = get_api_logger()
@@ -39,7 +37,7 @@ class EmotionConfigQuery(BaseModel):
 
 class EmotionConfigUpdate(BaseModel):
     """情绪配置更新请求模型"""
-    config_id: Union[uuid.UUID, int, str]= Field(..., description="配置ID")
+    config_id: UUID = Field(..., description="配置ID")
     emotion_enabled: bool = Field(..., description="是否启用情绪提取")
     emotion_model_id: Optional[str] = Field(None, description="情绪分析专用模型ID")
     emotion_extract_keywords: bool = Field(..., description="是否提取情绪关键词")
@@ -48,7 +46,7 @@ class EmotionConfigUpdate(BaseModel):
 
 @router.get("/read_config", response_model=ApiResponse)
 def get_emotion_config(
-    config_id: UUID|int = Query(..., description="配置ID"),
+    config_id: UUID = Query(..., description="配置ID"),
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
 ):
@@ -81,7 +79,7 @@ def get_emotion_config(
             f"用户 {current_user.username} 请求获取情绪配置",
             extra={"config_id": config_id}
         )
-        config_id=resolve_config_id(config_id, db)
+        
         # 初始化服务
         config_service = EmotionConfigService(db)
         
@@ -160,7 +158,6 @@ def update_emotion_config(
             }
         }
     """
-    config.config_id=resolve_config_id(config.config_id, db)
     try:
         api_logger.info(
             f"用户 {current_user.username} 请求更新情绪配置",

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,430 +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"
-        )
-    if page * pagesize > 100:
-        api_logger.warning(f"Paging parameters exceed ModelScope limit: page={page}, pagesize={pagesize}")
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"The maximum number of MCP services can view is 100. Please visit the ModelScope MCP Plaza."
-        )
-
-    # 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}")
-        return success(msg='The mcp market config does not exist or access is denied')
-
-    # 3. Execute paged query
-    token = db_mcp_market_config.token
-    if not token:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="MCP market config token is not configured"
-        )
-    api = MCPApi()
-    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"Failed 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("/operational_mcp_servers", response_model=ApiResponse)
-async def get_operational_mcp_servers(
-        mcp_market_config_id: uuid.UUID,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    Query the operational mcp servers list in pages
-    - Support keyword search for name,author,owner
-    - Return paging metadata + operational mcp server list
-    """
-    api_logger.info(
-        f"Query operational mcp server list: tenant_id={current_user.tenant_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}")
-        return success(msg='The mcp market config does not exist or access is denied')
-
-    # 2. Execute paged query
-    token = db_mcp_market_config.token
-    if not token:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="MCP market config token is not configured"
-        )
-    api = MCPApi()
-    api.login(token)
-
-    url = f'{api.mcp_base_url}/operational'
-    headers = api.builder_headers(api.headers)
-
-    try:
-        cookies = api.get_cookies(access_token=token, cookies_required=True)
-        r = api.session.get(url, headers=headers, cookies=cookies)
-        raise_for_http_status(r)
-    except requests.exceptions.RequestException as e:
-        api_logger.error(f"Failed to get operational MCP servers: {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to get operational 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]
-
-    # 3. Return structured response
-    return success(data=mcp_server_list, msg="Query of operational 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}")
-        return success(msg='The mcp market config does not exist or access is denied')
-
-    # 2. Get detailed information for a specific MCP Server
-    token = db_mcp_market_config.token
-    if not token:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="MCP market config token is not configured"
-        )
-    api = MCPApi()
-    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. Validate token can access ModelScope MCP market
-        if not create_data.token:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Token is required to access ModelScope MCP market"
-            )
-        try:
-            api = MCPApi()
-            api.login(create_data.token)
-            body = {'filter': {}, 'page_number': 1, 'page_size': 1, 'search': None}
-            cookies = api.get_cookies(create_data.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 Exception as e:
-            api_logger.warning(f"Token validation failed for ModelScope MCP market: {str(e)}")
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"Unable to access ModelScope MCP market with the provided token: {str(e)}"
-            )
-        # 2. 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}")
-            return success(msg='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}")
-            return success(msg='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}")
-        return success(msg='The mcp market config does not exist or access is denied')
-
-    # 2. Validate new token if provided
-    if update_data.token is not None:
-        try:
-            api = MCPApi()
-            api.login(update_data.token)
-            body = {'filter': {}, 'page_number': 1, 'page_size': 1, 'search': None}
-            cookies = api.get_cookies(update_data.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 Exception as e:
-            api_logger.warning(f"Token validation failed for ModelScope MCP market: {str(e)}")
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"Unable to access ModelScope MCP market with the provided token: {str(e)}"
-            )
-
-    # 3. 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)}")
-
-    # 4. 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}")
-            return success(msg='The mcp market config does not exist or access is denied')
-
-        # 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

@@ -1,29 +1,26 @@
 from typing import List, Optional
 
-from dotenv import load_dotenv
-from fastapi import APIRouter, Depends, File, Form, Query, UploadFile, Header
-from sqlalchemy.orm import Session
-from starlette.responses import StreamingResponse
-
-from app.cache.memory.interest_memory import InterestMemoryCache
 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.memory.agent.utils.redis_tool import store
-from app.core.memory.agent.utils.session_tools import SessionService
 from app.core.rag.llm.cv_model import QWenCV
 from app.core.response_utils import fail, success
 from app.db import get_db
 from app.dependencies import cur_workspace_access_guard, get_current_user
 from app.models import ModelApiKey
 from app.models.user_model import User
-from app.repositories import knowledge_repository
+from app.core.memory.agent.utils.session_tools import SessionService
+from app.core.memory.agent.utils.redis_tool import store
+from app.repositories import knowledge_repository, WorkspaceRepository
 from app.schemas.memory_agent_schema import UserInput, Write_UserInput
 from app.schemas.response_schema import ApiResponse
 from app.services import task_service, workspace_service
 from app.services.memory_agent_service import MemoryAgentService
 from app.services.model_service import ModelConfigService
+from dotenv import load_dotenv
+from fastapi import APIRouter, Depends, File, Form, Query, UploadFile,Header
+from sqlalchemy.orm import Session
+from starlette.responses import StreamingResponse
 
 load_dotenv()
 api_logger = get_api_logger()
@@ -38,7 +35,7 @@ router = APIRouter(
 
 @router.get("/health/status", response_model=ApiResponse)
 async def get_health_status(
-        current_user: User = Depends(get_current_user)
+    current_user: User = Depends(get_current_user)
 ):
     """
     Get latest health status written by Celery periodic task
@@ -56,9 +53,8 @@ async def get_health_status(
 
 @router.get("/download_log")
 async def download_log(
-        log_type: str = Query("file", regex="^(file|transmission)$",
-                              description="日志类型: file=完整文件, transmission=实时流式传输"),
-        current_user: User = Depends(get_current_user)
+    log_type: str = Query("file", regex="^(file|transmission)$", description="日志类型: file=完整文件, transmission=实时流式传输"),
+    current_user: User = Depends(get_current_user)
 ):
     """
     Download or stream agent service log file
@@ -77,16 +73,16 @@ async def download_log(
         - transmission mode: StreamingResponse with SSE
     """
     api_logger.info(f"Log download requested with log_type={log_type}")
-
+    
     # Validate log_type parameter (FastAPI Query regex already validates, but explicit check for clarity)
     if log_type not in ["file", "transmission"]:
         api_logger.warning(f"Invalid log_type parameter: {log_type}")
         return fail(
-            BizCode.BAD_REQUEST,
-            "无效的log_type参数",
+            BizCode.BAD_REQUEST, 
+            "无效的log_type参数", 
             "log_type必须是'file'或'transmission'"
         )
-
+    
     # Route to appropriate mode
     if log_type == "file":
         # File mode: Return complete log file content
@@ -121,28 +117,23 @@ async def download_log(
 @router.post("/writer_service", response_model=ApiResponse)
 @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)
+    user_input: Write_UserInput,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
 ):
     """
     Write service endpoint - processes write operations synchronously
     
     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(
         db=db,
@@ -151,7 +142,7 @@ async def write_server(
     )
     if storage_type is None: storage_type = 'neo4j'
     user_rag_memory_id = ''
-
+    
     # 如果 storage_type 是 rag，必须确保有有效的 user_rag_memory_id
     if storage_type == 'rag':
         if workspace_id:
@@ -163,15 +154,13 @@ async def write_server(
             if knowledge:
                 user_rag_memory_id = str(knowledge.id)
             else:
-                api_logger.warning(
-                    f"未找到名为 'USER_RAG_MERORY' 的知识库，workspace_id: {workspace_id}，将使用 neo4j 存储")
+                api_logger.warning(f"未找到名为 'USER_RAG_MERORY' 的知识库，workspace_id: {workspace_id}，将使用 neo4j 存储")
                 storage_type = 'neo4j'
         else:
             api_logger.warning("workspace_id 为空，无法使用 rag 存储，将使用 neo4j 存储")
             storage_type = 'neo4j'
-
-    api_logger.info(
-        f"Write service requested for group {user_input.end_user_id}, storage_type: {storage_type}, user_rag_memory_id: {user_rag_memory_id}")
+    
+    api_logger.info(f"Write service requested for group {user_input.end_user_id}, storage_type: {storage_type}, user_rag_memory_id: {user_rag_memory_id}")
     try:
         messages_list = memory_agent_service.get_messages_list(user_input)
         result = await memory_agent_service.write_memory(
@@ -179,9 +168,8 @@ async def write_server(
             messages_list,
             config_id,
             db,
-            storage_type,
-            user_rag_memory_id,
-            language
+            storage_type, 
+            user_rag_memory_id
         )
 
         return success(data=result, msg="写入成功")
@@ -199,29 +187,23 @@ async def write_server(
 @router.post("/writer_service_async", response_model=ApiResponse)
 @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)
+    user_input: Write_UserInput,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
 ):
     """
     Async write service endpoint - enqueues write processing to Celery
     
     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(
@@ -246,10 +228,10 @@ 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}")
-
+        
         return success(data={"task_id": task.id}, msg="写入任务已提交")
     except Exception as e:
         api_logger.error(f"Async write operation failed: {str(e)}")
@@ -259,9 +241,9 @@ async def write_server_async(
 @router.post("/read_service", response_model=ApiResponse)
 @cur_workspace_access_guard()
 async def read_server(
-        user_input: UserInput,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
+    user_input: UserInput,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
 ):
     """
     Read service endpoint - processes read operations synchronously
@@ -296,9 +278,8 @@ async def read_server(
         )
         if knowledge:
             user_rag_memory_id = str(knowledge.id)
-
-    api_logger.info(
-        f"Read service: group={user_input.end_user_id}, storage_type={storage_type}, user_rag_memory_id={user_rag_memory_id}, workspace_id={workspace_id}")
+    
+    api_logger.info(f"Read service: group={user_input.end_user_id}, storage_type={storage_type}, user_rag_memory_id={user_rag_memory_id}, workspace_id={workspace_id}")
     try:
         result = await memory_agent_service.read_memory(
             user_input.end_user_id,
@@ -312,8 +293,7 @@ async def read_server(
         )
         if str(user_input.search_switch) == "2":
             retrieve_info = result['answer']
-            history = await SessionService(store).get_history(user_input.end_user_id, user_input.end_user_id,
-                                                              user_input.end_user_id)
+            history = await SessionService(store).get_history(user_input.end_user_id, user_input.end_user_id, user_input.end_user_id)
             query = user_input.message
 
             # 调用 memory_agent_service 的方法生成最终答案
@@ -326,7 +306,7 @@ async def read_server(
                 db=db
             )
             if "信息不足，无法回答" in result['answer']:
-                result['answer'] = retrieve_info
+                result['answer']=retrieve_info
         return success(data=result, msg="回复对话消息成功")
     except BaseException as e:
         # Handle ExceptionGroup from TaskGroup (Python 3.11+) or BaseExceptionGroup
@@ -342,10 +322,9 @@ async def read_server(
 @router.post("/file", response_model=ApiResponse)
 async def file_update(
         files: List[UploadFile] = File(..., description="要上传的文件"),
-        model_id: str = Form(..., description="模型ID"),
+        model_id:str = Form(..., description="模型ID"),
         metadata: Optional[str] = Form(None, description="文件元数据 (JSON格式)"),
-        current_user: User = Depends(get_current_user),
-        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_user)
 ):
     """
     文件上传接口 - 支持图片识别
@@ -358,6 +337,9 @@ async def file_update(
     Returns:
         文件处理结果
     """
+
+    db_gen = get_db()             # get_db 通常是一个生成器
+    db = next(db_gen)
     api_logger.info(f"File upload requested, file count: {len(files)}")
     config = ModelConfigService.get_model_by_id(db=db, model_id=model_id)
     apiConfig: ModelApiKey = config.api_keys[0]
@@ -366,7 +348,7 @@ async def file_update(
         for file in files:
             api_logger.debug(f"Processing file: {file.filename}, content_type: {file.content_type}")
             content = await file.read()
-
+            
             if file.content_type and file.content_type.startswith("image/"):
                 vision_model = QWenCV(
                     key=apiConfig.api_key,
@@ -380,12 +362,12 @@ async def file_update(
             else:
                 api_logger.warning(f"Unsupported file type: {file.content_type}")
                 file_content.append(f"[不支持的文件类型: {file.content_type}]")
-
+        
         result_text = ';'.join(file_content)
         api_logger.info(f"File processing completed, result length: {len(result_text)}")
-
+        
         return success(data=result_text, msg="转换文本成功")
-
+        
     except Exception as e:
         api_logger.error(f"File processing failed: {str(e)}", exc_info=True)
         return fail(BizCode.INTERNAL_ERROR, "转换文本失败", str(e))
@@ -435,8 +417,8 @@ async def read_server_async(
 
 @router.get("/read_result/", response_model=ApiResponse)
 async def get_read_task_result(
-        task_id: str,
-        current_user: User = Depends(get_current_user)
+    task_id: str,
+    current_user: User = Depends(get_current_user)
 ):
     """
     Get the status and result of an async read task
@@ -457,7 +439,7 @@ async def get_read_task_result(
     try:
         result = task_service.get_task_memory_read_result(task_id)
         status = result.get("status")
-
+        
         if status == "SUCCESS":
             # 任务成功完成
             task_result = result.get("result", {})
@@ -475,7 +457,7 @@ async def get_read_task_result(
             else:
                 # 旧格式：直接返回结果
                 return success(data=task_result, msg="查询任务已完成")
-
+                
         elif status == "FAILURE":
             # 任务失败
             error_info = result.get("result", "Unknown error")
@@ -484,7 +466,7 @@ async def get_read_task_result(
             else:
                 error_msg = str(error_info)
             return fail(BizCode.INTERNAL_ERROR, "查询任务失败", error_msg)
-
+            
         elif status in ["PENDING", "STARTED"]:
             # 任务进行中
             return success(
@@ -504,7 +486,7 @@ async def get_read_task_result(
                 },
                 msg=f"任务状态: {status}"
             )
-
+            
     except Exception as e:
         api_logger.error(f"Read task status check failed: {str(e)}", exc_info=True)
         return fail(BizCode.INTERNAL_ERROR, "任务状态查询失败", str(e))
@@ -512,8 +494,8 @@ async def get_read_task_result(
 
 @router.get("/write_result/", response_model=ApiResponse)
 async def get_write_task_result(
-        task_id: str,
-        current_user: User = Depends(get_current_user)
+    task_id: str,
+    current_user: User = Depends(get_current_user)
 ):
     """
     Get the status and result of an async write task
@@ -534,7 +516,7 @@ async def get_write_task_result(
     try:
         result = task_service.get_task_memory_write_result(task_id)
         status = result.get("status")
-
+        
         if status == "SUCCESS":
             # 任务成功完成
             task_result = result.get("result", {})
@@ -552,7 +534,7 @@ async def get_write_task_result(
             else:
                 # 旧格式：直接返回结果
                 return success(data=task_result, msg="写入任务已完成")
-
+                
         elif status == "FAILURE":
             # 任务失败
             error_info = result.get("result", "Unknown error")
@@ -561,7 +543,7 @@ async def get_write_task_result(
             else:
                 error_msg = str(error_info)
             return fail(BizCode.INTERNAL_ERROR, "写入任务失败", error_msg)
-
+            
         elif status in ["PENDING", "STARTED"]:
             # 任务进行中
             return success(
@@ -581,7 +563,7 @@ async def get_write_task_result(
                 },
                 msg=f"任务状态: {status}"
             )
-
+            
     except Exception as e:
         api_logger.error(f"Write task status check failed: {str(e)}", exc_info=True)
         return fail(BizCode.INTERNAL_ERROR, "任务状态查询失败", str(e))
@@ -589,9 +571,9 @@ async def get_write_task_result(
 
 @router.post("/status_type", response_model=ApiResponse)
 async def status_type(
-        user_input: Write_UserInput,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
+    user_input: Write_UserInput,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
 ):
     """
     Determine the type of user message (read or write)
@@ -634,21 +616,26 @@ async def status_type(
 
 @router.get("/stats/types", response_model=ApiResponse)
 async def get_knowledge_type_stats_api(
-        end_user_id: Optional[str] = Query(None, description="用户ID（可选）"),
-        only_active: bool = Query(True, description="仅统计有效记录(status=1)"),
-        current_user: User = Depends(get_current_user),
-        db: Session = Depends(get_db),
+    end_user_id: Optional[str] = Query(None, description="用户ID（可选）"),
+    only_active: bool = Query(True, description="仅统计有效记录(status=1)"),
+    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}")
+    api_logger.info(f"Knowledge type stats requested for workspace_id: {current_user.current_workspace_id}, end_user_id: {end_user_id}")
     try:
+        from app.db import get_db
+        
+        # 获取数据库会话
+        db_gen = get_db()
+        db = next(db_gen)
+        
         # 调用service层函数
         result = await memory_agent_service.get_knowledge_type_stats(
             end_user_id=end_user_id,
@@ -656,70 +643,59 @@ async def get_knowledge_type_stats_api(
             current_workspace_id=current_user.current_workspace_id,
             db=db
         )
-
+        
         return success(data=result, msg="获取知识库类型统计成功")
     except Exception as e:
         api_logger.error(f"Knowledge type stats failed: {str(e)}")
         return fail(BizCode.INTERNAL_ERROR, "获取知识库类型统计失败", str(e))
 
 
-@router.get("/analytics/interest_distribution/by_user", response_model=ApiResponse)
-async def get_interest_distribution_by_user_api(
-        end_user_id: str = Query(..., description="用户ID（必填）"),
-        limit: int = Query(5, le=5, description="返回兴趣标签数量限制，最多5个"),
-        language_type: str = Header(default=None, alias="X-Language-Type"),
-        current_user: User = Depends(get_current_user),
-        db: Session = Depends(get_db),
+@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),
 ):
     """
-    获取指定用户的兴趣分布标签
-    
-    与热门标签不同，此接口专注于识别用户的兴趣活动（运动、爱好、学习、创作等），
-    过滤掉纯物品、工具、地点等不代表用户主动参与活动的名词。
+    获取指定用户的热门记忆标签
     
     返回格式：
     [
-        {"name": "兴趣活动名", "frequency": 频次},
+        {"name": "标签名", "frequency": 频次},
         ...
     ]
     """
-    language = get_language_from_header(language_type)
-    api_logger.info(f"Interest distribution by user requested: end_user_id={end_user_id}, language={language}")
+
+    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:
-        # 优先读取缓存
-        cached = await InterestMemoryCache.get_interest_distribution(
+        result = await memory_agent_service.get_hot_memory_tags_by_user(
             end_user_id=end_user_id,
-            language=language,
+            language_type=language_type,
+            model_id=model_id,
+            limit=limit
         )
-        if cached is not None:
-            api_logger.info(f"Interest distribution cache hit: end_user_id={end_user_id}")
-            return success(data=cached, msg="获取兴趣分布标签成功")
-
-        # 缓存未命中，调用模型生成
-        result = await memory_agent_service.get_interest_distribution_by_user(
-            end_user_id=end_user_id,
-            limit=limit,
-            language=language
-        )
-
-        # 写入缓存，24小时过期
-        await InterestMemoryCache.set_interest_distribution(
-            end_user_id=end_user_id,
-            language=language,
-            data=result,
-        )
-
-        return success(data=result, msg="获取兴趣分布标签成功")
+        return success(data=result, msg="获取热门记忆标签成功")
     except Exception as e:
-        api_logger.error(f"Interest distribution by user failed: {str(e)}")
-        return fail(BizCode.INTERNAL_ERROR, "获取兴趣分布标签失败", str(e))
+        api_logger.error(f"Hot memory tags by user failed: {str(e)}")
+        return fail(BizCode.INTERNAL_ERROR, "获取热门记忆标签失败", str(e))
 
 
 @router.get("/analytics/user_profile", response_model=ApiResponse)
 async def get_user_profile_api(
-        end_user_id: Optional[str] = Query(None, description="用户ID（可选）"),
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
+    end_user_id: Optional[str] = Query(None, description="用户ID（可选）"),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
 ):
     """
     获取用户详情，包含：
@@ -757,17 +733,17 @@ async def get_user_profile_api(
 # ):
 #     """
 #     Get parsed API documentation (Public endpoint - no authentication required)
-
+    
 #     Args:
 #         file_path: Optional path to API docs file. If None, uses default path.
-
+    
 #     Returns:
 #         Parsed API documentation including title, meta info, and sections
 #     """
 #     api_logger.info(f"API docs requested, file_path: {file_path or 'default'}")
 #     try:
 #         result = await memory_agent_service.get_api_docs(file_path)
-
+        
 #         if result.get("success"):
 #             return success(msg=result["msg"], data=result["data"])
 #         else:
@@ -783,9 +759,9 @@ async def get_user_profile_api(
 
 @router.get("/end_user/{end_user_id}/connected_config", response_model=ApiResponse)
 async def get_end_user_connected_config(
-        end_user_id: str,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
+    end_user_id: str,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
 ):
     """
     获取终端用户关联的记忆配置
@@ -804,9 +780,9 @@ async def get_end_user_connected_config(
     from app.services.memory_agent_service import (
         get_end_user_connected_config as get_config,
     )
-
+    
     api_logger.info(f"Getting connected config for end_user: {end_user_id}")
-
+    
     try:
         result = get_config(end_user_id, db)
         return success(data=result, msg="获取终端用户关联配置成功")
@@ -815,4 +791,4 @@ async def get_end_user_connected_config(
         return fail(BizCode.NOT_FOUND, str(e))
     except Exception as e:
         api_logger.error(f"Failed to get end user connected config: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "获取终端用户关联配置失败", str(e))
+        return fail(BizCode.INTERNAL_ERROR, "获取终端用户关联配置失败", str(e))

api/app/controllers/memory_dashboard_controller.py

@@ -1,5 +1,4 @@
 from fastapi import APIRouter, Depends, HTTPException, status, Query
-from pydantic import BaseModel, Field
 from sqlalchemy.orm import Session
 from typing import Optional
 from app.core.response_utils import success
@@ -10,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专用日志器
@@ -150,21 +148,6 @@ async def get_workspace_end_users(
         
         return {uid: {"total": 0} for uid in end_user_ids}
     
-    # 触发按需初始化：为 implicit_emotions_storage 中没有记录的用户异步生成数据
-    try:
-        from app.celery_app import celery_app as _celery_app
-        _celery_app.send_task(
-            "app.tasks.init_implicit_emotions_for_users",
-            kwargs={"end_user_ids": end_user_ids},
-        )
-        _celery_app.send_task(
-            "app.tasks.init_interest_distribution_for_users",
-            kwargs={"end_user_ids": end_user_ids},
-        )
-        api_logger.info(f"已触发按需初始化任务，候选用户数: {len(end_user_ids)}")
-    except Exception as e:
-        api_logger.warning(f"触发按需初始化任务失败（不影响主流程）: {e}")
-
     # 并发执行配置查询和记忆数量查询
     memory_configs_map, memory_nums_map = await asyncio.gather(
         get_memory_configs(),
@@ -403,15 +386,14 @@ def get_current_user_rag_total_num(
 @router.get("/rag_content", response_model=ApiResponse)
 def get_rag_content(
     end_user_id: str = Query(..., description="宿主ID"),
-    page: int = Query(1, gt=0, description="页码，从1开始"),
-    pagesize: int = Query(15, gt=0, le=100, description="每页返回记录数"),
+    limit: int = Query(15, description="返回记录数"),
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
 ):
     """
-    获取当前宿主知识库中的chunk内容（分页）
+    获取当前宿主知识库中的chunk内容
     """
-    data = memory_dashboard_service.get_rag_content(end_user_id, page, pagesize, db, current_user)
+    data = memory_dashboard_service.get_rag_content(end_user_id, limit, db, current_user)
     return success(data=data, msg="宿主RAGchunk数据获取成功")
 
 
@@ -424,18 +406,26 @@ async def get_chunk_summary_tag(
     current_user: User = Depends(get_current_user),
 ):
     """
-    读取RAG摘要、标签和人物形象（纯读库，不触发生成）。
-
+    获取chunk总结、提取的标签和人物形象
+    
     返回格式：
     {
-        "summary": "用户摘要",
-        "tags": [{"tag": "标签1", "frequency": 5}, ...],
-        "personas": ["产品设计师", ...],
-        "generated": true/false  // false表示尚未生产，请调用 /generate_rag_profile
+        "summary": "chunk内容的总结",
+        "tags": [
+            {"tag": "标签1", "frequency": 5},
+            {"tag": "标签2", "frequency": 3},
+            ...
+        ],
+        "personas": [
+            "产品设计师",
+            "旅行爱好者",
+            "摄影发烧友",
+            ...
+        ]
     }
     """
-    api_logger.info(f"用户 {current_user.username} 读取宿主 {end_user_id} 的RAG摘要/标签/人物形象")
-
+    api_logger.info(f"用户 {current_user.username} 请求获取宿主 {end_user_id} 的chunk摘要、标签和人物形象")
+    
     data = await memory_dashboard_service.get_chunk_summary_and_tags(
         end_user_id=end_user_id,
         limit=limit,
@@ -443,8 +433,9 @@ async def get_chunk_summary_tag(
         db=db,
         current_user=current_user
     )
-
-    return success(data=data, msg="获取成功")
+    
+    api_logger.info(f"成功获取chunk摘要、{len(data.get('tags', []))} 个标签和 {len(data.get('personas', []))} 个人物形象")
+    return success(data=data, msg="chunk摘要、标签和人物形象获取成功")
 
 
 @router.get("/chunk_insight", response_model=ApiResponse)
@@ -455,64 +446,29 @@ async def get_chunk_insight(
     current_user: User = Depends(get_current_user),
 ):
     """
-    读取RAG洞察报告（纯读库，不触发生成）。
-
+    获取chunk的洞察内容
+    
     返回格式：
     {
-        "insight": "总体概述",
-        "behavior_pattern": "行为模式",
-        "key_findings": "关键发现",
-        "growth_trajectory": "成长轨迹",
-        "generated": true/false  // false表示尚未生产，请调用 /generate_rag_profile
+        "insight": "对chunk内容的深度洞察分析"
     }
     """
-    api_logger.info(f"用户 {current_user.username} 读取宿主 {end_user_id} 的RAG洞察")
-
+    api_logger.info(f"用户 {current_user.username} 请求获取宿主 {end_user_id} 的chunk洞察")
+    
     data = await memory_dashboard_service.get_chunk_insight(
         end_user_id=end_user_id,
         limit=limit,
         db=db,
         current_user=current_user
     )
-
-    return success(data=data, msg="获取成功")
-
-
-class GenerateRagProfileRequest(BaseModel):
-    end_user_id: str = Field(..., description="宿主ID")
-    limit: int = Field(15, description="参与生成的chunk数量上限")
-    max_tags: int = Field(10, description="最大标签数量")
-
-
-@router.post("/generate_rag_profile", response_model=ApiResponse)
-async def generate_rag_profile(
-    body: GenerateRagProfileRequest,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-):
-    """
-    生产接口：为RAG存储模式的宿主全量重新生成完整画像并持久化到end_user表。
-    每次请求都会重新生成，覆盖已有数据。
-    """
-    api_logger.info(f"用户 {current_user.username} 触发RAG画像生产: end_user_id={body.end_user_id}")
-
-    data = await memory_dashboard_service.generate_rag_profile(
-        end_user_id=body.end_user_id,
-        limit=body.limit,
-        max_tags=body.max_tags,
-        db=db,
-        current_user=current_user,
-    )
-
-    api_logger.info(f"RAG画像生产完成: {data}")
-    return success(data=data, msg="RAG画像生产完成")
+    
+    api_logger.info("成功获取chunk洞察")
+    return success(data=data, msg="chunk洞察获取成功")
 
 
 @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),
 ):
@@ -547,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,
@@ -616,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")
@@ -647,8 +589,8 @@ async def dashboard_data(
             
             # 获取RAG相关数据
             try:
-                # total_memory: 只统计用户知识库（permission_id='Memory'）的chunk数
-                total_chunk = memory_dashboard_service.get_rag_user_kb_total_chunk(db, current_user)
+                # total_memory: 使用 total_chunk（总chunk数）
+                total_chunk = memory_dashboard_service.get_rag_total_chunk(db, current_user)
                 rag_data["total_memory"] = total_chunk
                 
                 # total_app: 统计当前空间下的所有app数量
@@ -660,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_forget_controller.py

@@ -34,7 +34,7 @@ from app.schemas.memory_storage_schema import (
 )
 from app.schemas.response_schema import ApiResponse
 from app.services.memory_forget_service import MemoryForgetService
-from app.utils.config_utils import resolve_config_id
+
 
 # 获取API专用日志器
 api_logger = get_api_logger()
@@ -84,8 +84,7 @@ async def trigger_forgetting_cycle(
         
         connected_config = get_end_user_connected_config(end_user_id, db)
         config_id = connected_config.get("memory_config_id")
-        config_id = resolve_config_id((config_id), db)
-
+        
         if config_id is None:
             api_logger.warning(f"终端用户 {end_user_id} 未关联记忆配置")
             return fail(BizCode.INVALID_PARAMETER, f"终端用户 {end_user_id} 未关联记忆配置", "memory_config_id is None")
@@ -130,7 +129,7 @@ async def trigger_forgetting_cycle(
 
 @router.get("/read_config", response_model=ApiResponse)
 async def read_forgetting_config(
-    config_id: UUID|int,
+    config_id: UUID,
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
@@ -159,7 +158,6 @@ async def read_forgetting_config(
     )
     
     try:
-        config_id=resolve_config_id(config_id, db)
         # 调用服务层读取配置
         config = forget_service.read_forgetting_config(db=db, config_id=config_id)
         
@@ -197,8 +195,6 @@ async def update_forgetting_config(
         ApiResponse: 包含更新结果的响应
     """
     workspace_id = current_user.current_workspace_id
-    payload.config_id=resolve_config_id((payload.config_id), db)
-
     
     # 检查用户是否已选择工作空间
     if workspace_id is None:
@@ -259,10 +255,12 @@ async def get_forgetting_stats(
         ApiResponse: 包含统计信息的响应
     """
     workspace_id = current_user.current_workspace_id
+    
     # 检查用户是否已选择工作空间
     if workspace_id is None:
         api_logger.warning(f"用户 {current_user.username} 尝试获取遗忘引擎统计但未选择工作空间")
         return fail(BizCode.INVALID_PARAMETER, "请先切换到一个工作空间", "current_workspace_id is None")
+    
     # 如果提供了 end_user_id，通过它获取 config_id
     config_id = None
     if end_user_id:
@@ -271,7 +269,6 @@ async def get_forgetting_stats(
             
             connected_config = get_end_user_connected_config(end_user_id, db)
             config_id = connected_config.get("memory_config_id")
-            config_id = resolve_config_id(config_id, db)
             
             if config_id is None:
                 api_logger.warning(f"终端用户 {end_user_id} 未关联记忆配置")
@@ -328,7 +325,7 @@ async def get_forgetting_curve(
         ApiResponse: 包含遗忘曲线数据的响应
     """
     workspace_id = current_user.current_workspace_id
-    request.config_id = resolve_config_id((request.config_id), db)
+    
     # 检查用户是否已选择工作空间
     if workspace_id is None:
         api_logger.warning(f"用户 {current_user.username} 尝试获取遗忘曲线但未选择工作空间")

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,
@@ -26,8 +25,6 @@ from fastapi import APIRouter, Depends, HTTPException, status,Header
 from sqlalchemy import text
 from sqlalchemy.orm import Session
 
-from app.utils.config_utils import resolve_config_id
-
 load_dotenv()
 api_logger = get_api_logger()
 
@@ -46,12 +43,12 @@ async def save_reflection_config(
     """Save reflection configuration to data_comfig table"""
     try:
         config_id = request.config_id
-        config_id = resolve_config_id(config_id, db)
         if not config_id:
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
                 detail="缺少必需参数: config_id"
             )
+
         api_logger.info(f"用户 {current_user.username} 保存反思配置，config_id: {config_id}")
 
         memory_config = MemoryConfigRepository.update_reflection_config(
@@ -102,71 +99,51 @@ async def start_workspace_reflection(
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
 ) -> dict:
-    """启动工作空间中所有匹配应用的反思功能"""
+    """Activate the reflection function for all matching applications in the workspace"""
     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']:
-                api_logger.debug(f"应用 {data['id']} 没有memory_configs，跳过")
+            if data['memory_configs'] == []: 
                 continue
-
+                
             releases = data['releases']
             memory_configs = data['memory_configs']
             end_users = data['end_users']
-
-            # 为每个配置和用户组合执行反思
-            for config in memory_configs:
-                config_id_str = str(config['config_id'])
-
-                # 找到匹配此配置的所有release
-                matching_releases = [r for r in releases if str(r['config']) == config_id_str]
-
-                if not matching_releases:
-                    api_logger.debug(f"配置 {config_id_str} 没有匹配的release")
+            
+            for base, config, user in zip(releases, memory_configs, end_users):
+                # 安全地转换为整数，处理空字符串和None的情况
+                print(base['config'])
+                try:
+                    base_config = int(base['config']) if base['config'] else 0
+                    config_id = int(config['config_id']) if config['config_id'] else 0
+                except (ValueError, TypeError):
+                    api_logger.warning(f"无效的配置ID: base['config']={base.get('config')}, config['config_id']={config.get('config_id')}")
                     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']
-                            )
-
-                            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)}"
-                                }
-                            })
+                
+                if base_config == config_id and base['app_id'] == user['app_id']:
+                    # 调用反思服务
+                    api_logger.info(f"为用户 {user['id']} 启动反思，config_id: {config['config_id']}")
+                    
+                    reflection_result = await reflection_service.start_text_reflection(
+                        config_data=config,
+                        end_user_id=user['id']
+                    )
+                    
+                    reflection_results.append({
+                        "app_id": base['app_id'],
+                        "config_id": config['config_id'],
+                        "end_user_id": user['id'],
+                        "reflection_result": reflection_result
+                    })
 
         return success(data=reflection_results, msg="反思配置成功")
 
@@ -180,20 +157,17 @@ async def start_workspace_reflection(
 
 @router.get("/reflection/configs")
 async def start_reflection_configs(
-        config_id: uuid.UUID|int,
+        config_id: uuid.UUID,
         current_user: User = Depends(get_current_user),
         db: Session = Depends(get_db),
 ) -> dict:
     """通过config_id查询memory_config表中的反思配置信息"""
-    config_id = resolve_config_id(config_id, db)
     try:
-        config_id=resolve_config_id(config_id,db)
         api_logger.info(f"用户 {current_user.username} 查询反思配置，config_id: {config_id}")
         result = MemoryConfigRepository.query_reflection_config_by_id(db, config_id)
-        memory_config_id = resolve_config_id(result.config_id, db)
         # 构建返回数据
         reflection_config = {
-            "config_id": memory_config_id,
+            "config_id": result.config_id,
             "reflection_enabled": result.enable_self_reflexion,
             "reflection_period_in_hours": result.iteration_period,
             "reflexion_range": result.reflexion_range,
@@ -218,17 +192,15 @@ 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"),
+    config_id: UUID,
+    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)
+
     # 使用MemoryConfigRepository查询反思配置
     result = MemoryConfigRepository.query_reflection_config_by_id(db, config_id)
     if not result:

api/app/controllers/memory_short_term_controller.py

@@ -1,18 +1,15 @@
-from typing import Optional
-
-from dotenv import load_dotenv
-from fastapi import APIRouter, Depends, Header, HTTPException, status
-from sqlalchemy.orm import Session
-
-from app.core.language_utils import get_language_from_header
+from fastapi import APIRouter, Depends, HTTPException, status,Header
 from app.core.logging_config import get_api_logger
 from app.core.response_utils import success
 from app.db import get_db
 from app.dependencies import get_current_user
 from app.models.user_model import User
-from app.services.memory_short_service import LongService, ShortService
-from app.services.memory_storage_service import search_entity
 
+from app.services.memory_storage_service import search_entity
+from app.services.memory_short_service import ShortService,LongService
+from dotenv import load_dotenv
+from sqlalchemy.orm import Session
+from typing import Optional
 load_dotenv()
 api_logger = get_api_logger()
 
@@ -23,19 +20,16 @@ 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, db)
+    short_term=ShortService(end_user_id)
     short_result=short_term.get_short_databasets()
     short_count=short_term.get_short_count()
 
-    long_term=LongService(end_user_id, db)
+    long_term=LongService(end_user_id)
     long_result=long_term.get_long_databasets()
 
     entity_result = await search_entity(end_user_id)

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, JSONResponse
-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,12 +31,10 @@ 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
 
-from app.utils.config_utils import resolve_config_id
-
 # Get API logger
 api_logger = get_api_logger()
 
@@ -75,9 +70,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,9 +139,9 @@ def create_config(
     payload: ConfigParamsCreate,
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
-    x_language_type: Optional[str] = Header(None, alias="X-Language-Type"),
-) -> dict:
+    ) -> dict:
     workspace_id = current_user.current_workspace_id
+    
     # 检查用户是否已选择工作空间
     if workspace_id is None:
         api_logger.warning(f"用户 {current_user.username} 尝试创建配置但未选择工作空间")
@@ -100,125 +154,46 @@ def create_config(
         svc = DataConfigService(db)
         result = svc.create(payload)
         return success(data=result, msg="创建成功")
-    except ValueError as e:
-        err_str = str(e)
-        if err_str.startswith("DUPLICATE_CONFIG_NAME:"):
-            config_name = err_str.split(":", 1)[1]
-            api_logger.warning(f"重复的配置名称 '{config_name}' 在工作空间 {workspace_id}")
-            lang = get_language_from_header(x_language_type)
-            if lang == "en":
-                msg = fail(BizCode.BAD_REQUEST, "Config name already exists", f"A config named \"{config_name}\" already exists in the current workspace. Please use a different name.")
-            else:
-                msg = fail(BizCode.BAD_REQUEST, "配置名称已存在", f"当前工作空间下已存在名为「{config_name}」的记忆配置，请使用其他名称")
-            return JSONResponse(status_code=400, content=msg)
-        api_logger.error(f"Create config failed: {err_str}")
-        return fail(BizCode.INTERNAL_ERROR, "创建配置失败", err_str)
     except Exception as e:
-        from sqlalchemy.exc import IntegrityError
-        if isinstance(e, IntegrityError) and "uq_workspace_config_name" in str(getattr(e, 'orig', '')):
-            api_logger.warning(f"重复的配置名称 '{payload.config_name}' 在工作空间 {workspace_id}")
-            lang = get_language_from_header(x_language_type)
-            if lang == "en":
-                msg = fail(BizCode.BAD_REQUEST, "Config name already exists", f"A config named \"{payload.config_name}\" already exists in the current workspace. Please use a different name.")
-            else:
-                msg = fail(BizCode.BAD_REQUEST, "配置名称已存在", f"当前工作空间下已存在名为「{payload.config_name}」的记忆配置，请使用其他名称")
-            return JSONResponse(status_code=400, content=msg)
         api_logger.error(f"Create config failed: {str(e)}")
         return fail(BizCode.INTERNAL_ERROR, "创建配置失败", str(e))
 
 
 @router.delete("/delete_config", response_model=ApiResponse)  # 删除数据库中的内容（按配置名称）
 def delete_config(
-    config_id: UUID|int,
-    force: bool = Query(False, description="是否强制删除（即使有终端用户正在使用）"),
+    config_id: UUID,
     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)
+    
     # 检查用户是否已选择工作空间
     if workspace_id is None:
         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)
+    
     # 检查用户是否已选择工作空间
     if workspace_id is None:
         api_logger.warning(f"用户 {current_user.username} 尝试更新配置但未选择工作空间")
         return fail(BizCode.INVALID_PARAMETER, "请先切换到一个工作空间", "current_workspace_id is None")
     
-    # 校验至少有一个字段需要更新
-    if payload.config_name is None and payload.config_desc is None and payload.scene_id is None:
-        api_logger.warning(f"用户 {current_user.username} 尝试更新配置但未提供任何更新字段")
-        return fail(BizCode.INVALID_PARAMETER, "请至少提供一个需要更新的字段", "config_name, config_desc, scene_id 均为空")
-    
     api_logger.info(f"用户 {current_user.username} 在工作空间 {workspace_id} 请求更新配置: {payload.config_id}")
     try:
         svc = DataConfigService(db)
@@ -234,9 +209,9 @@ 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)
+    
     # 检查用户是否已选择工作空间
     if workspace_id is None:
         api_logger.warning(f"用户 {current_user.username} 尝试更新提取配置但未选择工作空间")
@@ -258,12 +233,12 @@ def update_config_extracted(
 
 @router.get("/read_config_extracted", response_model=ApiResponse) # 通过查询参数读取某条配置（固定路径） 没有意义的话就删除
 def read_config_extracted(
-    config_id: UUID | int,
+    config_id: UUID,
     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)
+    
     # 检查用户是否已选择工作空间
     if workspace_id is None:
         api_logger.warning(f"用户 {current_user.username} 尝试读取提取配置但未选择工作空间")
@@ -282,7 +257,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
     
     # 检查用户是否已选择工作空间
@@ -304,22 +279,16 @@ 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",
@@ -328,8 +297,9 @@ async def pilot_run(
         },
     )
 
-
-# ==================== Search & Analytics ====================
+"""
+以下为搜索与分析接口，直接挂载到同一 router，统一响应为 ApiResponse。
+"""
 
 @router.get("/search/kb_type_distribution", response_model=ApiResponse)
 async def get_kb_type_distribution(
@@ -469,9 +439,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:
@@ -544,11 +513,10 @@ async def clear_hot_memory_tags_cache(
 @router.get("/analytics/recent_activity_stats", response_model=ApiResponse)
 async def get_recent_activity_stats_api(
     current_user: User = Depends(get_current_user),
-) -> dict:
-    workspace_id = str(current_user.current_workspace_id) if current_user.current_workspace_id else None
-    api_logger.info(f"Recent activity stats requested: workspace_id={workspace_id}")
+    ) -> dict:
+    api_logger.info("Recent activity stats requested")
     try:
-        result = await analytics_recent_activity_stats(workspace_id=workspace_id)
+        result = await analytics_recent_activity_stats()
         return success(data=result, msg="查询成功")
     except Exception as e:
         api_logger.error(f"Recent activity stats failed: {str(e)}")

api/app/controllers/model_controller.py

@@ -3,17 +3,15 @@ from sqlalchemy.orm import Session
 from typing import Optional
 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
-from app.models.models_model import ModelProvider, ModelType, LoadBalanceStrategy
+from app.models.models_model import ModelProvider, ModelType
 from app.models.user_model import User
-from app.repositories.model_repository import ModelConfigRepository
 from app.schemas import model_schema
 from app.core.response_utils import success
 from app.schemas.response_schema import ApiResponse, PageData
-from app.services.model_service import ModelConfigService, ModelApiKeyService, ModelBaseService
+from app.services.model_service import ModelConfigService, ModelApiKeyService
 from app.core.logging_config import get_api_logger
 
 # 获取API专用日志器
@@ -26,54 +24,44 @@ router = APIRouter(
 
 @router.get("/type", response_model=ApiResponse)
 def get_model_types():
+    
     return success(msg="获取模型类型成功", data=list(ModelType))
 
 
 @router.get("/provider", response_model=ApiResponse)
 def get_model_providers():
-    providers = [p for p in ModelProvider if p != ModelProvider.COMPOSITE]
-    return success(msg="获取模型提供商成功", data=providers)
-
-@router.get("/strategy", response_model=ApiResponse)
-def get_model_strategies():
-    return success(msg="获取模型策略成功", data=list(LoadBalanceStrategy))
+    return success(msg="获取模型提供商成功", data=list(ModelProvider))
 
 
 @router.get("", response_model=ApiResponse)
 def get_model_list(
-        type: Optional[list[str]] = Query(None, description="模型类型筛选（支持多个，如 ?type=LLM 或 ?type=LLM,EMBEDDING）"),
-        provider: Optional[model_schema.ModelProvider] = Query(None, description="提供商筛选(基于API Key)"),
-        is_active: Optional[bool] = Query(None, description="激活状态筛选"),
-        is_public: Optional[bool] = Query(None, description="公开状态筛选"),
-        search: Optional[str] = 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)
+    type: Optional[str] = Query(None, description="模型类型筛选（支持多个，如 ?type=LLM 或 ?type=LLM,EMBEDDING）"),
+    provider: Optional[model_schema.ModelProvider] = Query(None, description="提供商筛选(基于API Key)"),
+    is_active: Optional[bool] = Query(None, description="激活状态筛选"),
+    is_public: Optional[bool] = Query(None, description="公开状态筛选"),
+    search: Optional[str] = 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)
 ):
     """
     获取模型配置列表
-
+    
     支持多个 type 参数：
     - 单个：?type=LLM
     - 多个（逗号分隔）：?type=LLM,EMBEDDING
     - 多个（重复参数）：?type=LLM&type=EMBEDDING
     """
-    api_logger.info(
-        f"获取模型配置列表请求: type={type}, provider={provider}, page={page}, pagesize={pagesize}, tenant_id={current_user.tenant_id}")
-
+    api_logger.info(f"获取模型配置列表请求: type={type}, provider={provider}, page={page}, pagesize={pagesize}, tenant_id={current_user.tenant_id}")
+    
     try:
         # 解析 type 参数（支持逗号分隔）
-        type_list = []
-        if type is not None:
-            flat_type = []
-            for item in type:
-                split_items = [t.strip() for t in item.split(',') if t.strip()]
-                flat_type.extend(split_items)
-
-            unique_flat_type = list(dict.fromkeys(flat_type))
-            type_list = [ModelType(t.lower()) for t in unique_flat_type]
-
+        type_list = None
+        if type:
+            type_values = [t.strip() for t in type.split(',')]
+            type_list = [model_schema.ModelType(t.lower()) for t in type_values if t]
+        
         api_logger.error(f"获取模型type_list: {type_list}")
         query = model_schema.ModelConfigQuery(
             type=type_list,
@@ -84,7 +72,7 @@ def get_model_list(
             page=page,
             pagesize=pagesize
         )
-
+        
         api_logger.debug(f"开始获取模型配置列表: {query.dict()}")
         result_orm = ModelConfigService.get_model_list(db=db, query=query, tenant_id=current_user.tenant_id)
         result = PageData.model_validate(result_orm)
@@ -95,146 +83,6 @@ def get_model_list(
         raise
 
 
-@router.get("/new", response_model=ApiResponse)
-def get_model_list_new(
-    type: Optional[list[str]] = Query(None, description="模型类型筛选（支持多个，如 ?type=LLM 或 ?type=LLM,EMBEDDING）"),
-    provider: Optional[model_schema.ModelProvider] = Query(None, description="提供商筛选(基于ModelConfig)"),
-    is_active: Optional[bool] = Query(None, description="激活状态筛选"),
-    is_public: Optional[bool] = Query(None, description="公开状态筛选"),
-    search: Optional[str] = Query(None, description="搜索关键词"),
-    is_composite: Optional[bool] = Query(None, description="组合模型筛选"),
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """
-    获取模型配置列表
-    
-    支持多个 type 参数：
-    - 单个：?type=LLM
-    - 多个（逗号分隔）：?type=LLM,EMBEDDING
-    - 多个（重复参数）：?type=LLM&type=EMBEDDING
-    """
-    api_logger.info(f"获取模型配置列表请求: type={type}, provider={provider}, tenant_id={current_user.tenant_id}")
-    
-    try:
-        # 解析 type 参数（支持逗号分隔）
-        type_list = []
-        if type is not None:
-            flat_type = []
-            for item in type:
-                split_items = [t.strip() for t in item.split(',') if t.strip()]
-                flat_type.extend(split_items)
-
-            unique_flat_type = list(dict.fromkeys(flat_type))
-            type_list = [ModelType(t.lower()) for t in unique_flat_type]
-        
-        api_logger.info(f"获取模型type_list: {type_list}")
-        query = model_schema.ModelConfigQueryNew(
-            type=type_list,
-            provider=provider,
-            is_active=is_active,
-            is_public=is_public,
-            is_composite=is_composite,
-            search=search
-        )
-        
-        api_logger.debug(f"开始获取模型配置列表: {query.model_dump()}")
-        result = ModelConfigService.get_model_list_new(db=db, query=query, tenant_id=current_user.tenant_id)
-        api_logger.info(f"模型配置列表获取成功: 分组数={len(result)}, 总模型数={sum(len(item['models']) for item in result)}")
-        return success(data=result, msg="模型配置列表获取成功")
-    except Exception as e:
-        api_logger.error(f"获取模型配置列表失败: {str(e)}")
-        raise
-
-
-@router.get("/model_plaza", response_model=ApiResponse)
-def get_model_plaza_list(
-    type: Optional[ModelType] = Query(None, description="模型类型"),
-    provider: Optional[ModelProvider] = Query(None, description="供应商"),
-    is_official: Optional[bool] = Query(None, description="是否官方模型"),
-    is_deprecated: Optional[bool] = Query(None, description="是否弃用"),
-    search: Optional[str] = Query(None, description="搜索关键词"),
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """模型广场查询接口（按供应商分组）"""
-    
-    query = model_schema.ModelBaseQuery(
-        type=type,
-        provider=provider,
-        is_official=is_official,
-        is_deprecated=is_deprecated,
-        search=search
-    )
-    result = ModelBaseService.get_model_base_list(db=db, query=query, tenant_id=current_user.tenant_id)
-    return success(data=result, msg="模型广场列表获取成功")
-
-
-@router.get("/model_plaza/{model_base_id}", response_model=ApiResponse)
-def get_model_base_by_id(
-    model_base_id: uuid.UUID,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """获取基础模型详情"""
-    
-    result = ModelBaseService.get_model_base_by_id(db=db, model_base_id=model_base_id)
-    return success(data=model_schema.ModelBase.model_validate(result), msg="基础模型获取成功")
-
-
-@router.post("/model_plaza", response_model=ApiResponse)
-def create_model_base(
-    data: model_schema.ModelBaseCreate,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """创建基础模型"""
-    
-    result = ModelBaseService.create_model_base(db=db, data=data)
-    return success(data=model_schema.ModelBase.model_validate(result), msg="基础模型创建成功")
-
-
-@router.put("/model_plaza/{model_base_id}", response_model=ApiResponse)
-def update_model_base(
-    model_base_id: uuid.UUID,
-    data: model_schema.ModelBaseUpdate,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """更新基础模型"""
-    
-    # 不允许更改type类型
-    if data.type is not None or data.provider is not None:
-        raise BusinessException("不允许更改模型类型和供应商", BizCode.INVALID_PARAMETER)
-    
-    result = ModelBaseService.update_model_base(db=db, model_base_id=model_base_id, data=data)
-    return success(data=model_schema.ModelBase.model_validate(result), msg="基础模型更新成功")
-
-
-@router.delete("/model_plaza/{model_base_id}", response_model=ApiResponse)
-def delete_model_base(
-    model_base_id: uuid.UUID,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """删除基础模型"""
-    
-    ModelBaseService.delete_model_base(db=db, model_base_id=model_base_id)
-    return success(msg="基础模型删除成功")
-
-
-@router.post("/model_plaza/{model_base_id}/add", response_model=ApiResponse)
-def add_model_from_plaza(
-    model_base_id: uuid.UUID,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """从模型广场添加模型到模型列表"""
-    
-    result = ModelBaseService.add_model_from_plaza(db=db, model_base_id=model_base_id, tenant_id=current_user.tenant_id)
-    return success(data=model_schema.ModelConfig.model_validate(result), msg="模型添加成功")
-
-
 @router.get("/{model_id}", response_model=ApiResponse)
 def get_model_by_id(
     model_id: uuid.UUID,
@@ -290,73 +138,6 @@ async def create_model(
         raise
 
 
-@router.post("/composite", response_model=ApiResponse)
-async def create_composite_model(
-    model_data: model_schema.CompositeModelCreate,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """
-    创建组合模型
-    
-    - 绑定一个或多个现有的 API Key
-    - 所有 API Key 必须来自非组合模型
-    - 所有 API Key 关联的模型类型必须与组合模型类型一致
-    """
-    api_logger.info(f"创建组合模型请求: {model_data.name}, 用户: {current_user.username}, tenant_id={current_user.tenant_id}")
-    
-    try:
-        result_orm = await ModelConfigService.create_composite_model(db=db, model_data=model_data, tenant_id=current_user.tenant_id)
-        api_logger.info(f"组合模型创建成功: {result_orm.name} (ID: {result_orm.id})")
-        
-        result = model_schema.ModelConfig.model_validate(result_orm)
-        return success(data=result, msg="组合模型创建成功")
-    except Exception as e:
-        api_logger.error(f"创建组合模型失败: {model_data.name} - {str(e)}")
-        raise
-
-
-@router.put("/composite/{model_id}", response_model=ApiResponse)
-async def update_composite_model(
-    model_id: uuid.UUID,
-    model_data: model_schema.CompositeModelCreate,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """更新组合模型"""
-    api_logger.info(f"更新组合模型请求: model_id={model_id}, 用户: {current_user.username}")
-    
-    try:
-        if model_data.type is not None:
-            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})")
-        
-        result = model_schema.ModelConfig.model_validate(result_orm)
-        return success(data=result, msg="组合模型更新成功")
-    except Exception as e:
-        api_logger.error(f"更新组合模型失败: model_id={model_id} - {str(e)}")
-        raise
-
-
-@router.delete("/composite/{model_id}", response_model=ApiResponse)
-def delete_composite_model(
-    model_id: uuid.UUID,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """删除组合模型"""
-    api_logger.info(f"删除组合模型请求: model_id={model_id}, 用户: {current_user.username}")
-    
-    try:
-        ModelConfigService.delete_model(db=db, model_id=model_id, tenant_id=current_user.tenant_id)
-        api_logger.info(f"组合模型删除成功: model_id={model_id}")
-        return success(msg="组合模型删除成功")
-    except Exception as e:
-        api_logger.error(f"删除组合模型失败: model_id={model_id} - {str(e)}")
-        raise
-
-
 @router.put("/{model_id}", response_model=ApiResponse)
 def update_model(
     model_id: uuid.UUID,
@@ -368,14 +149,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)
-
-    if model_data.is_active:
-        active_keys = ModelApiKeyService.get_api_keys_by_model(db=db, model_config_id=model_id, is_active=model_data.is_active)
-        if not active_keys:
-            raise BusinessException("请先为该模型配置可用的 API Key", BizCode.INVALID_PARAMETER)
     
     try:
         api_logger.debug(f"开始更新模型配置: model_id={model_id}")
@@ -441,55 +214,6 @@ def get_model_api_keys(
         raise
 
 
-@router.post("/provider/apikeys", response_model=ApiResponse)
-async def create_model_api_key_by_provider(
-        api_key_data: model_schema.ModelApiKeyCreateByProvider,
-        db: Session = Depends(get_db),
-        current_user: User = Depends(get_current_user)
-):
-    """
-    根据供应商为所有匹配的模型创建API Key
-    """
-    api_logger.info(f"创建API Key请求: provider={api_key_data.provider}, 用户: {current_user.username}")
-
-    try:
-        # 根据tenant_id和provider筛选model_config_id列表
-        model_config_ids = api_key_data.model_config_ids
-        if not model_config_ids:
-            model_config_ids = ModelConfigRepository.get_model_config_ids_by_provider(
-                db=db,
-                tenant_id=current_user.tenant_id,
-                provider=api_key_data.provider
-            )
-        
-        if not model_config_ids:
-            raise BusinessException(f"未找到供应商 {api_key_data.provider} 的模型配置", BizCode.MODEL_NOT_FOUND)
-        
-        # 构造schema并调用service
-        create_data = model_schema.ModelApiKeyCreateByProvider(
-            provider=api_key_data.provider,
-            api_key=api_key_data.api_key,
-            api_base=api_key_data.api_base,
-            description=api_key_data.description,
-            config=api_key_data.config,
-            is_active=api_key_data.is_active,
-            priority=api_key_data.priority,
-            model_config_ids=model_config_ids,
-            capability=api_key_data.capability,
-            is_omni=api_key_data.is_omni
-        )
-        created_keys, failed_models = await ModelApiKeyService.create_api_key_by_provider(db=db, data=create_data)
-        
-        api_logger.info(f"API Key创建成功: 关联{len(created_keys)}个模型")
-        # result_list = [model_schema.ModelApiKey.model_validate(key) for key in created_keys]
-        result = "API Key已存在" if len(created_keys) == 0 and len(failed_models) == 0 else \
-            f"成功为 {len(created_keys)} 个模型创建API Key, 失败模型列表{failed_models}"
-        return success(data=result, msg=f"成功为 {len(created_keys)} 个模型创建API Key")
-    except Exception as e:
-        api_logger.error(f"创建API Key失败: {str(e)}")
-        raise
-
-
 @router.post("/{model_id}/apikeys", response_model=ApiResponse, status_code=status.HTTP_201_CREATED)
 async def create_model_api_key(
     model_id: uuid.UUID,
@@ -504,12 +228,11 @@ async def create_model_api_key(
     
     try:
         # 设置模型配置ID
-        api_key_data.model_config_ids = [model_id]
+        api_key_data.model_config_id = model_id
         
         api_logger.debug(f"开始创建模型API Key: {api_key_data.model_name}")
-        result_orm = await ModelApiKeyService.create_api_key(db=db, api_key_data=api_key_data)
-        api_logger.info(f"模型API Key创建成功: {result_orm.model_name} (ID: {result_orm.id})")
-        result = model_schema.ModelApiKey.model_validate(result_orm)
+        result = await ModelApiKeyService.create_api_key(db=db, api_key_data=api_key_data)
+        api_logger.info(f"模型API Key创建成功: {result.model_name} (ID: {result.id})")
         return success(data=result, msg="模型API Key创建成功")
     except Exception as e:
         api_logger.error(f"创建模型API Key失败: {api_key_data.model_name} - {str(e)}")
@@ -611,3 +334,5 @@ async def validate_model_config(
     return success(data=model_schema.ModelValidateResponse(**result), msg="验证完成")
 
 
+
+

api/app/controllers/ontology_secondary_routes.py

@@ -1,663 +0,0 @@
-# -*- coding: utf-8 -*-
-"""本体场景和类型路由（续）
-
-由于主Controller文件较大，将剩余路由放在此文件中。
-"""
-
-from uuid import UUID
-from typing import Optional
-
-from fastapi import Depends, Header
-from sqlalchemy.orm import Session
-
-from app.core.error_codes import BizCode
-from app.core.logging_config import get_api_logger, get_business_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.schemas.ontology_schemas import (
-    SceneResponse,
-    SceneListResponse,
-    PaginationInfo,
-    ClassCreateRequest,
-    ClassUpdateRequest,
-    ClassResponse,
-    ClassListResponse,
-    ClassBatchCreateResponse,
-)
-from app.schemas.response_schema import ApiResponse
-from app.services.ontology_service import OntologyService
-from app.core.memory.llm_tools.openai_client import OpenAIClient
-from app.core.models.base import RedBearModelConfig
-from app.repositories.ontology_class_repository import OntologyClassRepository
-
-
-api_logger = get_api_logger()
-business_logger = get_business_logger()
-
-
-def _get_dummy_ontology_service(db: Session) -> OntologyService:
-    """获取OntologyService实例（不需要LLM）
-    
-    场景和类型管理不需要LLM，创建一个dummy配置。
-    """
-    dummy_config = RedBearModelConfig(
-        model_name="dummy",
-        provider="openai",
-        api_key="dummy",
-        base_url="https://api.openai.com/v1"
-    )
-    llm_client = OpenAIClient(model_config=dummy_config)
-    return OntologyService(llm_client=llm_client, db=db)
-
-
-# 这些函数将被导入到主Controller中
-
-async def scenes_handler(
-    workspace_id: Optional[str] = None,
-    scene_name: Optional[str] = None,
-    page: Optional[int] = None,
-    pagesize: Optional[int] = None,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """获取场景列表（支持模糊搜索和全量查询，全量查询支持分页）
-    
-    当提供 scene_name 参数时，进行模糊搜索（不分页）；
-    当不提供 scene_name 参数时，返回所有场景（支持分页）。
-    
-    Args:
-        workspace_id: 工作空间ID（可选，默认当前用户工作空间）
-        scene_name: 场景名称关键词（可选，支持模糊匹配）
-        page: 页码（可选，从1开始，仅在全量查询时有效）
-        pagesize: 每页数量（可选，仅在全量查询时有效）
-        db: 数据库会话
-        current_user: 当前用户
-    """
-    operation = "search" if scene_name else "list"
-    api_logger.info(
-        f"Scene {operation} requested by user {current_user.id}, "
-        f"workspace_id={workspace_id}, keyword={scene_name}, page={page}, pagesize={pagesize}"
-    )
-    
-    try:
-        # 确定工作空间ID
-        if workspace_id:
-            try:
-                ws_uuid = UUID(workspace_id)
-            except ValueError:
-                api_logger.warning(f"Invalid workspace_id format: {workspace_id}")
-                return fail(BizCode.BAD_REQUEST, "请求参数无效", "无效的工作空间ID格式")
-        else:
-            ws_uuid = current_user.current_workspace_id
-            if not ws_uuid:
-                api_logger.warning(f"User {current_user.id} has no current workspace")
-                return fail(BizCode.BAD_REQUEST, "请求参数无效", "当前用户没有工作空间")
-        
-        # 创建Service
-        service = _get_dummy_ontology_service(db)
-        
-        # 根据是否提供 scene_name 决定查询方式
-        if scene_name and scene_name.strip():
-            # 验证分页参数（模糊搜索也支持分页）
-            if page is not None and page < 1:
-                api_logger.warning(f"Invalid page number: {page}")
-                return fail(BizCode.BAD_REQUEST, "请求参数无效", "页码必须大于0")
-            
-            if pagesize is not None and pagesize < 1:
-                api_logger.warning(f"Invalid pagesize: {pagesize}")
-                return fail(BizCode.BAD_REQUEST, "请求参数无效", "每页数量必须大于0")
-            
-            # 如果只提供了page或pagesize中的一个，返回错误
-            if (page is not None and pagesize is None) or (page is None and pagesize is not None):
-                api_logger.warning(f"Incomplete pagination params: page={page}, pagesize={pagesize}")
-                return fail(BizCode.BAD_REQUEST, "请求参数无效", "分页参数page和pagesize必须同时提供")
-            
-            # 模糊搜索场景（支持分页）
-            scenes = service.search_scenes_by_name(scene_name.strip(), ws_uuid)
-            total = len(scenes)
-            
-            # 如果提供了分页参数，进行分页处理
-            if page is not None and pagesize is not None:
-                start_idx = (page - 1) * pagesize
-                end_idx = start_idx + pagesize
-                scenes = scenes[start_idx:end_idx]
-            
-            # 构建响应
-            items = []
-            for scene in scenes:
-                entity_type = [cls.class_name for cls in scene.classes[:3]] if scene.classes else None
-                type_num = len(scene.classes) if scene.classes else 0
-                
-                items.append(SceneResponse(
-                    scene_id=scene.scene_id,
-                    scene_name=scene.scene_name,
-                    scene_description=scene.scene_description,
-                    type_num=type_num,
-                    entity_type=entity_type,
-                    workspace_id=scene.workspace_id,
-                    created_at=scene.created_at,
-                    updated_at=scene.updated_at,
-                    classes_count=type_num,
-                    is_system_default=scene.is_system_default
-                ))
-            
-            # 构建响应（包含分页信息）
-            if page is not None and pagesize is not None:
-                hasnext = (page * pagesize) < total
-                pagination_info = PaginationInfo(
-                    page=page,
-                    pagesize=pagesize,
-                    total=total,
-                    hasnext=hasnext
-                )
-                response = SceneListResponse(items=items, page=pagination_info)
-            else:
-                response = SceneListResponse(items=items)
-            
-            api_logger.info(
-                f"Scene search completed: found {len(items)} scenes matching '{scene_name}' "
-                f"in workspace {ws_uuid}, total={total}"
-            )
-        else:
-            # 获取所有场景（支持分页）
-            if page is not None and page < 1:
-                api_logger.warning(f"Invalid page number: {page}")
-                return fail(BizCode.BAD_REQUEST, "请求参数无效", "页码必须大于0")
-            
-            if pagesize is not None and pagesize < 1:
-                api_logger.warning(f"Invalid pagesize: {pagesize}")
-                return fail(BizCode.BAD_REQUEST, "请求参数无效", "每页数量必须大于0")
-            
-            # 如果只提供了page或pagesize中的一个，返回错误
-            if (page is not None and pagesize is None) or (page is None and pagesize is not None):
-                api_logger.warning(f"Incomplete pagination params: page={page}, pagesize={pagesize}")
-                return fail(BizCode.BAD_REQUEST, "请求参数无效", "分页参数page和pagesize必须同时提供")
-            
-            scenes, total = service.list_scenes(ws_uuid, page, pagesize)
-            
-            # 构建响应
-            items = []
-            for scene in scenes:
-                entity_type = [cls.class_name for cls in scene.classes[:3]] if scene.classes else None
-                type_num = len(scene.classes) if scene.classes else 0
-                
-                items.append(SceneResponse(
-                    scene_id=scene.scene_id,
-                    scene_name=scene.scene_name,
-                    scene_description=scene.scene_description,
-                    type_num=type_num,
-                    entity_type=entity_type,
-                    workspace_id=scene.workspace_id,
-                    created_at=scene.created_at,
-                    updated_at=scene.updated_at,
-                    classes_count=type_num,
-                    is_system_default=scene.is_system_default
-                ))
-            
-            # 构建响应（包含分页信息）
-            if page is not None and pagesize is not None:
-                hasnext = (page * pagesize) < total
-                pagination_info = PaginationInfo(
-                    page=page,
-                    pagesize=pagesize,
-                    total=total,
-                    hasnext=hasnext
-                )
-                response = SceneListResponse(items=items, page=pagination_info)
-            else:
-                response = SceneListResponse(items=items)
-            
-            api_logger.info(f"Scene list retrieved successfully, count={len(items)}, total={total}")
-        
-        return success(data=response.model_dump(mode='json'), msg="查询成功")
-        
-    except ValueError as e:
-        api_logger.warning(f"Validation error in scene {operation}: {str(e)}")
-        return fail(BizCode.BAD_REQUEST, "请求参数无效", str(e))
-        
-    except RuntimeError as e:
-        api_logger.error(f"Runtime error in scene {operation}: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "查询失败", str(e))
-        
-    except Exception as e:
-        api_logger.error(f"Unexpected error in scene {operation}: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "查询失败", str(e))
-
-
-# ==================== 本体类型管理接口 ====================
-
-async def create_class_handler(
-    request: ClassCreateRequest,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-    x_language_type: Optional[str] = None
-):
-    """创建本体类型（统一使用列表形式，支持单个或批量）"""
-    
-    # 根据列表长度判断是单个还是批量
-    count = len(request.classes)
-    mode = "single" if count == 1 else "batch"
-    
-    api_logger.info(
-        f"Class creation ({mode}) requested by user {current_user.id}, "
-        f"scene_id={request.scene_id}, count={count}"
-    )
-    
-    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, "请求参数无效", "当前用户没有工作空间")
-        
-        # 创建Service
-        service = _get_dummy_ontology_service(db)
-        
-        # 准备类型数据
-        classes_data = [
-            {
-                "class_name": item.class_name,
-                "class_description": item.class_description
-            }
-            for item in request.classes
-        ]
-        
-        if count == 1:
-            # 单个创建 - 先检查重名
-            class_data = classes_data[0]
-            existing = OntologyClassRepository(db).get_by_name(class_data["class_name"], request.scene_id)
-            if existing:
-                raise ValueError(f"DUPLICATE_CLASS_NAME:{class_data['class_name']}")
-            ontology_class = service.create_class(
-                scene_id=request.scene_id,
-                class_name=class_data["class_name"],
-                class_description=class_data["class_description"],
-                workspace_id=workspace_id
-            )
-            
-            # 构建单个响应
-            response = 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
-            )
-            
-            api_logger.info(f"Class created successfully: {ontology_class.class_id}")
-            
-            return success(data=response.model_dump(mode='json'), msg="类型创建成功")
-            
-        else:
-            # 批量创建
-            created_classes, errors = service.create_classes_batch(
-                scene_id=request.scene_id,
-                classes=classes_data,
-                workspace_id=workspace_id
-            )
-            
-            # 构建批量响应
-            items = []
-            for ontology_class in created_classes:
-                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
-                ))
-            
-            response = ClassBatchCreateResponse(
-                total=len(classes_data),
-                success_count=len(created_classes),
-                failed_count=len(errors),
-                items=items,
-                errors=errors if errors else None
-            )
-            
-            api_logger.info(
-                f"Batch class creation completed: "
-                f"success={len(created_classes)}, failed={len(errors)}"
-            )
-            
-            return success(data=response.model_dump(mode='json'), msg="批量创建完成")
-        
-    except ValueError as e:
-        err_str = str(e)
-        if err_str.startswith("DUPLICATE_CLASS_NAME:"):
-            class_name = err_str.split(":", 1)[1]
-            api_logger.warning(f"Duplicate class name '{class_name}' in scene {request.scene_id}")
-            from app.core.language_utils import get_language_from_header
-            from fastapi.responses import JSONResponse
-            lang = get_language_from_header(x_language_type)
-            if lang == "en":
-                msg = fail(BizCode.BAD_REQUEST, "Class name already exists", f"A class named \"{class_name}\" already exists in this scene. Please use a different name.")
-            else:
-                msg = fail(BizCode.BAD_REQUEST, "类型名称已存在", f"当前场景下已存在名为「{class_name}」的类型，请使用其他名称")
-            return JSONResponse(status_code=400, content=msg)
-        api_logger.warning(f"Validation error in class creation: {err_str}")
-        return fail(BizCode.BAD_REQUEST, "请求参数无效", err_str)
-
-    except RuntimeError as e:
-        err_str = str(e)
-        if "UniqueViolation" in err_str or "uq_scene_class_name" in err_str:
-            api_logger.warning(f"Duplicate class name in scene {request.scene_id}")
-            from app.core.language_utils import get_language_from_header
-            from fastapi.responses import JSONResponse
-            lang = get_language_from_header(x_language_type)
-            class_name = request.classes[0].class_name if request.classes else ""
-            if lang == "en":
-                msg = fail(BizCode.BAD_REQUEST, "Class name already exists", f"A class named \"{class_name}\" already exists in this scene. Please use a different name.")
-            else:
-                msg = fail(BizCode.BAD_REQUEST, "类型名称已存在", f"当前场景下已存在名为「{class_name}」的类型，请使用其他名称")
-            return JSONResponse(status_code=400, content=msg)
-        api_logger.error(f"Runtime error in class creation: {err_str}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "类型创建失败", err_str)
-        
-    except Exception as e:
-        api_logger.error(f"Unexpected error in class creation: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "类型创建失败", str(e))
-
-
-async def update_class_handler(
-    class_id: str,
-    request: ClassUpdateRequest,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """更新本体类型"""
-    api_logger.info(
-        f"Class update requested by user {current_user.id}, "
-        f"class_id={class_id}"
-    )
-    
-    try:
-        # 验证UUID格式
-        try:
-            class_uuid = UUID(class_id)
-        except ValueError:
-            api_logger.warning(f"Invalid class_id format: {class_id}")
-            return fail(BizCode.BAD_REQUEST, "请求参数无效", "无效的类型ID格式")
-        
-        # 获取当前工作空间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, "请求参数无效", "当前用户没有工作空间")
-        
-        # 检查是否为系统默认类型
-        class_repo = OntologyClassRepository(db)
-        ontology_class = class_repo.get_by_id(class_uuid)
-        if ontology_class and ontology_class.is_system_default:
-            business_logger.warning(
-                f"尝试修改系统默认类型: user_id={current_user.id}, "
-                f"class_id={class_id}, class_name={ontology_class.class_name}"
-            )
-            return fail(
-                BizCode.BAD_REQUEST,
-                "系统默认类型不可修改",
-                "该类型为系统预设类型，不允许修改"
-            )
-        
-        # 创建Service
-        service = _get_dummy_ontology_service(db)
-        
-        # 更新类型
-        ontology_class = service.update_class(
-            class_id=class_uuid,
-            class_name=request.class_name,
-            class_description=request.class_description,
-            workspace_id=workspace_id
-        )
-        
-        # 构建响应
-        response = 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
-        )
-        
-        api_logger.info(f"Class updated successfully: {class_id}")
-        
-        return success(data=response.model_dump(mode='json'), msg="类型更新成功")
-        
-    except ValueError as e:
-        api_logger.warning(f"Validation error in class update: {str(e)}")
-        return fail(BizCode.BAD_REQUEST, "请求参数无效", str(e))
-        
-    except RuntimeError as e:
-        api_logger.error(f"Runtime error in class update: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "类型更新失败", str(e))
-        
-    except Exception as e:
-        api_logger.error(f"Unexpected error in class update: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "类型更新失败", str(e))
-
-
-async def delete_class_handler(
-    class_id: str,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """删除本体类型"""
-    api_logger.info(
-        f"Class deletion requested by user {current_user.id}, "
-        f"class_id={class_id}"
-    )
-    
-    try:
-        # 验证UUID格式
-        try:
-            class_uuid = UUID(class_id)
-        except ValueError:
-            api_logger.warning(f"Invalid class_id format: {class_id}")
-            return fail(BizCode.BAD_REQUEST, "请求参数无效", "无效的类型ID格式")
-        
-        # 获取当前工作空间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, "请求参数无效", "当前用户没有工作空间")
-        
-        # 检查是否为系统默认类型
-        class_repo = OntologyClassRepository(db)
-        ontology_class = class_repo.get_by_id(class_uuid)
-        if ontology_class and ontology_class.is_system_default:
-            business_logger.warning(
-                f"尝试删除系统默认类型: user_id={current_user.id}, "
-                f"class_id={class_id}, class_name={ontology_class.class_name}"
-            )
-            return fail(
-                BizCode.BAD_REQUEST,
-                "系统默认类型不可删除",
-                "该类型为系统预设类型，不允许删除"
-            )
-        
-        # 创建Service
-        service = _get_dummy_ontology_service(db)
-        
-        # 删除类型
-        success_flag = service.delete_class(
-            class_id=class_uuid,
-            workspace_id=workspace_id
-        )
-        
-        api_logger.info(f"Class deleted successfully: {class_id}")
-        
-        return success(data={"deleted": success_flag}, msg="类型删除成功")
-        
-    except ValueError as e:
-        api_logger.warning(f"Validation error in class deletion: {str(e)}")
-        return fail(BizCode.BAD_REQUEST, "请求参数无效", str(e))
-        
-    except RuntimeError as e:
-        api_logger.error(f"Runtime error in class deletion: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "类型删除失败", str(e))
-        
-    except Exception as e:
-        api_logger.error(f"Unexpected error in class deletion: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "类型删除失败", str(e))
-
-
-async def get_class_handler(
-    class_id: str,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """获取单个本体类型"""
-    api_logger.info(
-        f"Get class requested by user {current_user.id}, "
-        f"class_id={class_id}"
-    )
-    
-    try:
-        # 验证UUID格式
-        try:
-            class_uuid = UUID(class_id)
-        except ValueError:
-            api_logger.warning(f"Invalid class_id format: {class_id}")
-            return fail(BizCode.BAD_REQUEST, "请求参数无效", "无效的类型ID格式")
-        
-        # 获取当前工作空间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, "请求参数无效", "当前用户没有工作空间")
-        
-        # 创建Service
-        service = _get_dummy_ontology_service(db)
-        
-        # 获取类型（会抛出ValueError如果不存在）
-        ontology_class = service.get_class_by_id(class_uuid, workspace_id)
-        
-        # 构建响应
-        response = 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
-        )
-        
-        api_logger.info(f"Class retrieved successfully: {class_id}")
-        
-        return success(data=response.model_dump(mode='json'), msg="查询成功")
-        
-    except ValueError as e:
-        # 类型不存在或无权限访问
-        api_logger.warning(f"Validation error in get class: {str(e)}")
-        return fail(BizCode.NOT_FOUND, "请求参数无效", str(e))
-        
-    except RuntimeError as e:
-        api_logger.error(f"Runtime error in get class: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "查询失败", str(e))
-        
-    except Exception as e:
-        api_logger.error(f"Unexpected error in get class: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "查询失败", str(e))
-
-
-async def classes_handler(
-    scene_id: str,
-    class_name: Optional[str] = None,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
-):
-    """获取类型列表（支持模糊搜索和全量查询）
-    
-    当提供 class_name 参数时，进行模糊搜索；
-    当不提供 class_name 参数时，返回场景下的所有类型。
-    
-    Args:
-        scene_id: 场景ID（必填）
-        class_name: 类型名称关键词（可选，支持模糊匹配）
-        db: 数据库会话
-        current_user: 当前用户
-    """
-    operation = "search" if class_name else "list"
-    api_logger.info(
-        f"Class {operation} requested by user {current_user.id}, "
-        f"keyword={class_name}, scene_id={scene_id}"
-    )
-    
-    try:
-        # 验证UUID格式
-        try:
-            scene_uuid = UUID(scene_id)
-        except ValueError:
-            api_logger.warning(f"Invalid scene_id format: {scene_id}")
-            return fail(BizCode.BAD_REQUEST, "请求参数无效", "无效的场景ID格式")
-        
-        # 获取当前工作空间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, "请求参数无效", "当前用户没有工作空间")
-        
-        # 创建Service
-        service = _get_dummy_ontology_service(db)
-        
-        # 获取场景信息
-        scene = service.get_scene_by_id(scene_uuid, workspace_id)
-        if not scene:
-            api_logger.warning(f"Scene not found: {scene_id}")
-            return fail(BizCode.NOT_FOUND, "场景不存在", f"未找到ID为 {scene_id} 的场景")
-        
-        # 根据是否提供 class_name 决定查询方式
-        if class_name and class_name.strip():
-            # 模糊搜索类型
-            classes = service.search_classes_by_name(class_name.strip(), scene_uuid, workspace_id)
-        else:
-            # 获取所有类型
-            classes = service.list_classes_by_scene(scene_uuid, workspace_id)
-        
-        # 构建响应
-        items = []
-        for ontology_class in classes:
-            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
-            ))
-        
-        response = ClassListResponse(
-            total=len(items),
-            scene_id=scene_uuid,
-            scene_name=scene.scene_name,
-            scene_description=scene.scene_description,
-            is_system_default=scene.is_system_default,
-            items=items
-        )
-        
-        if class_name:
-            api_logger.info(
-                f"Class search completed: found {len(items)} classes matching '{class_name}' "
-                f"in scene {scene_id}"
-            )
-        else:
-            api_logger.info(f"Class list retrieved successfully, count={len(items)}")
-        
-        return success(data=response.model_dump(mode='json'), msg="查询成功")
-        
-    except ValueError as e:
-        api_logger.warning(f"Validation error in class {operation}: {str(e)}")
-        return fail(BizCode.BAD_REQUEST, "请求参数无效", str(e))
-        
-    except RuntimeError as e:
-        api_logger.error(f"Runtime error in class {operation}: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "查询失败", str(e))
-        
-    except Exception as e:
-        api_logger.error(f"Unexpected error in class {operation}: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "查询失败", str(e))

api/app/controllers/prompt_optimizer_controller.py

@@ -1,5 +1,5 @@
-import json
 import uuid
+import json
 
 from fastapi import APIRouter, Depends, Path
 from sqlalchemy.orm import Session
@@ -8,13 +8,9 @@ from starlette.responses import StreamingResponse
 from app.core.logging_config import get_api_logger
 from app.core.response_utils import success
 from app.dependencies import get_current_user, get_db
-from app.schemas.prompt_optimizer_schema import (
-    PromptOptMessage,
-    CreateSessionResponse,
-    SessionHistoryResponse,
-    SessionMessage,
-    PromptSaveRequest
-)
+from app.models.prompt_optimizer_model import RoleType
+from app.schemas.prompt_optimizer_schema import PromptOptMessage, PromptOptModelSet, CreateSessionResponse, \
+    OptimizePromptResponse, SessionHistoryResponse, SessionMessage
 from app.schemas.response_schema import ApiResponse
 from app.services.prompt_optimizer_service import PromptOptimizerService
 
@@ -120,8 +116,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"
@@ -140,109 +135,3 @@ async def get_prompt_opt(
             "X-Accel-Buffering": "no"
         }
     )
-
-
-@router.post(
-    "/releases",
-    summary="Get prompt optimization",
-    response_model=ApiResponse
-)
-def save_prompt(
-        data: PromptSaveRequest,
-        db: Session = Depends(get_db),
-        current_user=Depends(get_current_user),
-):
-    """
-       Save a prompt release for the current tenant.
-
-       Args:
-           data (PromptSaveRequest): Request body containing session_id, title, and prompt.
-           db (Session): SQLAlchemy database session, injected via dependency.
-           current_user: Currently authenticated user object, injected via dependency.
-
-       Returns:
-           ApiResponse: Standard API response containing the saved prompt release info:
-               - id: UUID of the prompt release
-               - session_id: associated session
-               - title: prompt title
-               - prompt: prompt content
-               - created_at: timestamp of creation
-
-       Raises:
-           Any database or service exceptions are propagated to the global exception handler.
-       """
-    service = PromptOptimizerService(db)
-    prompt_info = service.save_prompt(
-        tenant_id=current_user.tenant_id,
-        session_id=data.session_id,
-        title=data.title,
-        prompt=data.prompt
-    )
-    return success(data=prompt_info)
-
-
-@router.delete(
-    "/releases/{prompt_id}",
-    summary="Delete prompt (soft delete)",
-    response_model=ApiResponse
-)
-def delete_prompt(
-        prompt_id: uuid.UUID = Path(..., description="Prompt ID"),
-        db: Session = Depends(get_db),
-        current_user=Depends(get_current_user),
-):
-    """
-    Soft delete a prompt release.
-
-    Args:
-        prompt_id
-        db (Session): Database session
-        current_user: Current logged-in user
-
-    Returns:
-        ApiResponse: Success message confirming deletion
-    """
-    service = PromptOptimizerService(db)
-    service.delete_prompt(
-        tenant_id=current_user.tenant_id,
-        prompt_id=prompt_id
-    )
-    return success(msg="Prompt deleted successfully")
-
-
-@router.get(
-    "/releases/list",
-    summary="Get paginated list of released prompts with optional filter",
-    response_model=ApiResponse
-)
-def get_release_list(
-        page: int = 1,
-        page_size: int = 20,
-        keyword: str | None = None,
-        db: Session = Depends(get_db),
-        current_user=Depends(get_current_user),
-):
-    """
-    Retrieve paginated list of released prompts for the current tenant.
-    Optionally filter by keyword in title.
-
-    Args:
-        page (int): Page number (starting from 1)
-        page_size (int): Number of items per page (max 100)
-        keyword (str | None): Optional keyword to filter prompt titles
-        db (Session): Database session
-        current_user: Current logged-in user
-
-    Returns:
-        ApiResponse: Contains paginated list of prompt releases with metadata
-    """
-    service = PromptOptimizerService(db)
-    result = service.get_release_list(
-        tenant_id=current_user.tenant_id,
-        page=max(1, page),
-        page_size=min(max(1, page_size), 100),
-        filter_keyword=keyword
-    )
-    return success(data=result)
-
-

api/app/controllers/public_share_controller.py

@@ -2,32 +2,25 @@ import hashlib
 import json
 import uuid
 from typing import Annotated
-
 from fastapi import APIRouter, Depends, Query, Request
 from fastapi.responses import StreamingResponse
 from sqlalchemy.orm import Session
 
-from app.core.error_codes import BizCode
-from app.core.exceptions import BusinessException
 from app.core.logging_config import get_business_logger
-from app.core.response_utils import success, fail
+from app.core.response_utils import success
 from app.db import get_db, get_db_read
 from app.dependencies import get_share_user_id, ShareTokenData
-from app.models.app_model import App
-from app.models.app_model import AppType
 from app.repositories import knowledge_repository
-from app.repositories.end_user_repository import EndUserRepository
 from app.repositories.workflow_repository import WorkflowConfigRepository
 from app.schemas import release_share_schema, conversation_schema
 from app.schemas.response_schema import PageData, PageMeta
 from app.services import workspace_service
-from app.services.app_chat_service import AppChatService, get_app_chat_service
 from app.services.auth_service import create_access_token
 from app.services.conversation_service import ConversationService
 from app.services.release_share_service import ReleaseShareService
 from app.services.shared_chat_service import SharedChatService
-from app.services.workflow_service import WorkflowService
-from app.utils.app_config_utils import workflow_config_4_app_release, \
+from app.services.app_chat_service import AppChatService, get_app_chat_service
+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
 
 router = APIRouter(prefix="/public/share", tags=["Public Share"])
@@ -213,13 +206,15 @@ def list_conversations(
     logger.debug(f"share_data:{share_data.user_id}")
     other_id = share_data.user_id
     service = SharedChatService(db)
-    share, release = service.get_release_by_share_token(share_data.share_token, password)
+    share, release = service._get_release_by_share_token(share_data.share_token, password)
+    from app.repositories.end_user_repository import EndUserRepository
     end_user_repo = EndUserRepository(db)
     new_end_user = end_user_repo.get_or_create_end_user(
         app_id=share.app_id,
         other_id=other_id
     )
     logger.debug(new_end_user.id)
+    service = SharedChatService(db)
     conversations, total = service.list_conversations(
         share_token=share_data.share_token,
         user_id=str(new_end_user.id),
@@ -298,15 +293,19 @@ async def chat(
 
     # 提前验证和准备（在流式响应开始前完成）
     # 这样可以确保错误能正确返回，而不是在流式响应中间出错
-
+    from app.models.app_model import AppType
     try:
+        from app.core.exceptions import BusinessException
+        from app.core.error_codes import BizCode
+        from app.services.app_service import AppService
         # 验证分享链接和密码
-        share, release = service.get_release_by_share_token(share_token, password)
+        share, release = service._get_release_by_share_token(share_token, password)
 
         # # Create end_user_id by concatenating app_id with user_id
         # end_user_id = f"{share.app_id}_{user_id}"
 
         # Store end_user_id in database with original user_id
+        from app.repositories.end_user_repository import EndUserRepository
         end_user_repo = EndUserRepository(db)
         new_end_user = end_user_repo.get_or_create_end_user(
             app_id=share.app_id,
@@ -319,6 +318,7 @@ async def chat(
         """获取存储类型和工作空间的ID"""
 
         # 直接通过 SQLAlchemy 查询 app（仅查询未删除的应用）
+        from app.models.app_model import App
         app = db.query(App).filter(
             App.id == appid,
             App.is_active.is_(True)
@@ -359,12 +359,12 @@ async def chat(
         app_type = release.app.type if release.app else None
 
         # 根据应用类型验证配置
-        if app_type == AppType.AGENT:
+        if app_type == "agent":
             # Agent 类型：验证模型配置
             model_config_id = release.default_model_config_id
             if not model_config_id:
                 raise BusinessException("Agent 应用未配置模型", BizCode.AGENT_CONFIG_MISSING)
-        elif app_type == AppType.MULTI_AGENT:
+        elif app_type == "multi_agent":
             # Multi-Agent 类型：验证多 Agent 配置
             config = release.config or {}
             if not config.get("sub_agents"):
@@ -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", {})
@@ -638,34 +634,6 @@ async def chat(
         # return success(data=conversation_schema.ChatResponse(**result).model_dump(mode="json"))
 
     else:
+        from app.core.exceptions import BusinessException
+        from app.core.error_codes import BizCode
         raise BusinessException(f"不支持的应用类型: {app_type}", BizCode.APP_TYPE_NOT_SUPPORTED)
-
-
-@router.get("/config", summary="获取应用启动配置")
-async def config_query(
-        password: str = Query(None, description="访问密码"),
-        share_data: ShareTokenData = Depends(get_share_user_id),
-        db: Session = Depends(get_db),
-):
-    share_service = SharedChatService(db)
-    share_token = share_data.share_token
-    share, release = share_service.get_release_by_share_token(share_token, password)
-    if release.app.type == AppType.WORKFLOW:
-        workflow_service = WorkflowService(db)
-        content = {
-            "app_type": release.app.type,
-            "variables": workflow_service.get_start_node_variables(release.config)
-        }
-    elif release.app.type == AppType.AGENT:
-        content = {
-            "app_type": release.app.type,
-            "variables": release.config.get("variables")
-        }
-    elif release.app.type == AppType.MULTI_AGENT:
-        content = {
-            "app_type": release.app.type,
-            "variables": []
-        }
-    else:
-        return fail(msg="Unsupported app type", code=BizCode.APP_TYPE_NOT_SUPPORTED)
-    return success(data=content)

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,21 +73,21 @@ 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)
 
+    other_id = payload.user_id
     app = app_service.get_app(api_key_auth.resource_id, api_key_auth.workspace_id)
     other_id = payload.user_id
     workspace_id = app.workspace_id
@@ -99,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,
@@ -134,8 +133,7 @@ async def chat(
         app_id=app.id,
         workspace_id=workspace_id,
         user_id=end_user_id,
-        is_draft=False,
-        conversation_id=payload.conversation_id
+        is_draft=False
     )
 
     if app_type == AppType.AGENT:
@@ -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,20 +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,
-                        public=True
+
+                    message=payload.message,
+                    conversation_id=conversation.id,  # 使用已创建的会话 ID
+                    user_id=new_end_user.id,  # 转换为字符串
+                    variables=payload.variables,
+                    config=config,
+                    web_search=payload.web_search,
+                    memory=payload.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", {})
@@ -273,11 +268,11 @@ async def chat(
 
             message=payload.message,
             conversation_id=conversation.id,  # 使用已创建的会话 ID
-            user_id=end_user_id,  # 转换为字符串
+            user_id=new_end_user.id,  # 转换为字符串
             variables=payload.variables,
             config=config,
-            web_search=web_search,
-            memory=memory,
+            web_search=payload.web_search,
+            memory=payload.memory,
             storage_type=storage_type,
             user_rag_memory_id=user_rag_memory_id,
             app_id=app.id,
@@ -299,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/memory_api_controller.py

@@ -39,7 +39,7 @@ async def write_memory_api_service(
     
     Stores memory content for the specified end user using the Memory API Service.
     """
-    logger.info(f"Memory write request - end_user_id: {payload.end_user_id}, workspace_id: {api_key_auth.workspace_id}")
+    logger.info(f"Memory write request - end_user_id: {payload.end_user_id}, tenant_id: {api_key_auth.tenant_id}")
     
     memory_api_service = MemoryAPIService(db)
     

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/tool_controller.py

@@ -14,7 +14,6 @@ from app.models import User
 from app.models.tool_model import ToolType, ToolStatus, AuthType
 from app.services.tool_service import ToolService
 from app.schemas.response_schema import ApiResponse
-from app.core.exceptions import BusinessException
 
 router = APIRouter(prefix="/tools", tags=["Tool System"])
 
@@ -98,13 +97,7 @@ async def create_tool(
 ):
     """创建工具"""
     try:
-        # 将 MCP 来源字段合并进 config
-        if request.tool_type == ToolType.MCP:
-            for key in ("source_channel", "market_id", "market_config_id", "mcp_service_id"):
-                val = getattr(request, key, None)
-                if val is not None:
-                    request.config[key] = val
-        tool_id = await service.create_tool(
+        tool_id = service.create_tool(
             name=request.name,
             tool_type=request.tool_type,
             tenant_id=current_user.tenant_id,
@@ -114,8 +107,6 @@ async def create_tool(
             tags=request.tags
         )
         return success(data={"tool_id": tool_id}, msg="工具创建成功")
-    except BusinessException as e:
-        raise HTTPException(status_code=400, detail=e.message)
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:

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/controllers/workspace_controller.py

@@ -1,7 +1,7 @@
 import uuid
 from typing import List, Optional
 
-from fastapi import APIRouter, Depends, Header, HTTPException, Query, status
+from fastapi import APIRouter, Depends, HTTPException, Query, status
 from sqlalchemy.orm import Session
 
 from app.core.logging_config import get_api_logger
@@ -95,29 +95,16 @@ def get_workspaces(
 @router.post("", response_model=ApiResponse)
 def create_workspace(
     workspace: WorkspaceCreate,
-    language_type: str = Header(default="zh", alias="X-Language-Type"),
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_superuser),
 ):
     """创建新的工作空间"""
-    from app.core.language_utils import get_language_from_header
-    
-    # 验证并获取语言参数
-    language = get_language_from_header(language_type)
-    
-    api_logger.info(
-        f"用户 {current_user.username} 请求创建工作空间: {workspace.name}, "
-        f"language={language}"
-    )
+    api_logger.info(f"用户 {current_user.username} 请求创建工作空间: {workspace.name}")
 
     result = workspace_service.create_workspace(
-        db=db, workspace=workspace, user=current_user, language=language
-    )
+        db=db, workspace=workspace, user=current_user)
 
-    api_logger.info(
-        f"工作空间创建成功 - 名称: {workspace.name}, ID: {result.id}, "
-        f"创建者: {current_user.username}, language={language}"
-    )
+    api_logger.info(f"工作空间创建成功 - 名称: {workspace.name}, ID: {result.id}, 创建者: {current_user.username}")
     result_schema = WorkspaceResponse.model_validate(result)
     return success(data=result_schema, msg="工作空间创建成功")
 

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

@@ -7,18 +7,23 @@ LangChain Agent 封装
 - 支持流式输出
 - 使用 RedBearLLM 支持多提供商
 """
-
+import os
 import time
 from typing import Any, AsyncGenerator, Dict, List, Optional, Sequence
 
-from app.core.memory.agent.langgraph_graph.write_graph import write_long_term
+
 from app.db import get_db
 from app.core.logging_config import get_business_logger
+from app.core.memory.agent.utils.redis_tool import store
 from app.core.models import RedBearLLM, RedBearModelConfig
-from app.models.models_model import ModelType, ModelProvider
+from app.models.models_model import ModelType
+from app.repositories.memory_short_repository import LongTermMemoryRepository
 from app.services.memory_agent_service import (
     get_end_user_connected_config,
 )
+from app.services.memory_konwledges_server import write_rag
+from app.services.task_service import get_task_memory_write_result
+from app.tasks import write_message_task
 from langchain.agents import create_agent
 from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
 from langchain_core.tools import BaseTool
@@ -29,19 +34,16 @@ logger = get_business_logger()
 class LangChainAgent:
 
     def __init__(
-            self,
-            model_name: str,
-            api_key: str,
-            provider: str = "openai",
-            api_base: Optional[str] = None,
-            is_omni: bool = False,
-            temperature: float = 0.7,
-            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  # 单个工具最大连续调用次数
+        self,
+        model_name: str,
+        api_key: str,
+        provider: str = "openai",
+        api_base: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: int = 2000,
+        system_prompt: Optional[str] = None,
+        tools: Optional[Sequence[BaseTool]] = None,
+        streaming: bool = False
     ):
         """初始化 LangChain Agent
 
@@ -54,37 +56,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.is_omni = is_omni
-        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(
@@ -92,7 +70,6 @@ class LangChainAgent:
             provider=provider,
             api_key=api_key,
             base_url=api_base,
-            is_omni=is_omni,
             extra_params={
                 "temperature": temperature,
                 "max_tokens": max_tokens,
@@ -109,14 +86,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
         )
 
@@ -128,92 +102,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)
+                "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
+        self,
+        message: str,
+        history: Optional[List[Dict[str, str]]] = None,
+        context: Optional[str] = None
     ) -> List[BaseMessage]:
         """准备消息列表
 
@@ -221,7 +120,6 @@ class LangChainAgent:
             message: 用户消息
             history: 历史消息列表
             context: 上下文信息
-            files: 多模态文件内容列表（已处理）
 
         Returns:
             List[BaseMessage]: 消息列表
@@ -244,49 +142,101 @@ 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
+# TODO 乐力齐 - 累积多组对话批量写入功能已禁用
+    # async def term_memory_save(self,messages,end_user_end,aimessages):
+    #     '''短长期存储redis，为不影响正常使用6句一段话，存储用户名加一个前缀，当数据存够6条返回给neo4j'''
+    #     end_user_end=f"Term_{end_user_end}"
+    #     print(messages)
+    #     print(aimessages)
+    #     session_id = store.save_session(
+    #                     userid=end_user_end,
+    #                     messages=messages,
+    #                     apply_id=end_user_end,
+    #                     end_user_id=end_user_end,
+    #                     aimessages=aimessages
+    #                 )
+    #     store.delete_duplicate_sessions()
+    #     # logger.info(f'Redis_Agent:{end_user_end};{session_id}')
+    #     return session_id
 
-    def _build_multimodal_content(self, text: str, files: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+# TODO 乐力齐 - 累积多组对话批量写入功能已禁用
+    # async def term_memory_redis_read(self,end_user_end):
+    #     end_user_end = f"Term_{end_user_end}"
+    #     history = store.find_user_apply_group(end_user_end, end_user_end, end_user_end)
+    #     # logger.info(f'Redis_Agent:{end_user_end};{history}')
+    #     messagss_list=[]
+    #     retrieved_content=[]
+    #     for messages in history:
+    #         query = messages.get("Query")
+    #         aimessages = messages.get("Answer")
+    #         messagss_list.append(f'用户:{query}。AI回复:{aimessages}')
+    #         retrieved_content.append({query: aimessages})
+    #     return messagss_list,retrieved_content
+
+    async def write(self, storage_type, end_user_id, user_message, ai_message, user_rag_memory_id, actual_end_user_id, actual_config_id):
         """
-        构建多模态消息内容
-        
+        写入记忆（支持结构化消息）
+
         Args:
-            text: 文本内容
-            files: 文件列表（已由 MultimodalService 处理为对应 provider 的格式）
-            
-        Returns:
-            List[Dict]: 消息内容列表
+            storage_type: 存储类型 (neo4j/rag)
+            end_user_id: 终端用户ID
+            user_message: 用户消息内容
+            ai_message: AI 回复内容
+            user_rag_memory_id: RAG 记忆ID
+            actual_end_user_id: 实际用户ID
+            actual_config_id: 配置ID
+
+        逻辑说明：
+        - RAG 模式：组合 user_message 和 ai_message 为字符串格式，保持原有逻辑不变
+        - Neo4j 模式：使用结构化消息列表
+          1. 如果 user_message 和 ai_message 都不为空：创建配对消息 [user, assistant]
+          2. 如果只有 user_message：创建单条用户消息 [user]（用于历史记忆场景）
+          3. 每条消息会被转换为独立的 Chunk，保留 speaker 字段
         """
-        # 根据 provider 使用不同的文本格式
-        # if (self.provider.lower() in [ModelProvider.BEDROCK, ModelProvider.OPENAI, ModelProvider.XINFERENCE,
-        #                               ModelProvider.GPUSTACK] or (
-        #         self.provider.lower() == ModelProvider.DASHSCOPE and self.is_omni)):
-        #     # Anthropic/Bedrock/Xinference/Gpustack/Openai: {"type": "text", "text": "..."}
-        #     content_parts = [{"type": "text", "text": text}]
-        # else:
-        #     # 通义千问等: {"text": "..."}
-        #     content_parts = [{"type": "text", "text": text}]
-        content_parts = [{"type": "text", "text": text}]
+        if storage_type == "rag":
+            # RAG 模式：组合消息为字符串格式（保持原有逻辑）
+            combined_message = f"user: {user_message}\nassistant: {ai_message}"
+            await write_rag(end_user_id, combined_message, user_rag_memory_id)
+            logger.info(f'RAG_Agent:{end_user_id};{user_rag_memory_id}')
+        else:
+            # Neo4j 模式：使用结构化消息列表
+            structured_messages = []
 
-        # 添加文件内容
-        # MultimodalService 已经根据 provider 返回了正确格式，直接使用
-        content_parts.extend(files)
+            # 始终添加用户消息（如果不为空）
+            if user_message:
+                structured_messages.append({"role": "user", "content": user_message})
 
-        logger.debug(
-            f"构建多模态消息: provider={self.provider}, "
-            f"parts={len(content_parts)}, "
-            f"files={len(files)}"
-        )
+            # 只有当 AI 回复不为空时才添加 assistant 消息
+            if ai_message:
+                structured_messages.append({"role": "assistant", "content": ai_message})
 
-        return content_parts
+            # 如果没有消息，直接返回
+            if not structured_messages:
+                logger.warning(f"No messages to write for user {actual_end_user_id}")
+                return
+
+            # 调用 Celery 任务，传递结构化消息列表
+            # 数据流：
+            # 1. structured_messages 传递给 write_message_task
+            # 2. write_message_task 调用 memory_agent_service.write_memory
+            # 3. write_memory 调用 write_tools.write，传递 messages 参数
+            # 4. write_tools.write 调用 get_chunked_dialogs，传递 messages 参数
+            # 5. get_chunked_dialogs 为每条消息创建独立的 Chunk，设置 speaker 字段
+            # 6. 每个 Chunk 保存到 Neo4j，包含 speaker 字段
+            logger.info(f"[WRITE] Submitting Celery task - user={actual_end_user_id}, messages={len(structured_messages)}, config={actual_config_id}")
+            write_id = write_message_task.delay(
+                actual_end_user_id,  # end_user_id: 用户ID
+                structured_messages,  # message: 结构化消息列表 [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]
+                actual_config_id,    # config_id: 配置ID
+                storage_type,        # storage_type: "neo4j"
+                user_rag_memory_id   # user_rag_memory_id: RAG记忆ID（Neo4j模式下不使用）
+            )
+            logger.info(f"[WRITE] Celery task submitted - task_id={write_id}")
+            write_status = get_task_memory_write_result(str(write_id))
+            logger.info(f'[WRITE] Task result - user={actual_end_user_id}, status={write_status}')
 
     async def chat(
             self,
@@ -297,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
     ) -> Dict[str, Any]:
         """执行对话
 
@@ -310,7 +259,7 @@ class LangChainAgent:
         Returns:
             Dict: 包含 content 和元数据的字典
         """
-        message_chat = message
+        message_chat= message
         start_time = time.time()
         actual_config_id = config_id
         # If config_id is None, try to get from end_user's connected config
@@ -330,11 +279,35 @@ class LangChainAgent:
             except Exception as e:
                 logger.warning(f"Failed to get db session: {e}")
         actual_end_user_id = end_user_id if end_user_id is not None else "unknown"
-        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)}')
+        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)}')
+# # TODO 乐力齐，在长短期记忆存储的时候再使用此代码
+#         history_term_memory_result = await self.term_memory_redis_read(end_user_id)
+#         history_term_memory = history_term_memory_result[0]
+#         db_for_memory = next(get_db())
+#         if memory_flag:
+#             if len(history_term_memory)>=4 and storage_type != "rag":
+#                 history_term_memory = ';'.join(history_term_memory)
+#                 retrieved_content = history_term_memory_result[1]
+#                 print(retrieved_content)
+#                 # 为长期记忆操作获取新的数据库连接
+#                 try:
+#                     repo = LongTermMemoryRepository(db_for_memory)
+#                     repo.upsert(end_user_id, retrieved_content)
+#                     logger.info(
+#                         f'写入短长期：{storage_type, str(end_user_id), history_term_memory, str(user_rag_memory_id)}')
+#                 except Exception as e:
+#                     logger.error(f"Failed to write to LongTermMemory: {e}")
+#                     raise
+#                 finally:
+#                     db_for_memory.close()
+
+#                 # 长期记忆写入（
+#                 await self.write(storage_type, actual_end_user_id, history_term_memory, "", user_rag_memory_id, actual_end_user_id, actual_config_id)
+#             # 注意：不在这里写入用户消息，等 AI 回复后一起写入
         try:
-            # 准备消息列表（支持多模态）
-            messages = self._prepare_messages(message, history, context, files)
+            # 准备消息列表
+            messages = self._prepare_messages(message, history, context)
 
             logger.debug(
                 "准备调用 LangChain Agent",
@@ -342,86 +315,27 @@ 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]}...")
-                    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
+                    content = msg.content
                     break
 
-            logger.info(f"最终提取的内容长度: {len(content)}")
-
             elapsed_time = time.time() - start_time
             if memory_flag:
-                await write_long_term(storage_type, end_user_id, message_chat, content, user_rag_memory_id,
-                                      actual_config_id)
+                # AI 回复写入（用户消息和 AI 回复配对，一次性写入完整对话）
+                await self.write(storage_type, actual_end_user_id, message_chat, content, user_rag_memory_id, actual_end_user_id, actual_config_id)
+                # TODO 乐力齐 - 累积多组对话批量写入功能已禁用
+                # await self.term_memory_save(message_chat, end_user_id, content)
             response = {
                 "content": content,
                 "model": self.model_name,
@@ -429,7 +343,7 @@ class LangChainAgent:
                 "usage": {
                     "prompt_tokens": 0,
                     "completion_tokens": 0,
-                    "total_tokens": total_tokens
+                    "total_tokens": 0
                 }
             }
 
@@ -448,16 +362,15 @@ class LangChainAgent:
             raise
 
     async def chat_stream(
-            self,
-            message: str,
-            history: Optional[List[Dict[str, str]]] = None,
-            context: Optional[str] = None,
-            end_user_id: Optional[str] = None,
-            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  # 新增：多模态文件
+        self,
+        message: str,
+        history: Optional[List[Dict[str, str]]] = None,
+        context: Optional[str] = None,
+        end_user_id:Optional[str] = None,
+        config_id: Optional[str] = None,
+        storage_type:Optional[str] = None,
+        user_rag_memory_id:Optional[str] = None,
+        memory_flag: Optional[bool] = True
     ) -> AsyncGenerator[str, None]:
         """执行流式对话
 
@@ -490,14 +403,33 @@ class LangChainAgent:
                     db.close()
             except Exception as e:
                 logger.warning(f"Failed to get db session: {e}")
+# # TODO 乐力齐
+#         history_term_memory_result = await self.term_memory_redis_read(end_user_id)
+#         history_term_memory = history_term_memory_result[0]
+#         if memory_flag:
+#             if len(history_term_memory) >= 4 and storage_type != "rag":
+#                 history_term_memory = ';'.join(history_term_memory)
+#                 retrieved_content = history_term_memory_result[1]
+#                 db_for_memory = next(get_db())
+#                 try:
+#                     repo = LongTermMemoryRepository(db_for_memory)
+#                     repo.upsert(end_user_id, retrieved_content)
+#                     logger.info(
+#                         f'写入短长期：{storage_type, str(end_user_id), history_term_memory, str(user_rag_memory_id)}')
+#                     # 长期记忆写入
+#                     await self.write(storage_type, end_user_id, history_term_memory, "", user_rag_memory_id, end_user_id, actual_config_id)
+#                 except Exception as e:
+#                     logger.error(f"Failed to write to long term memory: {e}")
+#                 finally:
+#                     db_for_memory.close()
 
             # 注意：不在这里写入用户消息，等 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
@@ -505,106 +437,49 @@ class LangChainAgent:
 
             # 统一使用 agent 的 astream_events 实现流式输出
             logger.debug("使用 Agent astream_events 实现流式输出")
-            full_content = ''
+            full_content=''
             try:
                 async for event in self.agent.astream_events(
-                        {"messages": messages},
-                        version="v2",
-                        config={"recursion_limit": self.max_iterations}
+                    {"messages": messages},
+                    version="v2"
                 ):
                     chunk_count += 1
                     kind = event.get("event")
-
+                    
                     # 处理所有可能的流式事件
                     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
-
+                    
                     # 记录工具调用（可选）
                     elif kind == "on_tool_start":
                         logger.debug(f"工具调用开始: {event.get('name')}")
                     elif kind == "on_tool_end":
                         logger.debug(f"工具调用结束: {event.get('name')}")
-
+                
                 logger.debug(f"Agent 流式完成，共 {chunk_count} 个事件")
-                # 统计token消耗
-                output_messages = event.get("data", {}).get("output", {}).get("messages", [])
-                for msg in reversed(output_messages):
-                    if isinstance(msg, AIMessage):
-                        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
-                        yield total_tokens
-                        break
                 if memory_flag:
-                    await write_long_term(storage_type, end_user_id, message_chat, full_content, user_rag_memory_id,
-                                          actual_config_id)
+                    # AI 回复写入（用户消息和 AI 回复配对，一次性写入完整对话）
+                    await self.write(storage_type, end_user_id, message_chat, full_content, user_rag_memory_id, end_user_id, actual_config_id)
+                    # TODO 乐力齐 - 累积多组对话批量写入功能已禁用
+                    # await self.term_memory_save(message_chat, end_user_id, full_content)
+                
             except Exception as e:
                 logger.error(f"Agent astream_events 失败: {str(e)}", exc_info=True)
                 raise
@@ -618,3 +493,5 @@ class LangChainAgent:
             logger.info("=" * 80)
             logger.info("chat_stream 方法执行结束")
             logger.info("=" * 80)
+
+

api/app/core/config.py

@@ -1,9 +1,9 @@
+import json
 import os
 from pathlib import Path
-from typing import Annotated, Optional
+from typing import Any, Dict, Optional
 
 from dotenv import load_dotenv
-from pydantic import Field, TypeAdapter
 
 load_dotenv()
 
@@ -16,18 +16,18 @@ class Settings:
     # cloud: SaaS 云服务版（全功能，按量计费）
     # enterprise: 企业私有化版（License 控制）
     DEPLOYMENT_MODE: str = os.getenv("DEPLOYMENT_MODE", "community")
-
+    
     # License 配置（企业版）
     LICENSE_FILE: str = os.getenv("LICENSE_FILE", "/etc/app/license.json")
     LICENSE_SERVER_URL: str = os.getenv("LICENSE_SERVER_URL", "https://license.yourcompany.com")
-
+    
     # 计费服务配置（SaaS 版）
     BILLING_SERVICE_URL: str = os.getenv("BILLING_SERVICE_URL", "")
-
+    
     # 基础 URL（用于 SSO 回调等）
     BASE_URL: str = os.getenv("BASE_URL", "http://localhost:8000")
     FRONTEND_URL: str = os.getenv("FRONTEND_URL", "http://localhost:3000")
-
+    
     ENABLE_SINGLE_WORKSPACE: bool = os.getenv("ENABLE_SINGLE_WORKSPACE", "true").lower() == "true"
     # API Keys Configuration
     OPENAI_API_KEY: str = os.getenv("OPENAI_API_KEY", "")
@@ -57,6 +57,7 @@ class Settings:
     REDIS_PORT: int = int(os.getenv("REDIS_PORT", "6379"))
     REDIS_DB: int = int(os.getenv("REDIS_DB", "1"))
     REDIS_PASSWORD: str = os.getenv("REDIS_PASSWORD", "")
+    
 
     # ElasticSearch configuration
     ELASTICSEARCH_HOST: str = os.getenv("ELASTICSEARCH_HOST", "https://127.0.0.1")
@@ -90,7 +91,7 @@ class Settings:
 
     # Single Sign-On configuration
     ENABLE_SINGLE_SESSION: bool = os.getenv("ENABLE_SINGLE_SESSION", "false").lower() == "true"
-
+    
     # SSO 免登配置
     SSO_TOKEN_EXPIRE_SECONDS: int = int(os.getenv("SSO_TOKEN_EXPIRE_SECONDS", "300"))
     SSO_TRUSTED_SOURCES_CONFIG: str = os.getenv("SSO_TRUSTED_SOURCES_CONFIG", "{}")
@@ -114,7 +115,6 @@ class Settings:
     S3_ACCESS_KEY_ID: str = os.getenv("S3_ACCESS_KEY_ID", "")
     S3_SECRET_ACCESS_KEY: str = os.getenv("S3_SECRET_ACCESS_KEY", "")
     S3_BUCKET_NAME: str = os.getenv("S3_BUCKET_NAME", "")
-    S3_ENDPOINT_URL: str = os.getenv("S3_ENDPOINT_URL", "")
 
     # VOLC ASR settings
     VOLC_APP_KEY: str = os.getenv("VOLC_APP_KEY", "")
@@ -130,7 +130,7 @@ class Settings:
 
     # Server Configuration
     SERVER_IP: str = os.getenv("SERVER_IP", "127.0.0.1")
-    FILE_LOCAL_SERVER_URL: str = os.getenv("FILE_LOCAL_SERVER_URL", "http://localhost:8000/api")
+    FILE_LOCAL_SERVER_URL : str = os.getenv("FILE_LOCAL_SERVER_URL", "http://localhost:8000/api")
 
     # ========================================================================
     # Internal Configuration (not in .env, used by application code)
@@ -157,11 +157,6 @@ class Settings:
         if origin.strip()
     ]
 
-    # Language Configuration
-    # Supported values: "zh" (Chinese), "en" (English)
-    # This controls the language used for memory summary titles and other generated content
-    DEFAULT_LANGUAGE: str = os.getenv("DEFAULT_LANGUAGE", "zh")
-
     # Logging settings
     LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
     LOG_FORMAT: str = os.getenv("LOG_FORMAT", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
@@ -190,45 +185,19 @@ class Settings:
     LOG_FILE_MAX_SIZE_MB: int = int(os.getenv("LOG_FILE_MAX_SIZE_MB", "10"))  # 10MB
 
     # Celery configuration (internal)
-    # NOTE: 变量名不以 CELERY_ 开头，避免被 Celery CLI 的前缀匹配机制劫持
-    # 详见 docs/celery-env-bug-report.md
-    # 默认使用 Redis DB 3 (broker) 和 DB 4 (backend)，与业务缓存 (DB 1/2) 隔离
-    # 多人共用同一 Redis 时，每位开发者应在 .env 中配置不同的 DB 编号避免任务互相干扰
-    REDIS_DB_CELERY_BROKER: int = int(os.getenv("REDIS_DB_CELERY_BROKER", "3"))
-    REDIS_DB_CELERY_BACKEND: int = int(os.getenv("REDIS_DB_CELERY_BACKEND", "4"))
-
-    # 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", "")
+    CELERY_BROKER: int = int(os.getenv("CELERY_BROKER", "1"))
+    CELERY_BACKEND: int = int(os.getenv("CELERY_BACKEND", "2"))
 
     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"))
 
-    # Celery Beat Schedule Configuration (定时任务执行频率)
-    MEMORY_INCREMENT_HOUR: int = TypeAdapter(
-        Annotated[int, Field(ge=0, le=23, description="cron hour [0, 23]")]
-    ).validate_python(int(os.getenv("MEMORY_INCREMENT_HOUR", "2")))
-    MEMORY_INCREMENT_MINUTE: int = TypeAdapter(
-        Annotated[int, Field(ge=0, le=59, description="cron minute [0, 59]")]
-    ).validate_python(int(os.getenv("MEMORY_INCREMENT_MINUTE", "0")))
-    WORKSPACE_REFLECTION_INTERVAL_SECONDS: int = TypeAdapter(
-        Annotated[int, Field(ge=1, description="reflection interval in seconds, must be >= 1")]
-    ).validate_python(int(os.getenv("WORKSPACE_REFLECTION_INTERVAL_SECONDS", "30")))
-    FORGETTING_CYCLE_INTERVAL_HOURS: int = TypeAdapter(
-        Annotated[int, Field(ge=1, description="forgetting cycle interval in hours, must be >= 1")]
-    ).validate_python(int(os.getenv("FORGETTING_CYCLE_INTERVAL_HOURS", "24")))
-    
-    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_OUTPUT_DIR: str = os.getenv("MEMORY_OUTPUT_DIR", "logs/memory-output")
     MEMORY_CONFIG_DIR: str = os.getenv("MEMORY_CONFIG_DIR", "app/core/memory")
 
@@ -241,35 +210,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_IMPORT_CACHE_TIMEOUT: int = int(os.getenv("WORKFLOW_IMPORT_CACHE_TIMEOUT", 1800))
     WORKFLOW_NODE_TIMEOUT: int = int(os.getenv("WORKFLOW_NODE_TIMEOUT", 600))
 
-    # ========================================================================
-    # General Ontology Type Configuration
-    # ========================================================================
-    # 通用本体文件路径列表（逗号分隔）
-    GENERAL_ONTOLOGY_FILES: str = os.getenv("GENERAL_ONTOLOGY_FILES", "api/app/core/memory/ontology_services/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/problem_nodes.py

@@ -1,10 +1,10 @@
-import json
 import os
+import json
 import time
-
 from app.core.logging_config import get_agent_logger
+from app.db import get_db
+
 from app.core.memory.agent.models.problem_models import ProblemExtensionResponse
-from app.core.memory.agent.services.optimized_llm_service import LLMServiceMixin
 from app.core.memory.agent.utils.llm_tools import (
     PROJECT_ROOT_,
     ReadState,
@@ -12,9 +12,10 @@ from app.core.memory.agent.utils.llm_tools import (
 from app.core.memory.agent.utils.redis_tool import store
 from app.core.memory.agent.utils.session_tools import SessionService
 from app.core.memory.agent.utils.template_tools import TemplateService
-from app.db import get_db_context
+from app.core.memory.agent.services.optimized_llm_service import LLMServiceMixin
 
 template_root = os.path.join(PROJECT_ROOT_, 'memory', 'agent', 'utils', 'prompt')
+db_session = next(get_db())
 logger = get_agent_logger(__name__)
 
 
@@ -52,14 +53,13 @@ async def Split_The_Problem(state: ReadState) -> ReadState:
 
     try:
         # 使用优化的LLM服务
-        with get_db_context() as db_session:
-            structured = await problem_service.call_llm_structured(
-                state=state,
-                db_session=db_session,
-                system_prompt=system_prompt,
-                response_model=ProblemExtensionResponse,
-                fallback_value=[]
-            )
+        structured = await problem_service.call_llm_structured(
+            state=state,
+            db_session=db_session,
+            system_prompt=system_prompt,
+            response_model=ProblemExtensionResponse,
+            fallback_value=[]
+        )
 
         # 添加更详细的日志记录
         logger.info(f"Split_The_Problem: 开始处理问题分解，内容长度: {len(content)}")
@@ -111,7 +111,7 @@ async def Split_The_Problem(state: ReadState) -> ReadState:
             "error_type": type(e).__name__,
             "error_message": str(e),
             "content_length": len(content),
-            "llm_model_id": str(memory_config.llm_model_id) if memory_config else None
+            "llm_model_id": memory_config.llm_model_id if memory_config else None
         }
 
         logger.error(f"Split_The_Problem error details: {error_details}")
@@ -171,14 +171,13 @@ async def Problem_Extension(state: ReadState) -> ReadState:
 
     try:
         # 使用优化的LLM服务
-        with get_db_context() as db_session:
-            response_content = await problem_service.call_llm_structured(
-                state=state,
-                db_session=db_session,
-                system_prompt=system_prompt,
-                response_model=ProblemExtensionResponse,
-                fallback_value=[]
-            )
+        response_content = await problem_service.call_llm_structured(
+            state=state,
+            db_session=db_session,
+            system_prompt=system_prompt,
+            response_model=ProblemExtensionResponse,
+            fallback_value=[]
+        )
 
         logger.info(f"Problem_Extension: 开始处理问题扩展，问题数量: {len(databasets)}")
 
@@ -221,7 +220,7 @@ async def Problem_Extension(state: ReadState) -> ReadState:
             "error_type": type(e).__name__,
             "error_message": str(e),
             "questions_count": len(databasets),
-            "llm_model_id": str(memory_config.llm_model_id) if memory_config else None
+            "llm_model_id": memory_config.llm_model_id if memory_config else None
         }
 
         logger.error(f"Problem_Extension error details: {error_details}")

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

@@ -6,26 +6,31 @@ import os
 # ===== 第三方库 =====
 from langchain.agents import create_agent
 from langchain_openai import ChatOpenAI
-
 from app.core.logging_config import get_agent_logger
+from app.db import get_db, get_db_context
+
+from app.schemas import model_schema
+from app.services.memory_config_service import MemoryConfigService
+from app.services.model_service import ModelConfigService
+
+from app.core.memory.agent.services.search_service import SearchService
+from app.core.memory.agent.utils.llm_tools import (
+    COUNTState,
+    ReadState,
+    deduplicate_entries,
+    merge_to_key_value_pairs,
+)
 from app.core.memory.agent.langgraph_graph.tools.tool import (
     create_hybrid_retrieval_tool_sync,
     create_time_retrieval_tool,
     extract_tool_message_content,
 )
-from app.core.memory.agent.services.search_service import SearchService
-from app.core.memory.agent.utils.llm_tools import (
-    ReadState,
-    deduplicate_entries,
-    merge_to_key_value_pairs,
-)
+
 from app.core.rag.nlp.search import knowledge_retrieval
-from app.db import get_db_context
-from app.schemas import model_schema
-from app.services.memory_config_service import MemoryConfigService
-from app.services.model_service import ModelConfigService
 
 logger = get_agent_logger(__name__)
+db = next(get_db())
+
 
 
 async def rag_config(state):
@@ -45,12 +50,10 @@ async def rag_config(state):
         "reranker_top_k": 10
     }
     return kb_config
-
-
-async def rag_knowledge(state, question):
+async def rag_knowledge(state,question):
     kb_config = await rag_config(state)
     end_user_id = state.get('end_user_id', '')
-    user_rag_memory_id = state.get("user_rag_memory_id", '')
+    user_rag_memory_id=state.get("user_rag_memory_id",'')
     retrieve_chunks_result = knowledge_retrieval(question, kb_config, [str(end_user_id)])
     try:
         retrieval_knowledge = [i.page_content for i in retrieve_chunks_result]
@@ -58,13 +61,13 @@ async def rag_knowledge(state, question):
         cleaned_query = question
         raw_results = clean_content
         logger.info(f" Using RAG storage with memory_id={user_rag_memory_id}")
-    except Exception:
-        retrieval_knowledge = []
+    except  Exception :
+        retrieval_knowledge=[]
         clean_content = ''
         raw_results = ''
         cleaned_query = question
         logger.info(f"No content retrieved from knowledge base: {user_rag_memory_id}")
-    return retrieval_knowledge, clean_content, cleaned_query, raw_results
+    return retrieval_knowledge,clean_content,cleaned_query,raw_results
 
 
 async def llm_infomation(state: ReadState) -> ReadState:
@@ -110,7 +113,7 @@ async def clean_databases(data) -> str:
 
         # 收集所有内容
         content_list = []
-
+        
         # 处理重排序结果
         reranked = results.get('reranked_results', {})
         if reranked:
@@ -138,6 +141,7 @@ async def clean_databases(data) -> str:
             elif isinstance(item, str):
                 text_parts.append(item)
 
+
         return '\n'.join(text_parts).strip()
 
     except Exception as e:
@@ -146,23 +150,23 @@ async def clean_databases(data) -> str:
 
 
 async def retrieve_nodes(state: ReadState) -> ReadState:
+
     '''
 
     模型信息
     '''
 
-    problem_extension = state.get('problem_extension', '')['context']
-    storage_type = state.get('storage_type', '')
-    user_rag_memory_id = state.get('user_rag_memory_id', '')
-    end_user_id = state.get('end_user_id', '')
+    problem_extension=state.get('problem_extension', '')['context']
+    storage_type=state.get('storage_type', '')
+    user_rag_memory_id=state.get('user_rag_memory_id', '')
+    end_user_id=state.get('end_user_id', '')
     memory_config = state.get('memory_config', None)
-    original = state.get('data', '')
-    problem_list = []
-    for key, values in problem_extension.items():
+    original=state.get('data', '')
+    problem_list=[]
+    for key,values in problem_extension.items():
         for data in values:
             problem_list.append(data)
     logger.info(f"Retrieve: storage_type={storage_type}, user_rag_memory_id={user_rag_memory_id}")
-
     # 创建异步任务处理单个问题
     async def process_question_nodes(idx, question):
         try:
@@ -240,7 +244,7 @@ async def retrieve_nodes(state: ReadState) -> ReadState:
 
     send_verify = []
     for i, j in zip(keys, val, strict=False):
-        if j != ['']:
+        if j!=['']:
             send_verify.append({
                 "Query_small": i,
                 "Answer_Small": j
@@ -253,13 +257,15 @@ async def retrieve_nodes(state: ReadState) -> ReadState:
     }
 
     logger.info(f"Collected {len(intermediate_outputs)} intermediate outputs from search results")
-    return {'retrieve': dup_databases}
+    return {'retrieve':dup_databases}
+
+
 
 
 async def retrieve(state: ReadState) -> ReadState:
     # 从state中获取end_user_id
     import time
-    start = time.time()
+    start=time.time()
     problem_extension = state.get('problem_extension', '')['context']
     storage_type = state.get('storage_type', '')
     user_rag_memory_id = state.get('user_rag_memory_id', '')
@@ -277,7 +283,6 @@ async def retrieve(state: ReadState) -> ReadState:
         with get_db_context() as db:  # 使用同步数据库上下文管理器
             config_service = MemoryConfigService(db)
             return await llm_infomation(state)
-
     llm_config = await get_llm_info()
     api_key_obj = llm_config.api_keys[0]
     api_key = api_key_obj.api_key
@@ -291,11 +296,11 @@ async def retrieve(state: ReadState) -> ReadState:
     )
 
     time_retrieval_tool = create_time_retrieval_tool(end_user_id)
-    search_params = {"end_user_id": end_user_id, "return_raw_results": True}
-    hybrid_retrieval = create_hybrid_retrieval_tool_sync(memory_config, **search_params)
+    search_params = { "end_user_id": end_user_id, "return_raw_results": True }
+    hybrid_retrieval=create_hybrid_retrieval_tool_sync(memory_config, **search_params)
     agent = create_agent(
         llm,
-        tools=[time_retrieval_tool, hybrid_retrieval],
+        tools=[time_retrieval_tool,hybrid_retrieval],
         system_prompt=f"我是检索专家，可以根据适合的工具进行检索。当前使用的end_user_id是: {end_user_id}"
     )
 
@@ -309,8 +314,7 @@ async def retrieve(state: ReadState) -> ReadState:
         async with SEMAPHORE:  # 限制并发
             try:
                 if storage_type == "rag" and user_rag_memory_id:
-                    retrieval_knowledge, clean_content, cleaned_query, raw_results = await rag_knowledge(state,
-                                                                                                         question)
+                    retrieval_knowledge, clean_content, cleaned_query, raw_results = await rag_knowledge(state, question)
                 else:
                     cleaned_query = question
                     # 使用 asyncio 在线程池中运行同步的 agent.invoke
@@ -409,3 +413,5 @@ async def retrieve(state: ReadState) -> ReadState:
     #     json.dump(dup_databases, f, indent=4)
     logger.info(f"Collected {len(intermediate_outputs)} intermediate outputs from search results")
     return {'retrieve': dup_databases}
+
+

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

@@ -1,3 +1,5 @@
+
+
 import os
 import time
 
@@ -15,77 +17,33 @@ from app.core.memory.agent.utils.llm_tools import (
 from app.core.memory.agent.utils.redis_tool import store
 from app.core.memory.agent.utils.session_tools import SessionService
 from app.core.memory.agent.utils.template_tools import TemplateService
-from app.core.rag.nlp.search import knowledge_retrieval
-from app.db import get_db_context
+from app.db import get_db
 
 template_root = os.path.join(PROJECT_ROOT_, 'memory', 'agent', 'utils', 'prompt')
 logger = get_agent_logger(__name__)
-
+db_session = next(get_db())
 
 class SummaryNodeService(LLMServiceMixin):
     """总结节点服务类"""
-
+    
     def __init__(self):
         super().__init__()
         self.template_service = TemplateService(template_root)
 
-
 # 创建全局服务实例
 summary_service = SummaryNodeService()
 
-
-async def rag_config(state):
-    user_rag_memory_id = state.get('user_rag_memory_id', '')
-    kb_config = {
-        "knowledge_bases": [
-            {
-                "kb_id": user_rag_memory_id,
-                "similarity_threshold": 0.7,
-                "vector_similarity_weight": 0.5,
-                "top_k": 10,
-                "retrieve_type": "participle"
-            }
-        ],
-        "merge_strategy": "weight",
-        "reranker_id": os.getenv('reranker_id'),
-        "reranker_top_k": 10
-    }
-    return kb_config
-
-
-async def rag_knowledge(state, question):
-    kb_config = await rag_config(state)
-    end_user_id = state.get('end_user_id', '')
-    user_rag_memory_id = state.get("user_rag_memory_id", '')
-    retrieve_chunks_result = knowledge_retrieval(question, kb_config, [str(end_user_id)])
-    try:
-        retrieval_knowledge = [i.page_content for i in retrieve_chunks_result]
-        clean_content = '\n\n'.join(retrieval_knowledge)
-        cleaned_query = question
-        raw_results = clean_content
-        logger.info(f" Using RAG storage with memory_id={user_rag_memory_id}")
-    except  Exception:
-        retrieval_knowledge = []
-        clean_content = ''
-        raw_results = ''
-        cleaned_query = question
-        logger.info(f"No content retrieved from knowledge base: {user_rag_memory_id}")
-    return retrieval_knowledge, clean_content, cleaned_query, raw_results
-
-
 async def summary_history(state: ReadState) -> ReadState:
     end_user_id = state.get("end_user_id", '')
     history = await SessionService(store).get_history(end_user_id, end_user_id, end_user_id)
     return history
 
-
-async def summary_llm(state: ReadState, history, retrieve_info, template_name, operation_name, response_model,
-                      search_mode) -> str:
+async def summary_llm(state: ReadState, history, retrieve_info, template_name, operation_name, response_model,search_mode) -> str:
     """
     增强的summary_llm函数，包含更好的错误处理和数据验证
     """
     data = state.get("data", '')
-
+    
     # 构建系统提示词
     if str(search_mode) == "0":
         system_prompt = await summary_service.template_service.render_template(
@@ -104,19 +62,18 @@ async def summary_llm(state: ReadState, history, retrieve_info, template_name, o
         )
     try:
         # 使用优化的LLM服务进行结构化输出
-        with get_db_context() as db_session:
-            structured = await summary_service.call_llm_structured(
-                state=state,
-                db_session=db_session,
-                system_prompt=system_prompt,
-                response_model=response_model,
-                fallback_value=None
-            )
+        structured = await summary_service.call_llm_structured(
+            state=state,
+            db_session=db_session,
+            system_prompt=system_prompt,
+            response_model=response_model,
+            fallback_value=None
+        )
         # 验证结构化响应
         if structured is None:
-            logger.warning("LLM返回None，使用默认回答")
+            logger.warning(f"LLM返回None，使用默认回答")
             return "信息不足，无法回答"
-
+        
         # 根据操作类型提取答案
         if operation_name == "summary":
             aimessages = getattr(structured, 'query_answer', None) or "信息不足，无法回答"
@@ -125,18 +82,18 @@ async def summary_llm(state: ReadState, history, retrieve_info, template_name, o
             if hasattr(structured, 'data') and structured.data:
                 aimessages = getattr(structured.data, 'query_answer', None) or "信息不足，无法回答"
             else:
-                logger.warning("结构化响应缺少data字段")
+                logger.warning(f"结构化响应缺少data字段")
                 aimessages = "信息不足，无法回答"
-
+        
         # 验证答案不为空
         if not aimessages or aimessages.strip() == "":
             aimessages = "信息不足，无法回答"
-
+            
         return aimessages
-
+        
     except Exception as e:
         logger.error(f"结构化输出失败: {e}", exc_info=True)
-
+        
         # 尝试非结构化输出作为fallback
         try:
             logger.info("尝试非结构化输出作为fallback")
@@ -146,7 +103,7 @@ async def summary_llm(state: ReadState, history, retrieve_info, template_name, o
                 system_prompt=system_prompt,
                 fallback_message="信息不足，无法回答"
             )
-
+            
             if response and response.strip():
                 # 简单清理响应
                 cleaned_response = response.strip()
@@ -154,17 +111,16 @@ async def summary_llm(state: ReadState, history, retrieve_info, template_name, o
                 if cleaned_response.startswith('```'):
                     lines = cleaned_response.split('\n')
                     cleaned_response = '\n'.join(lines[1:-1])
-
+                
                 return cleaned_response
             else:
                 return "信息不足，无法回答"
-
+                
         except Exception as fallback_error:
             logger.error(f"Fallback也失败: {fallback_error}")
             return "信息不足，无法回答"
 
-
-async def summary_redis_save(state: ReadState, aimessages) -> ReadState:
+async def summary_redis_save(state: ReadState,aimessages) -> ReadState:
     data = state.get("data", '')
     end_user_id = state.get("end_user_id", '')
     await SessionService(store).save_session(
@@ -176,12 +132,10 @@ async def summary_redis_save(state: ReadState, aimessages) -> ReadState:
     )
     await SessionService(store).cleanup_duplicates()
     logger.info(f"sessionid: {aimessages} 写入成功")
-
-
-async def summary_prompt(state: ReadState, aimessages, raw_results) -> ReadState:
-    storage_type = state.get("storage_type", '')
-    user_rag_memory_id = state.get("user_rag_memory_id", '')
-    data = state.get("data", '')
+async def summary_prompt(state: ReadState,aimessages,raw_results) -> ReadState:
+    storage_type=state.get("storage_type",'')
+    user_rag_memory_id=state.get("user_rag_memory_id",'')
+    data=state.get("data", '')
     input_summary = {
         "status": "success",
         "summary_result": aimessages,
@@ -198,14 +152,14 @@ async def summary_prompt(state: ReadState, aimessages, raw_results) -> ReadState
             "user_rag_memory_id": user_rag_memory_id
         }
     }
-    retrieve = {
+    retrieve={
         "status": "success",
         "summary_result": aimessages,
         "storage_type": storage_type,
         "user_rag_memory_id": user_rag_memory_id,
         "_intermediate": {
             "type": "retrieval_summary",
-            "title": "快速检索",
+            "title":"快速检索",
             "summary": aimessages,
             "query": data,
             "storage_type": storage_type,
@@ -213,18 +167,17 @@ async def summary_prompt(state: ReadState, aimessages, raw_results) -> ReadState
         }
     }
 
-    return input_summary, retrieve
-
+    return input_summary,retrieve
 
 async def Input_Summary(state: ReadState) -> ReadState:
-    start = time.time()
-    storage_type = state.get("storage_type", '')
+    start=time.time()
+    storage_type=state.get("storage_type",'')
     memory_config = state.get('memory_config', None)
-    user_rag_memory_id = state.get("user_rag_memory_id", '')
-    data = state.get("data", '')
-    end_user_id = state.get("end_user_id", '')
+    user_rag_memory_id=state.get("user_rag_memory_id",'')
+    data=state.get("data", '')
+    end_user_id=state.get("end_user_id", '')
     logger.info(f"Input_Summary: storage_type={storage_type}, user_rag_memory_id={user_rag_memory_id}")
-    history = await summary_history(state)
+    history = await summary_history( state)
     search_params = {
         "end_user_id": end_user_id,
         "question": data,
@@ -233,14 +186,12 @@ async def Input_Summary(state: ReadState) -> ReadState:
     }
 
     try:
-        if storage_type != "rag":
-            retrieve_info, question, raw_results = await SearchService().execute_hybrid_search(**search_params,
-                                                                                               memory_config=memory_config)
-        else:
-            retrieval_knowledge, retrieve_info, question, raw_results = await rag_knowledge(state, data)
+        retrieve_info, question, raw_results = await SearchService().execute_hybrid_search(**search_params, memory_config=memory_config)
     except Exception as e:
-        logger.error(f"Input_Summary: hybrid_search failed, using empty results: {e}", exc_info=True)
+        logger.error( f"Input_Summary: hybrid_search failed, using empty results: {e}",  exc_info=True )
         retrieve_info, question, raw_results = "", data, []
+
+
     try:
         # aimessages=await summary_llm(state,history,retrieve_info,'Retrieve_Summary_prompt.jinja2',
         #                              'input_summary',RetrieveSummaryResponse)
@@ -248,8 +199,8 @@ async def Input_Summary(state: ReadState) -> ReadState:
         summary_result = await summary_prompt(state, retrieve_info, retrieve_info)
         summary = summary_result[0]
     except Exception as e:
-        logger.error(f"Input_Summary failed: {e}", exc_info=True)
-        summary = {
+        logger.error( f"Input_Summary failed: {e}", exc_info=True )
+        summary= {
             "status": "fail",
             "summary_result": "信息不足，无法回答",
             "storage_type": storage_type,
@@ -262,31 +213,30 @@ async def Input_Summary(state: ReadState) -> ReadState:
     except Exception:
         duration = 0.0
     log_time('检索', duration)
-    return {"summary": summary}
+    return {"summary":summary}
 
-
-async def Retrieve_Summary(state: ReadState) -> ReadState:
-    retrieve = state.get("retrieve", '')
-    history = await summary_history(state)
+async def Retrieve_Summary(state: ReadState)-> ReadState:
+    retrieve=state.get("retrieve", '')
+    history = await summary_history( state)
     import json
-    with open("检索.json", "w", encoding='utf-8') as f:
+    with open("检索.json","w",encoding='utf-8') as f:
         f.write(json.dumps(retrieve, indent=4, ensure_ascii=False))
-    retrieve = retrieve.get("Expansion_issue", [])
-    start = time.time()
-    retrieve_info_str = []
+    retrieve=retrieve.get("Expansion_issue", [])
+    start=time.time()
+    retrieve_info_str=[]
     for data in retrieve:
-        if data == '':
-            retrieve_info_str = ''
+        if data=='':
+            retrieve_info_str=''
         else:
             for key, value in data.items():
-                if key == 'Answer_Small':
+                if key=='Answer_Small':
                     for i in value:
                         retrieve_info_str.append(i)
-    retrieve_info_str = list(set(retrieve_info_str))
-    retrieve_info_str = '\n'.join(retrieve_info_str)
+    retrieve_info_str=list(set(retrieve_info_str))
+    retrieve_info_str='\n'.join(retrieve_info_str)
 
-    aimessages = await  summary_llm(state, history, retrieve_info_str,
-                                    'direct_summary_prompt.jinja2', 'retrieve_summary', RetrieveSummaryResponse, "1")
+    aimessages=await  summary_llm(state,history,retrieve_info_str,
+                                  'direct_summary_prompt.jinja2','retrieve_summary',RetrieveSummaryResponse,"1")
     if '信息不足，无法回答' not in str(aimessages) or str(aimessages) != "":
         await summary_redis_save(state, aimessages)
     if aimessages == '':
@@ -298,33 +248,33 @@ async def Retrieve_Summary(state: ReadState) -> ReadState:
     except Exception:
         duration = 0.0
     log_time('Retrieval summary', duration)
-
+    
     # 修复协程调用 - 先await，然后访问返回值
     summary_result = await summary_prompt(state, aimessages, retrieve_info_str)
     summary = summary_result[1]
-    return {"summary": summary}
+    return {"summary":summary}
 
 
-async def Summary(state: ReadState) -> ReadState:
-    start = time.time()
+async def Summary(state: ReadState)-> ReadState:
+    start=time.time()
     query = state.get("data", '')
-    verify = state.get("verify", '')
-    verify_expansion_issue = verify.get("verified_data", '')
-    retrieve_info_str = ''
+    verify=state.get("verify", '')
+    verify_expansion_issue=verify.get("verified_data", '')
+    retrieve_info_str=''
     for data in verify_expansion_issue:
         for key, value in data.items():
-            if key == 'answer_small':
+            if key=='answer_small':
                 for i in value:
-                    retrieve_info_str += i + '\n'
-    history = await summary_history(state)
+                    retrieve_info_str+=i+'\n'
+    history=await summary_history(state)
 
     data = {
         "query": query,
         "history": history,
         "retrieve_info": retrieve_info_str
     }
-    aimessages = await  summary_llm(state, history, data,
-                                    'summary_prompt.jinja2', 'summary', SummaryResponse, 0)
+    aimessages=await  summary_llm(state,history,data,
+                                  'summary_prompt.jinja2','summary',SummaryResponse,0)
 
     if '信息不足，无法回答' not in str(aimessages) or str(aimessages) != "":
         await summary_redis_save(state, aimessages)
@@ -339,12 +289,11 @@ async def Summary(state: ReadState) -> ReadState:
     # 修复协程调用 - 先await，然后访问返回值
     summary_result = await summary_prompt(state, aimessages, retrieve_info_str)
     summary = summary_result[1]
-    return {"summary": summary}
+    return {"summary":summary}
 
-
-async def Summary_fails(state: ReadState) -> ReadState:
-    storage_type = state.get("storage_type", '')
-    user_rag_memory_id = state.get("user_rag_memory_id", '')
+async def Summary_fails(state: ReadState)-> ReadState:
+    storage_type=state.get("storage_type", '')
+    user_rag_memory_id=state.get("user_rag_memory_id", '')
     history = await summary_history(state)
     query = state.get("data", '')
     verify = state.get("verify", '')
@@ -360,12 +309,12 @@ async def Summary_fails(state: ReadState) -> ReadState:
         "history": history,
         "retrieve_info": retrieve_info_str
     }
-    aimessages = await summary_llm(state, history, data,
-                                   'fail_summary_prompt.jinja2', 'summary', SummaryResponse, 0)
-    result = {
+    aimessages = await  summary_llm(state, history, data,
+                                 'fail_summary_prompt.jinja2', 'summary', SummaryResponse, 0)
+    result= {
         "status": "success",
         "summary_result": aimessages,
         "storage_type": storage_type,
         "user_rag_memory_id": user_rag_memory_id
     }
-    return {"summary": result}
+    return {"summary":result}

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

@@ -1,9 +1,8 @@
-import asyncio
 import os
-
 from app.core.logging_config import get_agent_logger
+from app.db import get_db
+
 from app.core.memory.agent.models.verification_models import VerificationResult
-from app.core.memory.agent.services.optimized_llm_service import LLMServiceMixin
 from app.core.memory.agent.utils.llm_tools import (
     PROJECT_ROOT_,
     ReadState,
@@ -11,30 +10,28 @@ from app.core.memory.agent.utils.llm_tools import (
 from app.core.memory.agent.utils.redis_tool import store
 from app.core.memory.agent.utils.session_tools import SessionService
 from app.core.memory.agent.utils.template_tools import TemplateService
-from app.db import get_db_context
+from app.core.memory.agent.services.optimized_llm_service import LLMServiceMixin
 
 template_root = os.path.join(PROJECT_ROOT_, 'memory', 'agent', 'utils', 'prompt')
+db_session = next(get_db())
 logger = get_agent_logger(__name__)
 
-
 class VerificationNodeService(LLMServiceMixin):
     """验证节点服务类"""
-
+    
     def __init__(self):
         super().__init__()
         self.template_service = TemplateService(template_root)
 
-
 # 创建全局服务实例
 verification_service = VerificationNodeService()
 
-
 async def Verify_prompt(state: ReadState, messages_deal: VerificationResult):
     """处理验证结果并生成输出格式"""
     storage_type = state.get('storage_type', '')
     user_rag_memory_id = state.get('user_rag_memory_id', '')
     data = state.get('data', '')
-
+    
     # 将 VerificationItem 对象转换为字典列表
     verified_data = []
     if messages_deal.expansion_issue:
@@ -43,7 +40,7 @@ async def Verify_prompt(state: ReadState, messages_deal: VerificationResult):
                 verified_data.append(item.model_dump())
             elif isinstance(item, dict):
                 verified_data.append(item)
-
+    
     Verify_result = {
         "status": messages_deal.split_result,
         "verified_data": verified_data,
@@ -61,37 +58,34 @@ async def Verify_prompt(state: ReadState, messages_deal: VerificationResult):
         }
     }
     return Verify_result
-
-
 async def Verify(state: ReadState):
     logger.info("=== Verify 节点开始执行 ===")
     try:
         content = state.get('data', '')
         end_user_id = state.get('end_user_id', '')
         memory_config = state.get('memory_config', None)
-
+        
         logger.info(f"Verify: content={content[:50] if content else 'empty'}..., end_user_id={end_user_id}")
 
         history = await SessionService(store).get_history(end_user_id, end_user_id, end_user_id)
         logger.info(f"Verify: 获取历史记录完成，history length={len(history)}")
 
         retrieve = state.get("retrieve", {})
-        logger.info(
-            f"Verify: retrieve data type={type(retrieve)}, keys={retrieve.keys() if isinstance(retrieve, dict) else 'N/A'}")
-
+        logger.info(f"Verify: retrieve data type={type(retrieve)}, keys={retrieve.keys() if isinstance(retrieve, dict) else 'N/A'}")
+        
         retrieve_expansion = retrieve.get("Expansion_issue", []) if isinstance(retrieve, dict) else []
         logger.info(f"Verify: Expansion_issue length={len(retrieve_expansion)}")
-
+        
         messages = {
             "Query": content,
             "Expansion_issue": retrieve_expansion
         }
 
         logger.info("Verify: 开始渲染模板")
-
+        
         # 生成 JSON schema 以指导 LLM 输出正确格式
         json_schema = VerificationResult.model_json_schema()
-
+        
         system_prompt = await verification_service.template_service.render_template(
             template_name='split_verify_prompt.jinja2',
             operation_name='split_verify_prompt',
@@ -100,30 +94,29 @@ async def Verify(state: ReadState):
             json_schema=json_schema
         )
         logger.info(f"Verify: 模板渲染完成，prompt length={len(system_prompt)}")
-
+        
         # 使用优化的LLM服务，添加超时保护
         logger.info("Verify: 开始调用 LLM")
         try:
             # 添加 asyncio.wait_for 超时包裹，防止无限等待
             # 超时时间设置为 150 秒（比 LLM 配置的 120 秒稍长）
-
-            with get_db_context() as db_session:
-                structured = await asyncio.wait_for(
-                    verification_service.call_llm_structured(
-                        state=state,
-                        db_session=db_session,
-                        system_prompt=system_prompt,
-                        response_model=VerificationResult,
-                        fallback_value={
-                            "query": content,
-                            "history": history if isinstance(history, list) else [],
-                            "expansion_issue": [],
-                            "split_result": "failed",
-                            "reason": "验证失败或超时"
-                        }
-                    ),
-                    timeout=150.0  # 150秒超时
-                )
+            import asyncio
+            structured = await asyncio.wait_for(
+                verification_service.call_llm_structured(
+                    state=state,
+                    db_session=db_session,
+                    system_prompt=system_prompt,
+                    response_model=VerificationResult,
+                    fallback_value={
+                        "query": content,
+                        "history": history if isinstance(history, list) else [],
+                        "expansion_issue": [],
+                        "split_result": "failed",
+                        "reason": "验证失败或超时"
+                    }
+                ),
+                timeout=150.0  # 150秒超时
+            )
             logger.info(f"Verify: LLM 调用完成，result={structured}")
         except asyncio.TimeoutError:
             logger.error("Verify: LLM 调用超时（150秒），使用 fallback 值")
@@ -134,11 +127,11 @@ async def Verify(state: ReadState):
                 split_result="failed",
                 reason="LLM调用超时"
             )
-
+        
         result = await Verify_prompt(state, structured)
         logger.info("=== Verify 节点执行完成 ===")
         return {"verify": result}
-
+        
     except Exception as e:
         logger.error(f"Verify 节点执行失败: {e}", exc_info=True)
         # 返回失败的验证结果
@@ -159,4 +152,4 @@ async def Verify(state: ReadState):
                     "user_rag_memory_id": state.get('user_rag_memory_id', '')
                 }
             }
-        }
+        }

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

@@ -1,4 +1,3 @@
-from app.cache.memory.interest_memory import InterestMemoryCache
 from app.core.memory.agent.utils.llm_tools import WriteState
 from app.core.memory.agent.utils.write_tools import write
 from app.core.logging_config import get_agent_logger
@@ -11,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
@@ -19,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 = []
@@ -37,19 +35,9 @@ 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}")
 
-        # 写入 neo4j 成功后，删除该用户的兴趣分布缓存，确保下次请求重新生成
-        for lang in ["zh", "en"]:
-            deleted = await InterestMemoryCache.delete_interest_distribution(
-                end_user_id=end_user_id,
-                language=lang,
-            )
-            if deleted:
-                logger.info(f"Invalidated interest distribution cache: end_user_id={end_user_id}, language={lang}")
-
         write_result = {
             "status": "success",
             "data": structured_messages,

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

@@ -5,6 +5,7 @@ from langchain_core.messages import HumanMessage
 from langgraph.constants import START, END
 from langgraph.graph import StateGraph
 
+
 from app.db import get_db
 from app.services.memory_config_service import MemoryConfigService
 
@@ -31,6 +32,7 @@ from app.core.memory.agent.langgraph_graph.routing.routers import (
 )
 
 
+
 @asynccontextmanager
 async def make_read_graph():
     """创建并返回 LangGraph 工作流"""
@@ -47,7 +49,7 @@ async def make_read_graph():
         workflow.add_node("Retrieve_Summary", Retrieve_Summary)
         workflow.add_node("Summary", Summary)
         workflow.add_node("Summary_fails", Summary_fails)
-
+        
         # 添加边
         workflow.add_edge(START, "content_input")
         workflow.add_conditional_edges("content_input", Split_continue)
@@ -60,20 +62,20 @@ async def make_read_graph():
         workflow.add_edge("Summary_fails", END)
         workflow.add_edge("Summary", END)
 
+
         '''-----'''
         # workflow.add_edge("Retrieve", END)
-
+        
         # 编译工作流
         graph = workflow.compile()
         yield graph
-
+        
     except Exception as e:
         print(f"创建工作流失败: {e}")
         raise
     finally:
         print("工作流创建完成")
 
-
 async def main():
     """主函数 - 运行工作流"""
     message = "昨天有什么好看的电影"
@@ -90,19 +92,17 @@ async def main():
         service_name="MemoryAgentService"
     )
     import time
-    start = time.time()
+    start=time.time()
     try:
         async with make_read_graph() as graph:
             config = {"configurable": {"thread_id": end_user_id}}
             # 初始状态 - 包含所有必要字段
-            initial_state = {"messages": [HumanMessage(content=message)], "search_switch": search_switch,
-                             "end_user_id": end_user_id
-                , "storage_type": storage_type, "user_rag_memory_id": user_rag_memory_id,
-                             "memory_config": memory_config}
+            initial_state = {"messages": [HumanMessage(content=message)] ,"search_switch":search_switch,"end_user_id":end_user_id
+                             ,"storage_type":storage_type,"user_rag_memory_id":user_rag_memory_id,"memory_config":memory_config}
             # 获取节点更新信息
             _intermediate_outputs = []
             summary = ''
-
+            
             async for update_event in graph.astream(
                     initial_state,
                     stream_mode="updates",
@@ -110,7 +110,7 @@ async def main():
             ):
                 for node_name, node_data in update_event.items():
                     print(f"处理节点: {node_name}")
-
+                    
                     # 处理不同Summary节点的返回结构
                     if 'Summary' in node_name:
                         if 'InputSummary' in node_data and 'summary_result' in node_data['InputSummary']:
@@ -125,22 +125,23 @@ async def main():
                     spit_data = node_data.get('spit_data', {}).get('_intermediate', None)
                     if spit_data and spit_data != [] and spit_data != {}:
                         _intermediate_outputs.append(spit_data)
-
+                    
                     # Problem_Extension 节点
                     problem_extension = node_data.get('problem_extension', {}).get('_intermediate', None)
                     if problem_extension and problem_extension != [] and problem_extension != {}:
                         _intermediate_outputs.append(problem_extension)
-
+                    
                     # Retrieve 节点
                     retrieve_node = node_data.get('retrieve', {}).get('_intermediate_outputs', None)
                     if retrieve_node and retrieve_node != [] and retrieve_node != {}:
                         _intermediate_outputs.extend(retrieve_node)
-
+                    
                     # Verify 节点
                     verify_n = node_data.get('verify', {}).get('_intermediate', None)
                     if verify_n and verify_n != [] and verify_n != {}:
                         _intermediate_outputs.append(verify_n)
 
+                    
                     # Summary 节点
                     summary_n = node_data.get('summary', {}).get('_intermediate', None)
                     if summary_n and summary_n != [] and summary_n != {}:
@@ -160,20 +161,17 @@ async def main():
             #
             print(f"=== 最终摘要 ===")
             print(summary)
-
+                
     except Exception as e:
         import traceback
         traceback.print_exc()
-    finally:
-        db_session.close()
 
-    end = time.time()
-    print(100 * 'y')
-    print(f"总耗时: {end - start}s")
-    print(100 * 'y')
+    end=time.time()
+    print(100*'y')
+    print(f"总耗时: {end-start}s")
+    print(100*'y')
 
 
 if __name__ == "__main__":
     import asyncio
-
     asyncio.run(main())

api/app/core/memory/agent/langgraph_graph/routing/write_router.py

@@ -1,238 +0,0 @@
-import json
-import os
-
-from app.core.logging_config import get_agent_logger
-from app.core.memory.agent.langgraph_graph.tools.write_tool import  format_parsing,  messages_parse
-from app.core.memory.agent.langgraph_graph.write_graph import make_write_graph, long_term_storage
-
-from app.core.memory.agent.models.write_aggregate_model import WriteAggregateModel
-from app.core.memory.agent.utils.llm_tools import PROJECT_ROOT_
-from app.core.memory.agent.utils.redis_tool import write_store
-from app.core.memory.agent.utils.redis_tool import count_store
-from app.core.memory.agent.utils.template_tools import TemplateService
-from app.core.memory.utils.llm.llm_utils import MemoryClientFactory
-from app.db import get_db_context, get_db
-from app.repositories.memory_short_repository import LongTermMemoryRepository
-from app.schemas.memory_agent_schema import AgentMemory_Long_Term
-from app.services.memory_konwledges_server import write_rag
-from app.services.task_service import get_task_memory_write_result
-from app.tasks import write_message_task
-from app.utils.config_utils import resolve_config_id
-logger = get_agent_logger(__name__)
-template_root = os.path.join(PROJECT_ROOT_, 'memory', 'agent', 'utils', 'prompt')
-
-async def write_rag_agent(end_user_id, user_message, ai_message, user_rag_memory_id):
-    # RAG 模式：组合消息为字符串格式（保持原有逻辑）
-    combined_message = f"user: {user_message}\nassistant: {ai_message}"
-    await write_rag(end_user_id, combined_message, user_rag_memory_id)
-    logger.info(f'RAG_Agent:{end_user_id};{user_rag_memory_id}')
-async def write(storage_type, end_user_id, user_message, ai_message, user_rag_memory_id, actual_end_user_id,
-                actual_config_id, long_term_messages=[]):
-    """
-    写入记忆（支持结构化消息）
-
-    Args:
-        storage_type: 存储类型 (neo4j/rag)
-        end_user_id: 终端用户ID
-        user_message: 用户消息内容
-        ai_message: AI 回复内容
-        user_rag_memory_id: RAG 记忆ID
-        actual_end_user_id: 实际用户ID
-        actual_config_id: 配置ID
-
-    逻辑说明：
-    - RAG 模式：组合 user_message 和 ai_message 为字符串格式，保持原有逻辑不变
-    - Neo4j 模式：使用结构化消息列表
-      1. 如果 user_message 和 ai_message 都不为空：创建配对消息 [user, assistant]
-      2. 如果只有 user_message：创建单条用户消息 [user]（用于历史记忆场景）
-      3. 每条消息会被转换为独立的 Chunk，保留 speaker 字段
-    """
-
-    db = next(get_db())
-    try:
-        actual_config_id = resolve_config_id(actual_config_id, db)
-        # Neo4j 模式：使用结构化消息列表
-        structured_messages = []
-
-        # 始终添加用户消息（如果不为空）
-        if isinstance(user_message, str) and user_message.strip() != "":
-            structured_messages.append({"role": "user", "content": user_message})
-
-        # 只有当 AI 回复不为空时才添加 assistant 消息
-        if isinstance(ai_message, str) and ai_message.strip() != "":
-            structured_messages.append({"role": "assistant", "content": ai_message})
-
-        # 如果提供了 long_term_messages，使用它替代 structured_messages
-        if long_term_messages and isinstance(long_term_messages, list):
-            structured_messages = long_term_messages
-        elif long_term_messages and isinstance(long_term_messages, str):
-            # 如果是 JSON 字符串，先解析
-            try:
-                structured_messages = json.loads(long_term_messages)
-            except json.JSONDecodeError:
-                logger.error(f"Failed to parse long_term_messages as JSON: {long_term_messages}")
-
-        # 如果没有消息，直接返回
-        if not structured_messages:
-            logger.warning(f"No messages to write for user {actual_end_user_id}")
-            return
-
-        logger.info(
-            f"[WRITE] Submitting Celery task - user={actual_end_user_id}, messages={len(structured_messages)}, config={actual_config_id}")
-        write_id = write_message_task.delay(
-            actual_end_user_id,  # end_user_id: 用户ID
-            structured_messages,  # message: JSON 字符串格式的消息列表
-            str(actual_config_id),  # config_id: 配置ID字符串
-            storage_type,  # storage_type: "neo4j"
-            user_rag_memory_id or ""  # user_rag_memory_id: RAG记忆ID（Neo4j模式下不使用）
-        )
-        logger.info(f"[WRITE] Celery task submitted - task_id={write_id}")
-        write_status = get_task_memory_write_result(str(write_id))
-        logger.info(f'[WRITE] Task result - user={actual_end_user_id}, status={write_status}')
-    finally:
-        db.close()
-
-async def term_memory_save(long_term_messages,actual_config_id,end_user_id,type,scope):
-    with get_db_context() as db_session:
-        repo = LongTermMemoryRepository(db_session)
-
-
-        from app.core.memory.agent.utils.redis_tool import write_store
-        result = write_store.get_session_by_userid(end_user_id)
-        if type==AgentMemory_Long_Term.STRATEGY_CHUNK or AgentMemory_Long_Term.STRATEGY_AGGREGATE:
-            data = await format_parsing(result, "dict")
-            chunk_data = data[:scope]
-            if len(chunk_data)==scope:
-                repo.upsert(end_user_id, chunk_data)
-                logger.info(f'---------写入短长期-----------')
-        else:
-            long_time_data = write_store.find_user_recent_sessions(end_user_id, 5)
-            long_messages = await messages_parse(long_time_data)
-            repo.upsert(end_user_id, long_messages)
-            logger.info(f'写入短长期：')
-
-
-
-'''根据窗口'''
-async def window_dialogue(end_user_id,langchain_messages,memory_config,scope):
-    '''
-    根据窗口获取redis数据,写入neo4j：
-     Args:
-        end_user_id: 终端用户ID
-        memory_config: 内存配置对象
-        langchain_messages：原始数据LIST
-        scope：窗口大小
-    '''
-    scope=scope
-    is_end_user_id = count_store.get_sessions_count(end_user_id)
-    if is_end_user_id is not False:
-        is_end_user_id = count_store.get_sessions_count(end_user_id)[0]
-        redis_messages = count_store.get_sessions_count(end_user_id)[1]
-    if is_end_user_id and int(is_end_user_id) != int(scope):
-        is_end_user_id += 1
-        langchain_messages += redis_messages
-        count_store.update_sessions_count(end_user_id, is_end_user_id, langchain_messages)
-    elif int(is_end_user_id) == int(scope):
-        logger.info('写入长期记忆NEO4J')
-        formatted_messages = (redis_messages)
-        # 获取 config_id（如果 memory_config 是对象，提取 config_id；否则直接使用）
-        if hasattr(memory_config, 'config_id'):
-            config_id = memory_config.config_id
-        else:
-            config_id = memory_config
-        
-        await write(AgentMemory_Long_Term.STORAGE_NEO4J, end_user_id, "", "", None, end_user_id,
-                config_id, formatted_messages)
-        count_store.update_sessions_count(end_user_id, 1, langchain_messages)
-    else:
-        count_store.save_sessions_count(end_user_id, 1, langchain_messages)
-
-
-"""根据时间"""
-async def memory_long_term_storage(end_user_id,memory_config,time):
-    '''
-    根据时间获取redis数据,写入neo4j：
-     Args:
-        end_user_id: 终端用户ID
-        memory_config: 内存配置对象
-    '''
-    long_time_data = write_store.find_user_recent_sessions(end_user_id, time)
-    format_messages = (long_time_data)
-    messages=[]
-    memory_config=memory_config.config_id
-    for i in format_messages:
-        message=json.loads(i['Query'])
-        messages+= message
-    if format_messages!=[]:
-        await write(AgentMemory_Long_Term.STORAGE_NEO4J, end_user_id, "", "", None, end_user_id,
-                    memory_config, messages)
-'''聚合判断'''
-async def aggregate_judgment(end_user_id: str, ori_messages: list, memory_config) -> dict:
-    """
-    聚合判断函数：判断输入句子和历史消息是否描述同一事件
-    
-    Args:
-        end_user_id: 终端用户ID
-        ori_messages: 原始消息列表，格式如 [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]
-        memory_config: 内存配置对象
-    """
-
-    try:
-        # 1. 获取历史会话数据（使用新方法）
-        result = write_store.get_all_sessions_by_end_user_id(end_user_id)
-        history = await format_parsing(result)
-        if not result:
-            history = []
-        else:
-            history = await format_parsing(result)
-        json_schema = WriteAggregateModel.model_json_schema()
-        template_service = TemplateService(template_root)
-        system_prompt = await template_service.render_template(
-            template_name='write_aggregate_judgment.jinja2',
-            operation_name='aggregate_judgment',
-            history=history,
-            sentence=ori_messages,
-            json_schema=json_schema
-        )
-        with get_db_context() as db_session:
-            factory = MemoryClientFactory(db_session)
-            llm_client = factory.get_llm_client(memory_config.llm_model_id)
-            messages = [
-                {
-                    "role": "user",
-                    "content": system_prompt
-                }
-            ]
-            structured = await llm_client.response_structured(
-                messages=messages,
-                response_model=WriteAggregateModel
-            )
-        output_value = structured.output
-        if isinstance(output_value, list):
-            output_value = [
-                {"role": msg.role, "content": msg.content} 
-                for msg in output_value
-            ]
-
-        result_dict = {
-            "is_same_event": structured.is_same_event,
-            "output": output_value
-        }
-        if not structured.is_same_event:
-            logger.info(result_dict)
-            await write("neo4j", end_user_id, "", "", None, end_user_id,
-                        memory_config.config_id, output_value)
-        return result_dict
-        
-    except Exception as e:
-        print(f"[aggregate_judgment] 发生错误: {e}")
-        import traceback
-        traceback.print_exc()
-        
-        return {
-            "is_same_event": False,
-            "output": ori_messages,
-            "messages": ori_messages,
-            "history": history if 'history' in locals() else [],
-            "error": str(e)
-        }

api/app/core/memory/agent/langgraph_graph/tools/tool.py

@@ -186,11 +186,10 @@ def create_hybrid_retrieval_tool_async(memory_config, **search_params):
             清理后的数据
         """
         # 需要过滤的字段列表
-        # TODO: fact_summary 功能暂时禁用，待后续开发完善后启用
         fields_to_remove = {
             'invalid_at', 'valid_at', 'chunk_id_from_rel', 'entity_ids', 
             'expired_at', 'created_at', 'chunk_id', 'id', 'apply_id', 
-            'user_id', 'statement_ids', 'updated_at',"chunk_ids"  ,"fact_summary"
+            'user_id', 'statement_ids', 'updated_at',"chunk_ids","fact_summary"
         }
         
         if isinstance(data, dict):

api/app/core/memory/agent/langgraph_graph/tools/write_tool.py

@@ -1,72 +0,0 @@
-import json
-
-from langchain_core.messages import HumanMessage, AIMessage
-async def format_parsing(messages: list,type:str='string'):
-    """
-    格式化解析消息列表
-    
-    Args:
-        messages: 消息列表
-        type: 返回类型 ('string' 或 'dict')
-        
-    Returns:
-        格式化后的消息列表
-    """
-    result = []
-    user=[]
-    ai=[]
-
-    for message in messages:
-        hstory_messages = message['messages']
-        for history_messag in hstory_messages.strip().splitlines():
-            history_messag = json.loads(history_messag)
-            for content in history_messag:
-                role = content['role']
-                content = content['content']
-                if type == "string":
-                    if role == 'human' or role=="user":
-                        content = '用户:' + content
-                    else:
-                        content = 'AI:' + content
-                    result.append(content)
-                if type == "dict" :
-                    if role == 'human'  or role=="user":
-                        user.append( content)
-                    else:
-                        ai.append(content)
-    if type == "dict":
-        for key,values in zip(user,ai):
-            result.append({key:values})
-    return result
-
-async def messages_parse(messages: list | dict):
-    user=[]
-    ai=[]
-    database=[]
-    for message in messages:
-        Query = message['Query']
-        Query = json.loads(Query)
-        for data in Query:
-            role = data['role']
-            if role == "human":
-                user.append(data['content'])
-            if role == "ai":
-                ai.append(data['content'])
-    for key, values in zip(user, ai):
-        database.append({key, values})
-    return  database
-
-
-async def agent_chat_messages(user_content,ai_content):
-    messages = [
-        {
-            "role": "user",
-            "content": f"{user_content}"
-        },
-        {
-            "role": "assistant",
-            "content": f"{ai_content}"
-        }
-
-    ]
-    return messages

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

@@ -1,26 +1,27 @@
+
 import asyncio
-import json
 import sys
 import warnings
 from contextlib import asynccontextmanager
+
+
+from langchain_core.messages import HumanMessage
 from langgraph.constants import END, START
 from langgraph.graph import StateGraph
 
-from app.db import get_db, get_db_context
+
+from app.db import get_db
 from app.core.logging_config import get_agent_logger
 from app.core.memory.agent.utils.llm_tools import WriteState
 from app.core.memory.agent.langgraph_graph.nodes.write_nodes import write_node
-from app.schemas.memory_agent_schema import AgentMemory_Long_Term
+from app.core.memory.agent.langgraph_graph.nodes.data_nodes import content_input_write
 from app.services.memory_config_service import MemoryConfigService
 
-
 warnings.filterwarnings("ignore", category=RuntimeWarning)
 logger = get_agent_logger(__name__)
 
 if sys.platform.startswith("win"):
     asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
-
-
 @asynccontextmanager
 async def make_write_graph():
     """
@@ -33,6 +34,14 @@ async def make_write_graph():
         end_user_id: Group identifier
         memory_config: MemoryConfig object containing all configuration
     """
+    # workflow = StateGraph(WriteState)
+    # workflow.add_node("content_input", content_input_write)
+    # workflow.add_node("save_neo4j", write_node)
+    # workflow.add_edge(START, "content_input")
+    # workflow.add_edge("content_input", "save_neo4j")
+    # workflow.add_edge("save_neo4j", END)
+    #
+    # graph = workflow.compile()
     workflow = StateGraph(WriteState)
     workflow.add_node("save_neo4j", write_node)
     workflow.add_edge(START, "save_neo4j")
@@ -42,63 +51,43 @@ async def make_write_graph():
 
     yield graph
 
-async def long_term_storage(long_term_type:str="chunk",langchain_messages:list=[],memory_config:str='',end_user_id:str='',scope:int=6):
-    from app.core.memory.agent.langgraph_graph.routing.write_router import memory_long_term_storage, window_dialogue,aggregate_judgment
-    from app.core.memory.agent.utils.redis_tool import write_store
-    write_store.save_session_write(end_user_id,  (langchain_messages))
+
+async def main():
+    """主函数 - 运行工作流"""
+    message = "今天周一"
+    end_user_id = 'new_2025test1103'  # 组ID
+
+
     # 获取数据库会话
-    with get_db_context() as db_session:
-        config_service = MemoryConfigService(db_session)
-        memory_config = config_service.load_memory_config(
-            config_id=memory_config,  # 改为整数
-            service_name="MemoryAgentService"
-        )
-        if long_term_type=='chunk':
-            '''方案一:对话窗口6轮对话'''
-            await window_dialogue(end_user_id,langchain_messages,memory_config,scope)
-        if long_term_type=='time':
-            """时间"""
-            await memory_long_term_storage(end_user_id, memory_config,5)
-        if  long_term_type=='aggregate':
-            """方案三：聚合判断"""
-            await aggregate_judgment(end_user_id, langchain_messages, memory_config)
+    db_session = next(get_db())
+    config_service = MemoryConfigService(db_session)
+    memory_config = config_service.load_memory_config(
+        config_id=17,  # 改为整数
+        service_name="MemoryAgentService"
+    )
+    try:
+        async with make_write_graph() as graph:
+            config = {"configurable": {"thread_id": end_user_id}}
+            # 初始状态 - 包含所有必要字段
+            initial_state = {"messages": [HumanMessage(content=message)],  "end_user_id": end_user_id, "memory_config": memory_config}
+
+            # 获取节点更新信息
+            async for update_event in graph.astream(
+                    initial_state,
+                    stream_mode="updates",
+                    config=config
+            ):
+                for node_name, node_data in update_event.items():
+                    if 'save_neo4j'==node_name:
+                        massages=node_data
+            massages=massages.get('write_result')['status']
+            print(massages)  # | 更新数据: {node_data}
+
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
 
 
-
-async def write_long_term(storage_type,end_user_id,message_chat,aimessages,user_rag_memory_id,actual_config_id):
-    from app.core.memory.agent.langgraph_graph.routing.write_router import write_rag_agent
-    from app.core.memory.agent.langgraph_graph.routing.write_router import term_memory_save
-    from app.core.memory.agent.langgraph_graph.tools.write_tool import  agent_chat_messages
-    if storage_type == AgentMemory_Long_Term.STORAGE_RAG:
-        await write_rag_agent(end_user_id, message_chat, aimessages, user_rag_memory_id)
-    else:
-        # AI 回复写入（用户消息和 AI 回复配对，一次性写入完整对话）
-        CHUNK = AgentMemory_Long_Term.STRATEGY_CHUNK
-        SCOPE = AgentMemory_Long_Term.DEFAULT_SCOPE
-        long_term_messages = await agent_chat_messages(message_chat, aimessages)
-        await long_term_storage(long_term_type=CHUNK, langchain_messages=long_term_messages,
-                                memory_config=actual_config_id, end_user_id=end_user_id, scope=SCOPE)
-        await term_memory_save(long_term_messages, actual_config_id, end_user_id, CHUNK, scope=SCOPE)
-
-# async def main():
-#     """主函数 - 运行工作流"""
-#     langchain_messages = [
-#     {
-#       "role": "user",
-#       "content": "今天周五去爬山"
-#     },
-#     {
-#       "role": "assistant",
-#       "content": "好耶"
-#     }
-#
-#   ]
-#     end_user_id = '837fee1b-04a2-48ee-94d7-211488908940'  # 组ID
-#     memory_config="08ed205c-0f05-49c3-8e0c-a580d28f5fd4"
-#     await long_term_storage(long_term_type="chunk",langchain_messages=langchain_messages,memory_config=memory_config,end_user_id=end_user_id,scope=2)
-#
-#
-#
-# if __name__ == "__main__":
-#     import asyncio
-#     asyncio.run(main())
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

api/app/core/memory/agent/models/write_aggregate_model.py

@@ -1,28 +0,0 @@
-"""Pydantic models for write aggregate judgment operations."""
-
-from typing import List, Union
-from pydantic import BaseModel, Field
-
-
-class MessageItem(BaseModel):
-    """Individual message item in conversation."""
-    
-    role: str = Field(..., description="角色：user 或 assistant")
-    content: str = Field(..., description="消息内容")
-
-
-class WriteAggregateResponse(BaseModel):
-    """Response model for aggregate judgment containing judgment result and output."""
-    
-    is_same_event: bool = Field(
-        ..., 
-        description="是否是同一事件。True表示是同一事件，False表示不同事件"
-    )
-    output: Union[List[MessageItem], bool] = Field(
-        ..., 
-        description="如果is_same_event为True，返回False；如果is_same_event为False，返回消息列表"
-    )
-
-
-# 为了保持向后兼容，保留旧的类名作为别名
-WriteAggregateModel = WriteAggregateResponse

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

@@ -21,7 +21,7 @@ async def get_chunked_dialogs(
         end_user_id: Group identifier
         messages: Structured message list [{"role": "user", "content": "..."}, ...]
         ref_id: Reference identifier
-        config_id: Configuration ID for processing (used to load pruning config)
+        config_id: Configuration ID for processing
 
     Returns:
         List of DialogData objects with generated chunks
@@ -57,63 +57,6 @@ async def get_chunked_dialogs(
         end_user_id=end_user_id,
         config_id=config_id
     )
-    
-    # 语义剪枝步骤（在分块之前）
-    try:
-        from app.core.memory.storage_services.extraction_engine.data_preprocessing.data_pruning import SemanticPruner
-        from app.core.memory.models.config_models import PruningConfig
-        from app.db import get_db_context
-        from app.services.memory_config_service import MemoryConfigService
-        from app.core.memory.utils.llm.llm_utils import MemoryClientFactory
-        
-        # 加载剪枝配置
-        pruning_config = None
-        if config_id:
-            try:
-                with get_db_context() as db:
-                    # 使用 MemoryConfigService 加载完整的 MemoryConfig 对象
-                    config_service = MemoryConfigService(db)
-                    memory_config = config_service.load_memory_config(
-                        config_id=config_id,
-                        service_name="semantic_pruning"
-                    )
-                    
-                    if memory_config:
-                        pruning_config = PruningConfig(
-                            pruning_switch=memory_config.pruning_enabled,
-                            pruning_scene=memory_config.pruning_scene or "education",
-                            pruning_threshold=memory_config.pruning_threshold,
-                            scene_id=str(memory_config.scene_id) if memory_config.scene_id else None,
-                            ontology_classes=memory_config.ontology_classes,
-                        )
-                        logger.info(f"[剪枝] 加载配置: switch={pruning_config.pruning_switch}, scene={pruning_config.pruning_scene}, threshold={pruning_config.pruning_threshold}")
-                        
-                        # 获取LLM客户端用于剪枝
-                        if pruning_config.pruning_switch:
-                            factory = MemoryClientFactory(db)
-                            llm_client = factory.get_llm_client_from_config(memory_config)
-                            
-                            # 执行剪枝 - 使用 prune_dataset 支持消息级剪枝
-                            pruner = SemanticPruner(config=pruning_config, llm_client=llm_client)
-                            original_msg_count = len(dialog_data.context.msgs)
-                            
-                            # 使用 prune_dataset 而不是 prune_dialog
-                            # prune_dataset 会进行消息级剪枝，即使对话整体相关也会删除不重要消息
-                            pruned_dialogs = await pruner.prune_dataset([dialog_data])
-                            
-                            if pruned_dialogs:
-                                dialog_data = pruned_dialogs[0]
-                                remaining_msg_count = len(dialog_data.context.msgs)
-                                deleted_count = original_msg_count - remaining_msg_count
-                                logger.info(f"[剪枝] 完成: 原始{original_msg_count}条 -> 保留{remaining_msg_count}条 (删除{deleted_count}条)")
-                            else:
-                                logger.warning("[剪枝] prune_dataset 返回空列表")
-                        else:
-                            logger.info("[剪枝] 配置中剪枝开关关闭，跳过剪枝")
-            except Exception as e:
-                logger.warning(f"[剪枝] 加载配置失败，跳过剪枝: {e}", exc_info=True)
-    except Exception as e:
-        logger.warning(f"[剪枝] 执行失败，跳过剪枝: {e}", exc_info=True)
 
     chunker = DialogueChunker(chunker_strategy)
     extracted_chunks = await chunker.process_dialogue(dialog_data)

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

@@ -0,0 +1,56 @@
+
+import asyncio
+from typing import Dict, Optional
+from app.core.memory.utils.llm.llm_utils import get_llm_client_fast
+from app.db import get_db
+from app.core.logging_config import get_agent_logger
+
+logger = get_agent_logger(__name__)
+
+class LLMClientPool:
+    """LLM客户端连接池"""
+    
+    def __init__(self, max_size: int = 5):
+        self.max_size = max_size
+        self.pools: Dict[str, asyncio.Queue] = {}
+        self.active_clients: Dict[str, int] = {}
+        
+    async def get_client(self, llm_model_id: str):
+        """获取LLM客户端"""
+        if llm_model_id not in self.pools:
+            self.pools[llm_model_id] = asyncio.Queue(maxsize=self.max_size)
+            self.active_clients[llm_model_id] = 0
+            
+        pool = self.pools[llm_model_id]
+        
+        try:
+            # 尝试从池中获取客户端
+            client = pool.get_nowait()
+            logger.debug(f"从池中获取LLM客户端: {llm_model_id}")
+            return client
+        except asyncio.QueueEmpty:
+            # 池为空，创建新客户端
+            if self.active_clients[llm_model_id] < self.max_size:
+                db_session = next(get_db())
+                client = get_llm_client_fast(llm_model_id, db_session)
+                self.active_clients[llm_model_id] += 1
+                logger.debug(f"创建新LLM客户端: {llm_model_id}")
+                return client
+            else:
+                # 等待可用客户端
+                logger.debug(f"等待LLM客户端可用: {llm_model_id}")
+                return await pool.get()
+                
+    async def return_client(self, llm_model_id: str, client):
+        """归还LLM客户端到池中"""
+        if llm_model_id in self.pools:
+            try:
+                self.pools[llm_model_id].put_nowait(client)
+                logger.debug(f"归还LLM客户端到池: {llm_model_id}")
+            except asyncio.QueueFull:
+                # 池已满，丢弃客户端
+                self.active_clients[llm_model_id] -= 1
+                logger.debug(f"池已满，丢弃LLM客户端: {llm_model_id}")
+
+# 全局客户端池
+llm_client_pool = LLMClientPool()

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/prompt/write_aggregate_judgment.jinja2

@@ -1,57 +0,0 @@
-输入句子：{{sentence}}
-历史消息：{{history}}
-
-# 你的角色
-你是一个擅长事件聚合与语义判断的专家。
-
-# 你的任务
-结合历史消息和输入句子，判断它们是否在描述**同一件事件或同一事件链**。
-
-以下情况视为"同一事件"（需要返回 is_same_event=True, output=False）：
-- 描述的是同一个具体事件或事实
-- 存在明显的因果关系、前后发展关系
-- 是对同一事件的补充、解释、追问或延展
-- 逻辑上属于同一语境下的连续讨论
-
-以下情况视为"不同事件"（需要返回 is_same_event=False, output=消息列表）：
-- 话题不同，事件主体不同
-- 时间、地点、对象明显不同
-- 只是语义相似，但并非同一具体事件
-- 无直接事件、因果或逻辑关联
-
-# 输出规则（非常重要）
-你必须按照以下JSON格式输出：
-
-**如果是同一事件：**
-```json
-{
-  "is_same_event": true,
-  "output": false
-}
-```
-
-**如果不是同一事件：**
-```json
-{
-  "is_same_event": false,
-  "output": [
-    {
-      "role": "user",
-      "content": "输入句子的内容"
-    },
-    {
-      "role": "assistant",
-      "content": "对应的回复内容"
-    }
-  ]
-}
-```
-
-# JSON Schema
-{{json_schema}}
-
-# 注意事项
-- 必须严格按照上述格式输出
-- output 字段：如果是同一事件返回 false，如果不是同一事件返回完整的消息列表
-- 消息列表必须包含 role 和 content 字段
-- 不要输出任何解释、分析或多余内容

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

@@ -1,186 +0,0 @@
-import json
-from typing import Any, List, Dict, Optional
-from datetime import datetime, timedelta
-
-
-def serialize_messages(messages: Any) -> str:
-    """
-    将消息序列化为 JSON 字符串，支持 LangChain 消息对象
-
-    Args:
-        messages: 可以是 list、dict、string 或 LangChain 消息对象列表
-
-    Returns:
-        str: JSON 字符串
-    """
-    if isinstance(messages, str):
-        return messages
-
-    if isinstance(messages, (list, tuple)):
-        # 检查是否是 LangChain 消息对象列表
-        serialized_list = []
-        for msg in messages:
-            if hasattr(msg, 'type') and hasattr(msg, 'content'):
-                # LangChain 消息对象
-                serialized_list.append({
-                    'type': msg.type,
-                    'content': msg.content,
-                    'role': getattr(msg, 'role', msg.type)
-                })
-            elif isinstance(msg, dict):
-                serialized_list.append(msg)
-            else:
-                serialized_list.append(str(msg))
-        return json.dumps(serialized_list, ensure_ascii=False)
-
-    if isinstance(messages, dict):
-        return json.dumps(messages, ensure_ascii=False)
-
-    # 其他类型转为字符串
-    return str(messages)
-
-
-def deserialize_messages(messages_str: str) -> Any:
-    """
-    将 JSON 字符串反序列化为原始格式
-
-    Args:
-        messages_str: JSON 字符串
-
-    Returns:
-        反序列化后的对象（list、dict 或 string）
-    """
-    if not messages_str:
-        return []
-
-    try:
-        return json.loads(messages_str)
-    except (json.JSONDecodeError, TypeError):
-        return messages_str
-
-
-def fix_encoding(text: str) -> str:
-    """
-    修复错误编码的文本
-    
-    Args:
-        text: 需要修复的文本
-        
-    Returns:
-        str: 修复后的文本
-    """
-    if not text or not isinstance(text, str):
-        return text
-    try:
-        # 尝试修复 Latin-1 误编码为 UTF-8 的情况
-        return text.encode('latin-1').decode('utf-8')
-    except (UnicodeDecodeError, UnicodeEncodeError):
-        # 如果修复失败，返回原文本
-        return text
-
-
-def format_session_data(data: Dict[str, Any], include_time: bool = False) -> Dict[str, Any]:
-    """
-    格式化会话数据为统一的输出格式
-    
-    Args:
-        data: 原始会话数据
-        include_time: 是否包含时间字段
-        
-    Returns:
-        Dict: 格式化后的数据 {"Query": "...", "Answer": "...", "starttime": "..."}
-    """
-    result = {
-        "Query": fix_encoding(data.get('messages', '')),
-        "Answer": fix_encoding(data.get('aimessages', ''))
-    }
-    
-    if include_time:
-        result["starttime"] = data.get('starttime', '')
-    
-    return result
-
-
-def filter_by_time_range(items: List[Dict], minutes: int) -> List[Dict]:
-    """
-    根据时间范围过滤数据
-    
-    Args:
-        items: 包含 starttime 字段的数据列表
-        minutes: 时间范围（分钟）
-        
-    Returns:
-        List[Dict]: 过滤后的数据列表
-    """
-    time_threshold = datetime.now() - timedelta(minutes=minutes)
-    time_threshold_str = time_threshold.strftime("%Y-%m-%d %H:%M:%S")
-    
-    filtered_items = []
-    for item in items:
-        starttime = item.get('starttime', '')
-        if starttime and starttime >= time_threshold_str:
-            filtered_items.append(item)
-    
-    return filtered_items
-
-
-def sort_and_limit_results(items: List[Dict], limit: int = 6, 
-                           remove_time: bool = True) -> List[Dict]:
-    """
-    对结果进行排序、限制数量并移除时间字段
-    
-    Args:
-        items: 数据列表
-        limit: 最大返回数量
-        remove_time: 是否移除 starttime 字段
-        
-    Returns:
-        List[Dict]: 处理后的数据列表
-    """
-    # 按时间降序排序（最新的在前）
-    items.sort(key=lambda x: x.get('starttime', ''), reverse=True)
-    
-    # 限制数量
-    result_items = items[:limit]
-    
-    # 移除 starttime 字段
-    if remove_time:
-        for item in result_items:
-            item.pop('starttime', None)
-    
-    # 如果结果少于1条，返回空列表
-    if len(result_items) < 1:
-        return []
-    
-    return result_items
-
-
-def generate_session_key(session_id: str, key_type: str = "session") -> str:
-    """
-    生成 Redis key
-    
-    Args:
-        session_id: 会话ID
-        key_type: key 类型 ("session", "read", "write", "count")
-        
-    Returns:
-        str: Redis key
-    """
-    if key_type == "count":
-        return f"session:count:{session_id}"
-    elif key_type == "write":
-        return f"session:write:{session_id}"
-    elif key_type == "session" or key_type == "read":
-        return f"session:{session_id}"
-    else:
-        return f"session:{session_id}"
-
-
-def get_current_timestamp() -> str:
-    """
-    获取当前时间戳字符串
-    
-    Returns:
-        str: 格式化的时间字符串 "YYYY-MM-DD HH:MM:SS"
-    """
-    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

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

@@ -1,445 +1,11 @@
 import redis
 import uuid
+from datetime import datetime
 from app.core.config import settings
-from typing import List, Dict, Any, Optional, Union
-
-from app.core.memory.agent.utils.redis_base import (
-    serialize_messages, 
-    deserialize_messages,
-    fix_encoding,
-    format_session_data,
-    filter_by_time_range,
-    sort_and_limit_results,
-    generate_session_key,
-    get_current_timestamp
-)
-
-
-
-
-class RedisWriteStore:
-    """Redis Write 类型存储类，用于管理 save_session_write 相关的数据"""
-    
-    def __init__(self, host='localhost', port=6379, db=0, password=None, session_id=''):
-        """
-        初始化 Redis 连接
-        
-        Args:
-            host: Redis 主机地址
-            port: Redis 端口
-            db: Redis 数据库编号
-            password: Redis 密码
-            session_id: 会话ID
-        """
-        self.r = redis.Redis(
-            host=host,
-            port=port,
-            db=db,
-            password=password,
-            decode_responses=True,
-            encoding='utf-8'
-        )
-        self.uudi = session_id
-
-    def save_session_write(self, userid: str, messages: str) -> str:
-        """
-        写入一条会话数据，返回 session_id
-
-        Args:
-            userid: 用户ID
-            messages: 用户消息
-
-        Returns:
-            str: 新生成的 session_id
-        """
-        try:
-            messages = serialize_messages(messages)
-            session_id = str(uuid.uuid4())
-            key = generate_session_key(session_id, key_type="write")
-
-            pipe = self.r.pipeline()
-            pipe.hset(key, mapping={
-                "id": self.uudi,
-                "sessionid": userid,
-                "messages": messages,
-                "starttime": get_current_timestamp()
-            })
-            result = pipe.execute()
-
-            print(f"[save_session_write] 保存结果: {result[0]}, session_id: {session_id}")
-            return session_id
-        except Exception as e:
-            print(f"[save_session_write] 保存会话失败: {e}")
-            raise e
-
-    def get_session_by_userid(self, userid: str) -> Union[List[Dict[str, str]], bool]:
-        """
-        通过 save_session_write 的 userid 获取 sessionid 和 messages
-        
-        Args:
-            userid: 用户ID (对应 sessionid 字段)
-            
-        Returns:
-            List[Dict] 或 False: 如果找到数据返回 [{"sessionid": "...", "messages": "..."}, ...]，否则返回 False
-        """
-        try:
-            # 只查询 write 类型的 key
-            keys = self.r.keys('session:write:*')
-            if not keys:
-                return False
-
-            # 批量获取数据
-            pipe = self.r.pipeline()
-            for key in keys:
-                pipe.hgetall(key)
-            all_data = pipe.execute()
-
-            # 筛选符合 userid 的数据
-            results = []
-            for key, data in zip(keys, all_data):
-                if not data:
-                    continue
-                
-                # 从 write 类型读取，匹配 sessionid 字段
-                if data.get('sessionid') == userid:
-                    # 从 key 中提取 session_id: session:write:{session_id}
-                    session_id = key.split(':')[-1]
-                    results.append({
-                        "sessionid": session_id,
-                        "messages": fix_encoding(data.get('messages', ''))
-                    })
-            
-            if not results:
-                return False
-            
-            print(f"[get_session_by_userid] userid={userid}, 找到 {len(results)} 条数据")
-            return results
-        except Exception as e:
-            print(f"[get_session_by_userid] 查询失败: {e}")
-            return False
-    
-    def get_all_sessions_by_end_user_id(self, end_user_id: str) -> Union[List[Dict[str, Any]], bool]:
-        """
-        通过 end_user_id 获取所有 write 类型的会话数据
-        
-        Args:
-            end_user_id: 终端用户ID (对应 sessionid 字段)
-            
-        Returns:
-            List[Dict] 或 False: 如果找到数据返回完整的会话信息列表，否则返回 False
-            
-        返回格式:
-        [
-            {
-                "session_id": "uuid",
-                "id": "...",
-                "sessionid": "end_user_id",
-                "messages": "...",
-                "starttime": "timestamp"
-            },
-            ...
-        ]
-        """
-        try:
-            # 只查询 write 类型的 key
-            keys = self.r.keys('session:write:*')
-            if not keys:
-                print(f"[get_all_sessions_by_end_user_id] 没有找到任何 write 类型的会话")
-                return False
-
-            # 批量获取数据
-            pipe = self.r.pipeline()
-            for key in keys:
-                pipe.hgetall(key)
-            all_data = pipe.execute()
-
-            # 筛选符合 end_user_id 的数据
-            results = []
-            for key, data in zip(keys, all_data):
-                if not data:
-                    continue
-                
-                # 从 write 类型读取，匹配 sessionid 字段
-                if data.get('sessionid') == end_user_id:
-                    # 从 key 中提取 session_id: session:write:{session_id}
-                    session_id = key.split(':')[-1]
-                    
-                    # 构建完整的会话信息
-                    session_info = {
-                        "session_id": session_id,
-                        "id": data.get('id', ''),
-                        "sessionid": data.get('sessionid', ''),
-                        "messages": fix_encoding(data.get('messages', '')),
-                        "starttime": data.get('starttime', '')
-                    }
-                    results.append(session_info)
-            
-            if not results:
-                print(f"[get_all_sessions_by_end_user_id] end_user_id={end_user_id}, 没有找到数据")
-                return False
-            
-            # 按时间排序（最新的在前）
-            results.sort(key=lambda x: x.get('starttime', ''), reverse=True)
-            
-            print(f"[get_all_sessions_by_end_user_id] end_user_id={end_user_id}, 找到 {len(results)} 条数据")
-            return results
-        except Exception as e:
-            print(f"[get_all_sessions_by_end_user_id] 查询失败: {e}")
-            import traceback
-            traceback.print_exc()
-            return False
-
-    def find_user_recent_sessions(self, userid: str, 
-                                  minutes: int = 5) -> List[Dict[str, str]]:
-        """
-        根据 userid 从 save_session_write 写入的数据中查询最近 N 分钟内的会话数据
-        
-        Args:
-            userid: 用户ID (对应 sessionid 字段)
-            minutes: 查询最近几分钟的数据，默认5分钟
-            
-        Returns:
-            List[Dict]: 会话列表 [{"Query": "...", "Answer": "..."}, ...]
-        """
-        import time
-        start_time = time.time()
-        
-        # 只查询 write 类型的 key
-        keys = self.r.keys('session:write:*')
-        if not keys:
-            print(f"[find_user_recent_sessions] 查询耗时: {time.time() - start_time:.3f}秒, 结果数: 0")
-            return []
-
-        # 批量获取数据
-        pipe = self.r.pipeline()
-        for key in keys:
-            pipe.hgetall(key)
-        all_data = pipe.execute()
-
-        # 筛选符合 userid 的数据
-        matched_items = []
-        for data in all_data:
-            if not data:
-                continue
-            
-            # 从 write 类型读取，匹配 sessionid 字段
-            if data.get('sessionid') == userid and data.get('starttime'):
-                # write 类型没有 aimessages，所以 Answer 为空
-                matched_items.append({
-                    "Query": fix_encoding(data.get('messages', '')),
-                    "Answer": "",
-                    "starttime": data.get('starttime', '')
-                })
-        
-        # 根据时间范围过滤
-        filtered_items = filter_by_time_range(matched_items, minutes)
-        # 排序并移除时间字段
-        result_items = sort_and_limit_results(filtered_items, limit=None)
-        print(result_items)
-
-        elapsed_time = time.time() - start_time
-        print(f"[find_user_recent_sessions] userid={userid}, minutes={minutes}, "
-              f"查询耗时: {elapsed_time:.3f}秒, 结果数: {len(result_items)}")
-
-        return result_items
-
-    def delete_all_write_sessions(self) -> int:
-        """
-        删除所有 write 类型的会话
-        
-        Returns:
-            int: 删除的数量
-        """
-        keys = self.r.keys('session:write:*')
-        if keys:
-            return self.r.delete(*keys)
-        return 0
-
-
-class RedisCountStore:
-    """Redis Count 类型存储类，用于管理访问次数统计相关的数据"""
-    
-    def __init__(self, host='localhost', port=6379, db=0, password=None, session_id=''):
-        """
-        初始化 Redis 连接
-        
-        Args:
-            host: Redis 主机地址
-            port: Redis 端口
-            db: Redis 数据库编号
-            password: Redis 密码
-            session_id: 会话ID
-        """
-        self.r = redis.Redis(
-            host=host,
-            port=port,
-            db=db,
-            password=password,
-            decode_responses=True,
-            encoding='utf-8'
-        )
-        self.uudi = session_id
-
-    def save_sessions_count(self, end_user_id: str, count: int, messages: Any) -> str:
-        """
-        保存用户访问次数统计
-        
-        Args:
-            end_user_id: 终端用户ID
-            count: 访问次数
-            messages: 消息内容
-            
-        Returns:
-            str: 新生成的 session_id
-        """
-        session_id = str(uuid.uuid4())
-        key = generate_session_key(session_id, key_type="count")
-        index_key = f'session:count:index:{end_user_id}'  # 索引键
-        
-        pipe = self.r.pipeline()
-        pipe.hset(key, mapping={
-            "id": self.uudi,
-            "end_user_id": end_user_id,
-            "count": int(count),
-            "messages": serialize_messages(messages),
-            "starttime": get_current_timestamp()
-        })
-        pipe.expire(key, 30 * 24 * 60 * 60)  # 30天过期
-        
-        # 创建索引：end_user_id -> session_id 映射
-        pipe.set(index_key, session_id, ex=30 * 24 * 60 * 60)
-        
-        result = pipe.execute()
-        
-        print(f"[save_sessions_count] 保存结果: {result}, session_id: {session_id}")
-        return session_id
-
-    def get_sessions_count(self, end_user_id: str) -> Union[List[Any], bool]:
-        """
-        通过 end_user_id 查询访问次数统计
-        
-        Args:
-            end_user_id: 终端用户ID
-            
-        Returns:
-            list 或 False: 如果找到返回 [count, messages]，否则返回 False
-        """
-        try:
-            # 使用索引键快速查找
-            index_key = f'session:count:index:{end_user_id}'
-            
-            # 检查索引键类型，避免 WRONGTYPE 错误
-            try:
-                key_type = self.r.type(index_key)
-                if key_type != 'string' and key_type != 'none':
-                    self.r.delete(index_key)
-                    return False
-            except Exception as type_error:
-                print(f"[get_sessions_count] 检查键类型失败: {type_error}")
-            
-            session_id = self.r.get(index_key)
-            
-            if not session_id:
-                return False
-            
-            # 直接获取数据
-            key = generate_session_key(session_id, key_type="count")
-            data = self.r.hgetall(key)
-            
-            if not data:
-                # 索引存在但数据不存在，清理索引
-                self.r.delete(index_key)
-                return False
-            
-            count = data.get('count')
-            messages_str = data.get('messages')
-            
-            if count is not None:
-                messages = deserialize_messages(messages_str)
-                return [int(count), messages]
-            
-            return False
-        except Exception as e:
-            print(f"[get_sessions_count] 查询失败: {e}")
-            return False
-    def update_sessions_count(self, end_user_id: str, new_count: int, 
-                             messages: Any) -> bool:
-        """
-        通过 end_user_id 修改访问次数统计（优化版：使用索引）
-        
-        Args:
-            end_user_id: 终端用户ID
-            new_count: 新的 count 值
-            messages: 消息内容
-            
-        Returns:
-            bool: 更新成功返回 True，未找到记录返回 False
-        """
-        try:
-            # 使用索引键快速查找
-            index_key = f'session:count:index:{end_user_id}'
-            
-            # 检查索引键类型，避免 WRONGTYPE 错误
-            try:
-                key_type = self.r.type(index_key)
-                if key_type != 'string' and key_type != 'none':
-                    # 索引键类型错误，删除并返回 False
-                    print(f"[update_sessions_count] 索引键类型错误: {key_type}，删除索引")
-                    self.r.delete(index_key)
-                    print(f"[update_sessions_count] 未找到记录: end_user_id={end_user_id}")
-                    return False
-            except Exception as type_error:
-                print(f"[update_sessions_count] 检查键类型失败: {type_error}")
-            
-            session_id = self.r.get(index_key)
-            
-            if not session_id:
-                print(f"[update_sessions_count] 未找到记录: end_user_id={end_user_id}")
-                return False
-            
-            # 直接更新数据
-            key = generate_session_key(session_id, key_type="count")
-            messages_str = serialize_messages(messages)
-            
-            pipe = self.r.pipeline()
-            pipe.hset(key, 'count', int(new_count))
-            pipe.hset(key, 'messages', messages_str)
-            result = pipe.execute()
-            
-            print(f"[update_sessions_count] 更新成功: end_user_id={end_user_id}, new_count={new_count}, key={key}")
-            return True
-            
-        except Exception as e:
-            print(f"[update_sessions_count] 更新失败: {e}")
-            return False
-
-    def delete_all_count_sessions(self) -> int:
-        """
-        删除所有 count 类型的会话
-        
-        Returns:
-            int: 删除的数量
-        """
-        keys = self.r.keys('session:count:*')
-        if keys:
-            return self.r.delete(*keys)
-        return 0
 
 
 class RedisSessionStore:
-    """Redis 会话存储类，用于管理会话数据"""
-    
     def __init__(self, host='localhost', port=6379, db=0, password=None, session_id=''):
-        """
-        初始化 Redis 连接
-        
-        Args:
-            host: Redis 主机地址
-            port: Redis 端口
-            db: Redis 数据库编号
-            password: Redis 密码
-            session_id: 会话ID
-        """
         self.r = redis.Redis(
             host=host,
             port=port,
@@ -450,28 +16,32 @@ class RedisSessionStore:
         )
         self.uudi = session_id
 
-    # ==================== 写入操作 ====================
-    
-    def save_session(self, userid: str, messages: str, aimessages: str, 
-                    apply_id: str, end_user_id: str) -> str:
+    def _fix_encoding(self, text):
+        """修复错误编码的文本"""
+        if not text or not isinstance(text, str):
+            return text
+        try:
+            # 尝试修复 Latin-1 误编码为 UTF-8 的情况
+            return text.encode('latin-1').decode('utf-8')
+        except (UnicodeDecodeError, UnicodeEncodeError):
+            # 如果修复失败，返回原文本
+            return text
+
+    # 修改后的 save_session 方法
+    def save_session(self, userid, messages, aimessages, apply_id, end_user_id):
         """
         写入一条会话数据，返回 session_id
-        
-        Args:
-            userid: 用户ID
-            messages: 用户消息
-            aimessages: AI回复消息
-            apply_id: 应用ID
-            end_user_id: 终端用户ID
-            
-        Returns:
-            str: 新生成的 session_id
+        优化版本：确保写入时间不超过1秒
         """
         try:
-            session_id = str(uuid.uuid4())
-            key = generate_session_key(session_id, key_type="read")
+            session_id = str(uuid.uuid4())  # 为每次会话生成新的 ID
+            starttime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            key = f"session:{session_id}"  # 使用新生成的 session_id 作为 key
 
+            # 使用 pipeline 批量写入，减少网络往返
             pipe = self.r.pipeline()
+
+            # 直接写入数据，decode_responses=True 已经处理了编码
             pipe.hset(key, mapping={
                 "id": self.uudi,
                 "sessionid": userid,
@@ -479,195 +49,177 @@ class RedisSessionStore:
                 "end_user_id": end_user_id,
                 "messages": messages,
                 "aimessages": aimessages,
-                "starttime": get_current_timestamp()
+                "starttime": starttime
             })
+
+            # 可选：设置过期时间（例如30天），避免数据无限增长
+            # pipe.expire(key, 30 * 24 * 60 * 60)
+
+            # 执行批量操作
             result = pipe.execute()
 
-            print(f"[save_session] 保存结果: {result[0]}, session_id: {session_id}")
-            return session_id
+            print(f"保存结果: {result[0]}, session_id: {session_id}")
+            return session_id  # 返回新生成的 session_id
         except Exception as e:
-            print(f"[save_session] 保存会话失败: {e}")
+            print(f"保存会话失败: {e}")
             raise e
 
-    # ==================== 读取操作 ====================
-    
-    def get_session(self, session_id: str) -> Optional[Dict[str, Any]]:
+    def save_sessions_batch(self, sessions_data):
+        """
+        批量写入多条会话数据，返回 session_id 列表
+        sessions_data: list of dict, 每个 dict 包含 userid, messages, aimessages, apply_id, end_user_id
+        优化版本：批量操作，大幅提升性能
+        """
+        try:
+            session_ids = []
+            pipe = self.r.pipeline()
+
+            for session in sessions_data:
+                session_id = str(uuid.uuid4())
+                starttime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                key = f"session:{session_id}"
+
+                pipe.hset(key, mapping={
+                    "id": self.uudi,
+                    "sessionid": session.get('userid'),
+                    "apply_id": session.get('apply_id'),
+                    "end_user_id": session.get('end_user_id'),
+                    "messages": session.get('messages'),
+                    "aimessages": session.get('aimessages'),
+                    "starttime": starttime
+                })
+
+                session_ids.append(session_id)
+
+            # 一次性执行所有写入操作
+            results = pipe.execute()
+            print(f"批量保存完成: {len(session_ids)} 条记录")
+            return session_ids
+        except Exception as e:
+            print(f"批量保存会话失败: {e}")
+            raise e
+
+    # ---------------- 读取 ----------------
+    def get_session(self, session_id):
         """
         读取一条会话数据
-        
-        Args:
-            session_id: 会话ID
-            
-        Returns:
-            Dict 或 None: 会话数据
         """
-        key = generate_session_key(session_id)
+        key = f"session:{session_id}"
         data = self.r.hgetall(key)
         return data if data else None
 
-    def get_all_sessions(self) -> Dict[str, Dict[str, Any]]:
+    def get_session_apply_group(self, sessionid, apply_id, end_user_id):
         """
-        获取所有会话数据（不包括 count 和 write 类型）
-        
-        Returns:
-            Dict: 所有会话数据，key 为 session_id
+        根据 sessionid、apply_id 和 end_user_id 三个条件查询会话数据
         """
-        sessions = {}
+        result_items = []
+
+        # 遍历所有会话数据
         for key in self.r.keys('session:*'):
-            # 排除 count 和 write 类型的 key
-            if ':count:' not in key and ':write:' not in key:
-                sid = key.split(':')[1]
-                sessions[sid] = self.get_session(sid)
-        return sessions
+            data = self.r.hgetall(key)
 
-    def find_user_apply_group(self, sessionid: str, apply_id: str, 
-                             end_user_id: str) -> List[Dict[str, str]]:
-        """
-        根据 sessionid、apply_id 和 end_user_id 查询会话数据，返回最新的6条
-        
-        Args:
-            sessionid: 会话ID（支持模糊匹配）
-            apply_id: 应用ID
-            end_user_id: 终端用户ID
-            
-        Returns:
-            List[Dict]: 会话列表 [{"Query": "...", "Answer": "..."}, ...]
-        """
-        import time
-        start_time = time.time()
-        
-        keys = self.r.keys('session:*')
-        if not keys:
-            print(f"[find_user_apply_group] 查询耗时: {time.time() - start_time:.3f}秒, 结果数: 0")
-            return []
-
-        # 批量获取数据
-        pipe = self.r.pipeline()
-        for key in keys:
-            # 排除 count 和 write 类型
-            if ':count:' not in key and ':write:' not in key:
-                pipe.hgetall(key)
-        all_data = pipe.execute()
-
-        # 筛选符合条件的数据
-        matched_items = []
-        for data in all_data:
             if not data:
                 continue
 
-            if (data.get('apply_id') == apply_id and
-                data.get('end_user_id') == end_user_id):
-                # 支持模糊匹配或完全匹配 sessionid
-                if sessionid in data.get('sessionid', '') or data.get('sessionid') == sessionid:
-                    matched_items.append(format_session_data(data, include_time=True))
-        
-        # 排序、限制数量并移除时间字段
-        result_items = sort_and_limit_results(matched_items, limit=6)
-
-        elapsed_time = time.time() - start_time
-        print(f"[find_user_apply_group] 查询耗时: {elapsed_time:.3f}秒, 结果数: {len(result_items)}")
+            # 检查三个条件是否都匹配
+            if (data.get('sessionid') == sessionid and
+                    data.get('apply_id') == apply_id and
+                    data.get('end_user_id') == end_user_id):
+                result_items.append(data)
 
         return result_items
 
-    # ==================== 更新操作 ====================
-    
-    def update_session(self, session_id: str, field: str, value: Any) -> bool:
+    def get_all_sessions(self):
+        """
+        获取所有会话数据
+        """
+        sessions = {}
+        for key in self.r.keys('session:*'):
+            sid = key.split(':')[1]
+            sessions[sid] = self.get_session(sid)
+        return sessions
+
+    # ---------------- 更新 ----------------
+    def update_session(self, session_id, field, value):
         """
         更新单个字段
-        
-        Args:
-            session_id: 会话ID
-            field: 字段名
-            value: 字段值
-            
-        Returns:
-            bool: 是否更新成功
+        优化版本：使用 pipeline 减少网络往返
         """
-        key = generate_session_key(session_id)
+        key = f"session:{session_id}"
         pipe = self.r.pipeline()
         pipe.exists(key)
         pipe.hset(key, field, value)
         results = pipe.execute()
-        return bool(results[0])
+        return bool(results[0])  # 返回 key 是否存在
 
-    # ==================== 删除操作 ====================
-    
-    def delete_session(self, session_id: str) -> int:
+    # ---------------- 删除 ----------------
+    def delete_session(self, session_id):
         """
         删除单条会话
-        
-        Args:
-            session_id: 会话ID
-            
-        Returns:
-            int: 删除的数量
         """
-        key = generate_session_key(session_id)
+        key = f"session:{session_id}"
         return self.r.delete(key)
 
-    def delete_all_sessions(self) -> int:
+    def delete_all_sessions(self):
         """
-        删除所有会话（不包括 count 和 write 类型）
-        
-        Returns:
-            int: 删除的数量
+        删除所有会话
         """
         keys = self.r.keys('session:*')
-        # 过滤掉 count 和 write 类型
-        keys_to_delete = [k for k in keys if ':count:' not in k and ':write:' not in k]
-        if keys_to_delete:
-            return self.r.delete(*keys_to_delete)
+        if keys:
+            return self.r.delete(*keys)
         return 0
 
-    def delete_duplicate_sessions(self) -> int:
+    def delete_duplicate_sessions(self):
         """
-        删除重复会话数据（不包括 count 和 write 类型）
-        条件：sessionid、user_id、end_user_id、messages、aimessages 五个字段都相同的只保留一个
-        
-        Returns:
-            int: 删除的数量
+        删除重复会话数据，条件：
+        "sessionid"、"user_id"、"end_user_id"、"messages"、"aimessages" 五个字段都相同的只保留一个，其他删除
+        优化版本：使用 pipeline 批量操作，确保在1秒内完成
         """
         import time
         start_time = time.time()
 
+        # 第一步：使用 pipeline 批量获取所有 key
         keys = self.r.keys('session:*')
+
         if not keys:
             print("[delete_duplicate_sessions] 没有会话数据")
             return 0
 
-        # 批量获取所有数据
+        # 第二步：使用 pipeline 批量获取所有数据
         pipe = self.r.pipeline()
         for key in keys:
-            # 排除 count 和 write 类型
-            if ':count:' not in key and ':write:' not in key:
-                pipe.hgetall(key)
+            pipe.hgetall(key)
         all_data = pipe.execute()
 
-        # 识别重复数据
-        seen = {}
-        keys_to_delete = []
+        # 第三步：在内存中识别重复数据
+        seen = {}  # 用字典记录：identifier -> key（保留第一个出现的 key）
+        keys_to_delete = []  # 需要删除的 key 列表
 
-        for key, data in zip([k for k in keys if ':count:' not in k and ':write:' not in k], all_data, strict=False):
+        for key, data in zip(keys, all_data, strict=False):
             if not data:
                 continue
 
+            # 获取五个字段的值
+            sessionid = data.get('sessionid', '')
+            user_id = data.get('id', '')
+            end_user_id = data.get('end_user_id', '')
+            messages = data.get('messages', '')
+            aimessages = data.get('aimessages', '')
+
             # 用五元组作为唯一标识
-            identifier = (
-                data.get('sessionid', ''),
-                data.get('id', ''),
-                data.get('end_user_id', ''),
-                data.get('messages', ''),
-                data.get('aimessages', '')
-            )
+            identifier = (sessionid, user_id, end_user_id, messages, aimessages)
 
             if identifier in seen:
+                # 重复，标记为待删除
                 keys_to_delete.append(key)
             else:
+                # 第一次出现，记录
                 seen[identifier] = key
 
-        # 批量删除重复的 key
+        # 第四步：使用 pipeline 批量删除重复的 key
         deleted_count = 0
         if keys_to_delete:
+            # 分批删除，避免单次操作过大
             batch_size = 1000
             for i in range(0, len(keys_to_delete), batch_size):
                 batch = keys_to_delete[i:i + batch_size]
@@ -681,28 +233,79 @@ class RedisSessionStore:
         print(f"[delete_duplicate_sessions] 删除重复会话数量: {deleted_count}, 耗时: {elapsed_time:.3f}秒")
         return deleted_count
 
+    def find_user_session(self, sessionid):
+        user_id = sessionid
+
+        result_items = []
+        for key, values in store.get_all_sessions().items():
+            history = {}
+            if user_id == str(values['sessionid']):
+                history["Query"] = values['messages']
+                history["Answer"] = values['aimessages']
+                result_items.append(history)
+
+        if len(result_items) <= 1:
+            result_items = []
+        return (result_items)
+
+    def find_user_apply_group(self, sessionid, apply_id, end_user_id):
+        """
+        根据 sessionid、apply_id 和 end_user_id 三个条件查询会话数据，返回最新的6条
+        """
+        import time
+        start_time = time.time()
+        # 使用 pipeline 批量获取数据，提高性能
+        keys = self.r.keys('session:*')
+
+        if not keys:
+            print(f"查询耗时: {time.time() - start_time:.3f}秒, 结果数: 0")
+            return []
+
+        # 使用 pipeline 批量获取所有 hash 数据
+        pipe = self.r.pipeline()
+        for key in keys:
+            pipe.hgetall(key)
+        all_data = pipe.execute()
+
+        # 解析并筛选符合条件的数据
+        matched_items = []
+        for data in all_data:
+            if not data:
+                continue
+
+            # 检查是否符合三个条件
+
+            if (data.get('apply_id') == apply_id and
+                    data.get('end_user_id') == end_user_id):
+                # 支持模糊匹配 sessionid 或者完全匹配
+                if sessionid in data.get('sessionid', '') or data.get('sessionid') == sessionid:
+                    matched_items.append({
+                        "Query": self._fix_encoding(data.get('messages')),
+                        "Answer": self._fix_encoding(data.get('aimessages')),
+                        "starttime": data.get('starttime', '')
+                    })
+        # 按时间降序排序（最新的在前）
+        matched_items.sort(key=lambda x: x.get('starttime', ''), reverse=True)
+        # 只保留最新的6条
+        result_items = matched_items[:6]
+        # # 移除 starttime 字段
+        for item in result_items:
+            item.pop('starttime', None)
+
+        # 如果结果少于等于1条，返回空列表
+        if len(result_items) <= 1:
+            result_items = []
+
+        elapsed_time = time.time() - start_time
+        print(f"查询耗时: {elapsed_time:.3f}秒, 结果数: {len(result_items)}")
+
+        return result_items
+
 
-# 全局实例
 store = RedisSessionStore(
     host=settings.REDIS_HOST,
     port=settings.REDIS_PORT,
     db=settings.REDIS_DB,
     password=settings.REDIS_PASSWORD if settings.REDIS_PASSWORD else None,
     session_id=str(uuid.uuid4())
-)
-
-write_store = RedisWriteStore(
-    host=settings.REDIS_HOST,
-    port=settings.REDIS_PORT,
-    db=settings.REDIS_DB,
-    password=settings.REDIS_PASSWORD if settings.REDIS_PASSWORD else None,
-    session_id=str(uuid.uuid4())
-)
-
-count_store = RedisCountStore(
-    host=settings.REDIS_HOST,
-    port=settings.REDIS_PORT,
-    db=settings.REDIS_DB,
-    password=settings.REDIS_PASSWORD if settings.REDIS_PASSWORD else None,
-    session_id=str(uuid.uuid4())
-)
+)

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

@@ -4,7 +4,6 @@ Write Tools for Memory Knowledge Extraction Pipeline
 This module provides the main write function for executing the knowledge extraction
 pipeline. Only MemoryConfig is needed - clients are constructed internally.
 """
-import asyncio
 import time
 from datetime import datetime
 
@@ -34,17 +33,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 +93,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
@@ -151,48 +123,23 @@ async def write(
     except Exception as e:
         logger.error(f"Error creating indexes: {e}", exc_info=True)
 
-    # 添加死锁重试机制
-    max_retries = 3
-    retry_delay = 1  # 秒
-
-    for attempt in range(max_retries):
-        try:
-            success = await save_dialog_and_statements_to_neo4j(
-                dialogue_nodes=all_dialogue_nodes,
-                chunk_nodes=all_chunk_nodes,
-                statement_nodes=all_statement_nodes,
-                entity_nodes=all_entity_nodes,
-                statement_chunk_edges=all_statement_chunk_edges,
-                statement_entity_edges=all_statement_entity_edges,
-                entity_edges=all_entity_entity_edges,
-                connector=neo4j_connector
-            )
-            if success:
-                logger.info("Successfully saved all data to Neo4j")
-                break
-            else:
-                logger.warning("Failed to save some data to Neo4j")
-                if attempt < max_retries - 1:
-                    logger.info(f"Retrying... (attempt {attempt + 2}/{max_retries})")
-                    await asyncio.sleep(retry_delay * (attempt + 1))  # 指数退避
-        except Exception as e:
-            error_msg = str(e)
-            # 检查是否是死锁错误
-            if "DeadlockDetected" in error_msg or "deadlock" in error_msg.lower():
-                if attempt < max_retries - 1:
-                    logger.warning(f"Deadlock detected, retrying... (attempt {attempt + 2}/{max_retries})")
-                    await asyncio.sleep(retry_delay * (attempt + 1))  # 指数退避
-                else:
-                    logger.error(f"Failed after {max_retries} attempts due to deadlock: {e}")
-                    raise
-            else:
-                # 非死锁错误，直接抛出
-                raise
-
     try:
+        success = await save_dialog_and_statements_to_neo4j(
+            dialogue_nodes=all_dialogue_nodes,
+            chunk_nodes=all_chunk_nodes,
+            statement_nodes=all_statement_nodes,
+            entity_nodes=all_entity_nodes,
+            statement_chunk_edges=all_statement_chunk_edges,
+            statement_entity_edges=all_statement_entity_edges,
+            entity_edges=all_entity_entity_edges,
+            connector=neo4j_connector
+        )
+        if success:
+            logger.info("Successfully saved all data to Neo4j")
+        else:
+            logger.warning("Failed to save some data to Neo4j")
+    finally:
         await neo4j_connector.close()
-    except Exception as e:
-        logger.error(f"Error closing Neo4j connector: {e}")
 
     log_time("Neo4j Database Save", time.time() - step_start, log_file)
 
@@ -200,7 +147,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:
@@ -225,24 +172,5 @@ async def write(
     with open(log_file, "a", encoding="utf-8") as f:
         f.write(f"=== Pipeline Run Completed: {timestamp} ===\n\n")
 
-    # 将提取统计写入 Redis，按 workspace_id 存储
-    try:
-        from app.cache.memory.activity_stats_cache import ActivityStatsCache
-
-        stats_to_cache = {
-            "chunk_count": len(all_chunk_nodes) if all_chunk_nodes else 0,
-            "statements_count": len(all_statement_nodes) if all_statement_nodes else 0,
-            "triplet_entities_count": len(all_entity_nodes) if all_entity_nodes else 0,
-            "triplet_relations_count": len(all_entity_entity_edges) if all_entity_entity_edges else 0,
-            "temporal_count": 0,
-        }
-        await ActivityStatsCache.set_activity_stats(
-            workspace_id=str(memory_config.workspace_id),
-            stats=stats_to_cache,
-        )
-        logger.info(f"[WRITE] 活动统计已写入 Redis: workspace_id={memory_config.workspace_id}")
-    except Exception as cache_err:
-        logger.warning(f"[WRITE] 写入活动统计缓存失败（不影响主流程）: {cache_err}", exc_info=True)
-
     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

@@ -1,12 +1,9 @@
 import asyncio
 import json
-import logging
 import os
 from typing import List, Tuple
 
 from app.core.config import settings
-
-logger = logging.getLogger(__name__)
 from app.core.memory.utils.llm.llm_utils import MemoryClientFactory
 from app.db import get_db_context
 from app.repositories.neo4j.neo4j_connector import Neo4jConnector
@@ -19,10 +16,6 @@ class FilteredTags(BaseModel):
     """用于接收LLM筛选后的核心标签列表的模型。"""
     meaningful_tags: List[str] = Field(..., description="从原始列表中筛选出的具有核心代表意义的名词列表。")
 
-class InterestTags(BaseModel):
-    """用于接收LLM筛选后的兴趣活动标签列表的模型。"""
-    interest_tags: List[str] = Field(..., description="从原始列表中筛选出的代表用户兴趣活动的标签列表。")
-
 async def filter_tags_with_llm(tags: List[str], end_user_id: str) -> List[str]:
     """
     使用LLM筛选标签列表，仅保留具有代表性的核心名词。
@@ -46,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(
@@ -92,74 +81,10 @@ async def filter_tags_with_llm(tags: List[str], end_user_id: str) -> List[str]:
         return structured_response.meaningful_tags
 
     except Exception as e:
-        logger.error(f"LLM筛选过程中发生错误: {e}", exc_info=True)
+        print(f"LLM筛选过程中发生错误: {e}")
         # 在LLM失败时返回原始标签，确保流程继续
         return tags
 
-async def filter_interests_with_llm(tags: List[str], end_user_id: str, language: str = "zh") -> List[str]:
-    """
-    使用LLM从标签列表中筛选出代表用户兴趣活动的标签。
-    
-    与 filter_tags_with_llm 不同，此函数专注于识别"活动/行为"类兴趣，
-    过滤掉纯物品、工具、地点等不代表用户主动参与活动的名词。
-    
-    Args:
-        tags: 原始标签列表
-        end_user_id: 用户ID，用于获取LLM配置
-        
-    Returns:
-        筛选后的兴趣活动标签列表
-    """
-    try:
-        with get_db_context() as db:
-            from app.services.memory_agent_service import (
-                get_end_user_connected_config,
-            )
-            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:
-                raise ValueError(
-                    f"No memory_config_id found for end_user_id: {end_user_id}."
-                )
-
-            config_service = MemoryConfigService(db)
-            memory_config = config_service.load_memory_config(
-                config_id=config_id,
-                workspace_id=workspace_id
-            )
-
-            if not memory_config.llm_model_id:
-                raise ValueError(
-                    f"No llm_model_id found in memory config {config_id}."
-                )
-
-            factory = MemoryClientFactory(db)
-            llm_client = factory.get_llm_client(memory_config.llm_model_id)
-
-        tag_list_str = ", ".join(tags)
-        from app.core.memory.utils.prompt.prompt_utils import render_interest_filter_prompt
-        rendered_prompt = render_interest_filter_prompt(tag_list_str, language=language)
-        messages = [
-            {
-                "role": "user",
-                "content": rendered_prompt
-            }
-        ]
-
-        structured_response = await llm_client.response_structured(
-            messages=messages,
-            response_model=InterestTags
-        )
-
-        return structured_response.interest_tags
-
-    except Exception as e:
-        logger.error(f"兴趣标签LLM筛选过程中发生错误: {e}", exc_info=True)
-        return tags
-
-
 async def get_raw_tags_from_db(
     connector: Neo4jConnector,
     end_user_id: str,
@@ -210,14 +135,14 @@ async def get_raw_tags_from_db(
     
     return [(record["name"], record["frequency"]) for record in results]
 
-async def get_hot_memory_tags(end_user_id: str, limit: int = 10, by_user: bool = False) -> List[Tuple[str, int]]:
+async def get_hot_memory_tags(end_user_id: str, limit: int = 40, by_user: bool = False) -> List[Tuple[str, int]]:
     """
     获取原始标签，然后使用LLM进行筛选，返回最终的热门标签列表。
-    查询更多的标签(40条)给LLM提供更丰富的上下文进行筛选，但最终返回数量由limit参数控制。
+    查询更多的标签(limit=40)给LLM提供更丰富的上下文进行筛选。
 
     Args:
         end_user_id: 必需参数。如果by_user=False，则为end_user_id；如果by_user=True，则为user_id
-        limit: 最终返回的标签数量限制（默认10）
+        limit: 返回的标签数量限制
         by_user: 是否按user_id查询（默认False，按end_user_id查询）
         
     Raises:
@@ -232,9 +157,8 @@ async def get_hot_memory_tags(end_user_id: str, limit: int = 10, by_user: bool =
     # 使用项目的Neo4jConnector
     connector = Neo4jConnector()
     try:
-        # 1. 从数据库获取原始排名靠前的标签（查询40条给LLM提供更丰富的上下文）
-        query_limit = 40
-        raw_tags_with_freq = await get_raw_tags_from_db(connector, end_user_id, query_limit, by_user=by_user)
+        # 1. 从数据库获取原始排名靠前的标签
+        raw_tags_with_freq = await get_raw_tags_from_db(connector, end_user_id, limit, by_user=by_user)
         if not raw_tags_with_freq:
             return []
 
@@ -249,61 +173,7 @@ async def get_hot_memory_tags(end_user_id: str, limit: int = 10, by_user: bool =
             if tag in meaningful_tag_names:
                 final_tags.append((tag, freq))
 
-        # 4. 限制返回的标签数量
-        return final_tags[:limit]
+        return final_tags
     finally:
         # 确保关闭连接
         await connector.close()
-
-async def get_interest_distribution(end_user_id: str, limit: int = 10, by_user: bool = False, language: str = "zh") -> List[Tuple[str, int]]:
-    """
-    获取用户的兴趣分布标签。
-    
-    与 get_hot_memory_tags 不同，此函数使用专门针对"活动/行为"的LLM prompt，
-    过滤掉纯物品、工具、地点等，只保留能代表用户兴趣爱好的活动类标签。
-
-    Args:
-        end_user_id: 必需参数。如果by_user=False，则为end_user_id；如果by_user=True，则为user_id
-        limit: 最终返回的标签数量限制（默认10）
-        by_user: 是否按user_id查询（默认False，按end_user_id查询）
-
-    Raises:
-        ValueError: 如果end_user_id未提供或为空
-    """
-    if not end_user_id or not end_user_id.strip():
-        raise ValueError(
-            "end_user_id is required. Please provide a valid end_user_id or user_id."
-        )
-
-    connector = Neo4jConnector()
-    try:
-        # 查询更多原始标签，给LLM提供充足上下文
-        query_limit = 40
-        raw_tags_with_freq = await get_raw_tags_from_db(connector, end_user_id, query_limit, by_user=by_user)
-        if not raw_tags_with_freq:
-            return []
-
-        raw_tag_names = [tag for tag, freq in raw_tags_with_freq]
-        raw_freq_map = {tag: freq for tag, freq in raw_tags_with_freq}
-
-        # 使用兴趣活动专用prompt进行筛选（支持语义推断出新标签）
-        interest_tag_names = await filter_interests_with_llm(raw_tag_names, end_user_id, language=language)
-
-        # 构建最终标签列表：
-        # - 原始标签中存在的，保留原始频率
-        # - LLM推断出的新标签（不在原始列表中），赋予默认频率1
-        final_tags = []
-        seen = set()
-        for tag in interest_tag_names:
-            if tag in seen:
-                continue
-            seen.add(tag)
-            freq = raw_freq_map.get(tag, 1)
-            final_tags.append((tag, freq))
-
-        # 按频率降序排列
-        final_tags.sort(key=lambda x: x[1], reverse=True)
-
-        return final_tags[:limit]
-    finally:
-        await connector.close()

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,6 @@ 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 (
-    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,
@@ -124,16 +105,6 @@ __all__ = [
     "Entity",
     "Triplet",
     "TripletExtractionResponse",
-    # 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/config_models.py

@@ -10,7 +10,7 @@ Classes:
     TemporalSearchParams: Parameters for temporal search queries
 """
 
-from typing import Optional, List
+from typing import Optional
 from pydantic import BaseModel, Field
 
 
@@ -55,26 +55,17 @@ class PruningConfig(BaseModel):
 
     Attributes:
         pruning_switch: Enable or disable semantic pruning
-        pruning_scene: Scene name for pruning, either a built-in key
-            ('education', 'online_service', 'outbound') or a custom scene_name
-            from ontology_scene table
+        pruning_scene: Scene type for pruning ('education', 'online_service', 'outbound')
         pruning_threshold: Pruning ratio (0-0.9, max 0.9 to avoid complete removal)
-        scene_id: Optional ontology scene UUID, used to load custom ontology classes
-        ontology_classes: List of class_name strings from ontology_class table,
-            injected into the prompt when pruning_scene is not a built-in scene
     """
     pruning_switch: bool = Field(False, description="Enable semantic pruning when True.")
     pruning_scene: str = Field(
         "education",
-        description="Scene for pruning: built-in key or custom scene_name from ontology_scene.",
+        description="Scene for pruning: one of 'education', 'online_service', 'outbound'.",
     )
     pruning_threshold: float = Field(
         0.5, ge=0.0, le=0.9,
         description="Pruning ratio within 0-0.9 (max 0.9 to avoid termination).")
-    scene_id: Optional[str] = Field(None, description="Ontology scene UUID (optional).")
-    ontology_classes: Optional[List[str]] = Field(
-        None, description="Class names from ontology_class table for custom scenes."
-    )
 
 
 class TemporalSearchParams(BaseModel):

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

@@ -413,8 +413,7 @@ class ExtractedEntityNode(Node):
         description="Entity aliases - alternative names for this entity"
     )
     name_embedding: Optional[List[float]] = Field(default_factory=list, description="Name embedding vector")
-    # TODO: fact_summary 功能暂时禁用，待后续开发完善后启用
-    # fact_summary: str = Field(default="", description="Summary of the fact about this entity")
+    fact_summary: str = Field(default="", description="Summary of the fact about this entity")
     connect_strength: str = Field(..., description="Strong VS Weak about this entity")
     config_id: Optional[int | str] = Field(None, description="Configuration ID used to process this entity (integer or string)")
     

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_scenario_models.py

@@ -1,138 +0,0 @@
-"""Models for ontology classes and extraction responses.
-
-This module contains Pydantic models for representing extracted ontology classes
-from scenario descriptions, following OWL ontology engineering standards.
-
-Classes:
-    OntologyClass: Represents an extracted ontology class
-    OntologyExtractionResponse: Response model containing extracted ontology classes
-"""
-
-from typing import List, Optional
-from uuid import uuid4
-
-from pydantic import BaseModel, ConfigDict, Field, field_validator
-
-
-class OntologyClass(BaseModel):
-    """Represents an extracted ontology class from scenario description.
-
-    An ontology class represents an abstract category or concept in a domain,
-    following OWL ontology engineering standards and naming conventions.
-
-    Attributes:
-        id: Unique string identifier for the ontology class
-        name: Name of the class in PascalCase format (e.g., 'MedicalProcedure')
-        name_chinese: Chinese translation of the class name (e.g., '医疗程序')
-        description: Textual description of the class
-        examples: List of concrete instance examples of this class
-        parent_class: Optional name of the parent class in the hierarchy
-        entity_type: Type/category of the entity (e.g., 'Person', 'Organization', 'Concept')
-        domain: Domain this class belongs to (e.g., 'Healthcare', 'Education')
-
-    Config:
-        extra: Ignore extra fields from LLM output
-    """
-    model_config = ConfigDict(extra='ignore')
-    
-    id: str = Field(
-        default_factory=lambda: uuid4().hex,
-        description="Unique identifier for the ontology class"
-    )
-    name: str = Field(
-        ...,
-        description="Name of the class in PascalCase format"
-    )
-    name_chinese: Optional[str] = Field(
-        None,
-        description="Chinese translation of the class name"
-    )
-    description: str = Field(
-        ...,
-        description="Description of the class"
-    )
-    examples: List[str] = Field(
-        default_factory=list,
-        description="List of concrete instance examples"
-    )
-    parent_class: Optional[str] = Field(
-        None,
-        description="Name of the parent class in the hierarchy"
-    )
-    entity_type: str = Field(
-        ...,
-        description="Type/category of the entity"
-    )
-    domain: str = Field(
-        ...,
-        description="Domain this class belongs to"
-    )
-
-    @field_validator('name')
-    @classmethod
-    def validate_pascal_case(cls, v: str) -> str:
-        """Validate that the class name follows PascalCase convention.
-
-        PascalCase rules:
-        - Must start with an uppercase letter (for English) or any character (for Chinese/Unicode)
-        - Cannot contain spaces
-        - Should not contain special characters except underscores
-
-        Args:
-            v: The class name to validate
-
-        Returns:
-            The validated class name
-
-        Raises:
-            ValueError: If the name doesn't follow PascalCase convention
-        """
-        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():
-            raise ValueError(
-                f"Class name '{v}' must start with an uppercase letter (PascalCase)"
-            )
-        
-        if ' ' in v:
-            raise ValueError(
-                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):
-            raise ValueError(
-                f"Class name '{v}' contains invalid characters. "
-                "Only alphanumeric characters, underscores, and Unicode characters are allowed"
-            )
-        
-        return v
-
-
-class OntologyExtractionResponse(BaseModel):
-    """Response model for ontology extraction from LLM.
-
-    This model represents the structured output from the LLM when
-    extracting ontology classes from scenario descriptions.
-
-    Attributes:
-        classes: List of extracted ontology classes
-        domain: Domain/field the scenario belongs to
-
-    Config:
-        extra: Ignore extra fields from LLM output
-    """
-    model_config = ConfigDict(extra='ignore')
-    
-    classes: List[OntologyClass] = Field(
-        default_factory=list,
-        description="List of extracted ontology classes"
-    )
-    domain: str = Field(
-        ...,
-        description="Domain/field the scenario belongs to"
-    )

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/data_preprocessing/data_pruning.py

@@ -5,27 +5,20 @@
 - 对话级一次性抽取判定相关性
 - 仅对"不相关对话"的消息按比例删除
 - 重要信息（时间、编号、金额、联系方式、地址等）优先保留
-- 改进版：增强重要性判断、智能填充消息识别、问答对保护、并发优化
 """
 
-import asyncio
 import os
 import hashlib
 import json
 import re
-from collections import OrderedDict
 from datetime import datetime
-from typing import List, Optional, Dict, Tuple, Set
+from typing import List, Optional
 from pydantic import BaseModel, Field
 
 from app.core.memory.models.message_models import DialogData, ConversationMessage, ConversationContext
 from app.core.memory.models.config_models import PruningConfig
 from app.core.memory.utils.config.config_utils import get_pruning_config
 from app.core.memory.utils.prompt.prompt_utils import prompt_env, log_prompt_rendering, log_template_rendering
-from app.core.memory.storage_services.extraction_engine.data_preprocessing.scene_config import (
-    SceneConfigRegistry,
-    ScenePatterns
-)
 
 
 class DialogExtractionResponse(BaseModel):
@@ -33,7 +26,6 @@ class DialogExtractionResponse(BaseModel):
 
     - is_related：对话与场景的相关性判定。
     - times / ids / amounts / contacts / addresses / keywords：重要信息片段，用来在不相关对话中保留关键消息。
-    - preserve_keywords：情绪/兴趣/爱好/个人观点相关词，包含这些词的消息必须强制保留。
     """
     is_related: bool = Field(...)
     times: List[str] = Field(default_factory=list)
@@ -42,24 +34,6 @@ class DialogExtractionResponse(BaseModel):
     contacts: List[str] = Field(default_factory=list)
     addresses: List[str] = Field(default_factory=list)
     keywords: List[str] = Field(default_factory=list)
-    preserve_keywords: List[str] = Field(default_factory=list, description="情绪/兴趣/爱好/个人观点相关词，包含这些词的消息强制保留")
-
-
-class MessageImportanceResponse(BaseModel):
-    """消息重要性批量判断的结构化返回（用于LLM语义判断）。
-    
-    - importance_scores: 消息索引到重要性分数的映射 (0-10分)
-    - reasons: 可选的判断理由
-    """
-    importance_scores: Dict[int, int] = Field(default_factory=dict, description="消息索引到重要性分数(0-10)的映射")
-    reasons: Optional[Dict[int, str]] = Field(default_factory=dict, description="可选的判断理由")
-
-
-class QAPair(BaseModel):
-    """问答对模型，用于识别和保护对话中的问答结构。"""
-    question_idx: int = Field(..., description="问题消息的索引")
-    answer_idx: int = Field(..., description="答案消息的索引")
-    confidence: float = Field(default=1.0, description="问答对的置信度(0-1)")
 
 
 class SemanticPruner:
@@ -69,280 +43,109 @@ class SemanticPruner:
     重要信息（时间、编号、金额、联系方式、地址等）优先保留。
     """
 
-    def __init__(self, config: Optional[PruningConfig] = None, llm_client=None, language: str = "zh", max_concurrent: int = 5):
-        # 如果没有提供config，使用默认配置
-        if config is None:
-            # 使用默认的剪枝配置
-            config = PruningConfig(
-                pruning_switch=False,  # 默认关闭剪枝，保持向后兼容
-                pruning_scene="education",
-                pruning_threshold=0.5
-            )
-        
-        self.config = config
+    def __init__(self, config: Optional[PruningConfig] = None, llm_client=None):
+        cfg_dict = get_pruning_config() if config is None else config.model_dump()
+        self.config = PruningConfig.model_validate(cfg_dict)
         self.llm_client = llm_client
-        self.language = language  # 保存语言配置
-        self.max_concurrent = max_concurrent  # 新增：最大并发数
-        
-        # 详细日志配置：限制逐条消息日志的数量
-        self._detailed_prune_logging = True  # 是否启用详细日志
-        self._max_debug_msgs_per_dialog = 20  # 每个对话最多记录前N条消息的详细日志
-        
-        # 加载统一填充词库
-        self.scene_config: ScenePatterns = SceneConfigRegistry.get_config(self.config.pruning_scene)
-        
-        # 本体类型列表（用于注入提示词，所有场景均支持）
-        self._ontology_classes = getattr(self.config, "ontology_classes", None) or []
-        
-        self._log(f"[剪枝-初始化] 场景={self.config.pruning_scene}")
-        if self._ontology_classes:
-            self._log(f"[剪枝-初始化] 注入本体类型: {self._ontology_classes}")
-        else:
-            self._log(f"[剪枝-初始化] 未找到本体类型，将使用通用提示词")
-        
         # Load Jinja2 template
         self.template = prompt_env.get_template("extracat_Pruning.jinja2")
-        
-        # 对话抽取缓存：使用 OrderedDict 实现 LRU 缓存
-        self._dialog_extract_cache: OrderedDict[str, DialogExtractionResponse] = OrderedDict()
-        self._cache_max_size = 1000  # 缓存大小限制
-        
+        # 对话抽取缓存：避免同一对话重复调用 LLM / 重复渲染
+        self._dialog_extract_cache: dict[str, DialogExtractionResponse] = {}
         # 运行日志：收集关键终端输出，便于写入 JSON
         self.run_logs: List[str] = []
+        # 采用顺序处理，移除并发配置以简化与稳定执行
 
-    # _is_important_message 和 _importance_score 已移除：
-    # 重要性判断完全由 extracat_Pruning.jinja2 提示词 + LLM 的 preserve_tokens 机制承担。
-    # LLM 根据注入的本体工程类型语义识别需要保护的内容，无需硬编码正则规则。
+    def _is_important_message(self, message: ConversationMessage) -> bool:
+        """基于启发式规则识别重要信息消息，优先保留。
+
+        - 含日期/时间（如YYYY-MM-DD、HH:MM、2024年11月10日、上午/下午）。
+        - 含编号/ID/订单号/申请号/账号/电话/金额等关键字段。
+        - 关键词："时间"、"日期"、"编号"、"订单"、"流水"、"金额"、"￥"、"元"、"电话"、"手机号"、"邮箱"、"地址"。
+        """
+        import re
+        text = message.msg.strip()
+        if not text:
+            return False
+        patterns = [
+            r"\b\d{4}-\d{1,2}-\d{1,2}\b",
+            r"\b\d{1,2}:\d{2}\b",
+            r"\d{4}年\d{1,2}月\d{1,2}日",
+            r"上午|下午|AM|PM",
+            r"订单号|工单|申请号|编号|ID|账号|账户",
+            r"电话|手机号|微信|QQ|邮箱",
+            r"地址|地点",
+            r"金额|费用|价格|¥|￥|\d+元",
+            r"时间|日期|有效期|截止",
+        ]
+        for p in patterns:
+            if re.search(p, text, flags=re.IGNORECASE):
+                return True
+        return False
+    def _importance_score(self, message: ConversationMessage) -> int:
+        """为重要消息打分，用于在保留比例内优先保留更关键的内容。
+
+        简单启发：匹配到的类别越多、越关键分值越高。
+        """
+        import re
+        text = message.msg.strip()
+        score = 0
+        weights = [
+            (r"\b\d{4}-\d{1,2}-\d{1,2}\b", 3),
+            (r"\b\d{1,2}:\d{2}\b", 2),
+            (r"\d{4}年\d{1,2}月\d{1,2}日", 3),
+            (r"订单号|工单|申请号|编号|ID|账号|账户", 4),
+            (r"电话|手机号|微信|QQ|邮箱", 3),
+            (r"地址|地点", 2),
+            (r"金额|费用|价格|¥|￥|\d+元", 4),
+            (r"时间|日期|有效期|截止", 2),
+        ]
+        for p, w in weights:
+            if re.search(p, text, flags=re.IGNORECASE):
+                score += w
+        return score
 
     def _is_filler_message(self, message: ConversationMessage) -> bool:
-        """检测典型寒暄/口头禅/确认类短消息。
+        """检测典型寒暄/口头禅/确认类短消息，用于跳过LLM分类以加速。
 
-        判断顺序：
-        1. 空消息
-        2. 场景特定填充词库精确匹配
-        3. 常见寒暄精确匹配
-        4. 纯表情/标点
+        满足以下之一视为填充消息：
+        - 纯标点或长度很短（<= 4 个汉字或 <= 8 个字符）且不包含数字或关键实体；
+        - 常见词：你好/您好/在吗/嗯/嗯嗯/哦/好的/好/行/可以/不可以/谢谢/拜拜/再见/哈哈/呵呵/哈哈哈/。。。/？？。
         """
+        import re
         t = message.msg.strip()
         if not t:
             return True
-
-        # 检查是否在场景特定填充词库中（精确匹配）
-        if t in self.scene_config.filler_phrases:
+        # 常见填充语
+        fillers = [
+            "你好", "您好", "在吗", "嗯", "嗯嗯", "哦", "好的", "好", "行", "可以", "不可以", "谢谢",
+            "拜拜", "再见", "哈哈", "呵呵", "哈哈哈", "。。。", "??", "？？"
+        ]
+        if t in fillers:
             return True
-
-        # 常见寒暄和问候（精确匹配，避免误删）
-        common_greetings = {
-            "在吗", "在不在", "在呢", "在的",
-            "你好", "您好", "hello", "hi",
-            "拜拜", "再见", "拜", "88", "bye",
-            "好的", "好", "行", "可以", "嗯", "哦", "啊",
-            "是的", "对", "对的", "没错", "是啊",
-            "哈哈", "呵呵", "嘿嘿", "嗯嗯"
-        }
-        if t in common_greetings:
-            return True
-
-        # 检查是否为纯表情符号（方括号包裹）
-        if re.fullmatch(r"(\[[^\]]+\])+", t):
-            return True
-        
-        # 纯标点符号
-        if re.fullmatch(r"[。！？,.!?…·\s]+", t):
-            return True
-        
+        # 长度与字符类型判断
+        if len(t) <= 8:
+            # 非数字、无关键实体的短文本
+            if not re.search(r"[0-9]", t) and not self._is_important_message(message):
+                # 主要是标点或简单确认词
+                if re.fullmatch(r"[。！？,.!?…·\s]+", t) or t in fillers:
+                    return True
         return False
-    
-    async def _batch_evaluate_importance_with_llm(
-        self, 
-        messages: List[ConversationMessage],
-        context: str = ""
-    ) -> Dict[int, int]:
-        """使用LLM批量评估消息的重要性（语义层面）。
-        
-        Args:
-            messages: 消息列表
-            context: 对话上下文（可选）
-            
-        Returns:
-            消息索引到重要性分数(0-10)的映射
-        """
-        if not self.llm_client or not messages:
-            return {}
-        
-        # 构建批量评估的提示词
-        msg_list = []
-        for idx, msg in enumerate(messages):
-            msg_list.append(f"{idx}. {msg.msg}")
-        
-        msg_text = "\n".join(msg_list)
-        
-        prompt = f"""请评估以下消息的重要性，给每条消息打分（0-10分）：
-- 0-2分：无意义的寒暄、口头禅、纯表情
-- 3-5分：一般性对话，有一定信息量但不关键
-- 6-8分：包含重要信息（时间、地点、人物、事件等）
-- 9-10分：关键决策、承诺、重要数据
-
-对话上下文：
-{context if context else "无"}
-
-待评估的消息：
-{msg_text}
-
-请以JSON格式返回，格式为：
-{{
-  "importance_scores": {{
-    "0": 分数,
-    "1": 分数,
-    ...
-  }}
-}}
-"""
-        
-        try:
-            messages_for_llm = [
-                {"role": "system", "content": "你是一个专业的对话分析助手，擅长评估消息的重要性。"},
-                {"role": "user", "content": prompt}
-            ]
-            
-            response = await self.llm_client.response_structured(
-                messages_for_llm,
-                MessageImportanceResponse
-            )
-            
-            # 转换字符串键为整数键
-            return {int(k): v for k, v in response.importance_scores.items()}
-        except Exception as e:
-            self._log(f"[剪枝-LLM] 批量重要性评估失败: {str(e)[:100]}")
-            return {}
-    
-    def _identify_qa_pairs(self, messages: List[ConversationMessage]) -> List[QAPair]:
-        """识别对话中的问答对，用于保护问答结构的完整性。
-        
-        改进版：使用场景特定的问句关键词，并排除寒暄类问句
-        
-        Args:
-            messages: 消息列表
-            
-        Returns:
-            问答对列表
-        """
-        qa_pairs = []
-        
-        # 寒暄类问句，不应该被保护（这些不是真正的问答）
-        greeting_questions = {
-            "在吗", "在不在", "你好吗", "怎么样", "好吗",
-            "有空吗", "忙吗", "睡了吗", "起床了吗"
-        }
-        
-        for i in range(len(messages) - 1):
-            current_msg = messages[i].msg.strip()
-            next_msg = messages[i + 1].msg.strip()
-            
-            # 排除寒暄类问句
-            if current_msg in greeting_questions:
-                continue
-            
-            # 使用场景特定的问句关键词，但要求更严格
-            is_question = False
-            
-            # 1. 以问号结尾
-            if current_msg.endswith("？") or current_msg.endswith("?"):
-                is_question = True
-            # 2. 包含实质性问句关键词（排除"吗"这种太宽泛的）
-            elif any(word in current_msg for word in ["什么", "为什么", "怎么", "如何", "哪里", "哪个", "谁", "多少", "几点", "何时"]):
-                is_question = True
-            
-            if is_question and next_msg:
-                # 检查下一条消息是否像答案（不是另一个问句，也不是寒暄）
-                is_answer = not (next_msg.endswith("？") or next_msg.endswith("?"))
-                
-                # 排除寒暄类回复
-                greeting_answers = {"你好", "您好", "在呢", "在的", "嗯", "哦", "好的"}
-                if next_msg in greeting_answers:
-                    is_answer = False
-                
-                if is_answer:
-                    qa_pairs.append(QAPair(
-                        question_idx=i,
-                        answer_idx=i + 1,
-                        confidence=0.8  # 基于规则的置信度
-                    ))
-        
-        return qa_pairs
-    
-    def _get_protected_indices(
-        self, 
-        messages: List[ConversationMessage],
-        qa_pairs: List[QAPair],
-        window_size: int = 2
-    ) -> Set[int]:
-        """获取需要保护的消息索引集合（问答对+上下文窗口）。
-        
-        Args:
-            messages: 消息列表
-            qa_pairs: 问答对列表
-            window_size: 上下文窗口大小（前后各保留几条消息）
-            
-        Returns:
-            需要保护的消息索引集合
-        """
-        protected = set()
-        
-        for qa_pair in qa_pairs:
-            # 保护问答对本身
-            protected.add(qa_pair.question_idx)
-            protected.add(qa_pair.answer_idx)
-            
-            # 保护上下文窗口
-            for offset in range(-window_size, window_size + 1):
-                q_idx = qa_pair.question_idx + offset
-                a_idx = qa_pair.answer_idx + offset
-                
-                if 0 <= q_idx < len(messages):
-                    protected.add(q_idx)
-                if 0 <= a_idx < len(messages):
-                    protected.add(a_idx)
-        
-        return protected
 
     async def _extract_dialog_important(self, dialog_text: str) -> DialogExtractionResponse:
         """对话级一次性抽取：从整段对话中提取重要信息并判定相关性。
 
-        改进版：
-        - LRU缓存管理
-        - 重试机制
-        - 降级策略
+        - 仅使用 LLM 结构化输出；
         """
         # 缓存命中则直接返回（场景+内容作为键）
         cache_key = f"{self.config.pruning_scene}:" + hashlib.sha1(dialog_text.encode("utf-8")).hexdigest()
-        
-        # LRU缓存：如果命中，移到末尾（最近使用）
         if cache_key in self._dialog_extract_cache:
-            self._dialog_extract_cache.move_to_end(cache_key)
             return self._dialog_extract_cache[cache_key]
 
-        # LRU缓存大小限制：超过限制时删除最旧的条目
-        if len(self._dialog_extract_cache) >= self._cache_max_size:
-            # 删除最旧的条目（OrderedDict的第一个）
-            oldest_key = next(iter(self._dialog_extract_cache))
-            del self._dialog_extract_cache[oldest_key]
-            self._log(f"[剪枝-缓存] LRU缓存已满，删除最旧条目")
-
-        rendered = self.template.render(
-            pruning_scene=self.config.pruning_scene,
-            ontology_classes=self._ontology_classes,
-            dialog_text=dialog_text,
-            language=self.language
-        )
-        log_template_rendering("extracat_Pruning.jinja2", {
-            "pruning_scene": self.config.pruning_scene,
-            "ontology_classes_count": len(self._ontology_classes),
-            "language": self.language
-        })
+        rendered = self.template.render(pruning_scene=self.config.pruning_scene, dialog_text=dialog_text)
+        log_template_rendering("extracat_Pruning.jinja2", {"pruning_scene": self.config.pruning_scene})
         log_prompt_rendering("pruning-extract", rendered)
 
-        # 强制使用 LLM
+        # 强制使用 LLM；移除正则回退
         if not self.llm_client:
             raise RuntimeError("llm_client 未配置；请配置 LLM 以进行结构化抽取。")
 
@@ -350,32 +153,12 @@ class SemanticPruner:
             {"role": "system", "content": "你是一个严谨的场景抽取助手，只输出严格 JSON。"},
             {"role": "user", "content": rendered},
         ]
-        
-        # 重试机制
-        max_retries = 3
-        for attempt in range(max_retries):
-            try:
-                ex = await self.llm_client.response_structured(messages, DialogExtractionResponse)
-                self._dialog_extract_cache[cache_key] = ex
-                return ex
-            except Exception as e:
-                if attempt < max_retries - 1:
-                    self._log(f"[剪枝-LLM] 第 {attempt + 1} 次尝试失败，重试中... 错误: {str(e)[:100]}")
-                    await asyncio.sleep(0.5 * (attempt + 1))  # 指数退避
-                    continue
-                else:
-                    # 降级策略：标记为相关，避免误删
-                    self._log(f"[剪枝-LLM] LLM 调用失败 {max_retries} 次，使用降级策略（标记为相关）")
-                    fallback_response = DialogExtractionResponse(
-                        is_related=True,
-                        times=[],
-                        ids=[],
-                        amounts=[],
-                        contacts=[],
-                        addresses=[],
-                        keywords=[]
-                    )
-                    return fallback_response
+        try:
+            ex = await self.llm_client.response_structured(messages, DialogExtractionResponse)
+            self._dialog_extract_cache[cache_key] = ex
+            return ex
+        except Exception as e:
+            raise RuntimeError("LLM 结构化抽取失败；请检查 LLM 配置或重试。") from e
 
     def _msg_matches_tokens(self, message: ConversationMessage, tokens: List[str]) -> bool:
         """判断消息是否包含任意抽取到的重要片段。"""
@@ -401,56 +184,62 @@ class SemanticPruner:
             # 相关对话不剪枝
             return dialog
 
-        # 在不相关对话中，LLM 已通过 preserve_tokens 标记需要保护的内容
-        preserve_tokens = (
-            extraction.times + extraction.ids + extraction.amounts +
-            extraction.contacts + extraction.addresses + extraction.keywords +
-            extraction.preserve_keywords
-        )
+        # 在不相关对话中，识别重要/不重要消息
+        tokens = extraction.times + extraction.ids + extraction.amounts + extraction.contacts + extraction.addresses + extraction.keywords
         msgs = dialog.context.msgs
-
-        # 分类：填充 / 其他可删（LLM保护消息通过不加入任何桶来隐式保护）
-        filler_ids: set = set()
-        deletable: List[ConversationMessage] = []
-
+        imp_unrel_msgs: List[ConversationMessage] = []
+        unimp_unrel_msgs: List[ConversationMessage] = []
         for m in msgs:
-            if self._msg_matches_tokens(m, preserve_tokens):
-                pass  # 保护消息：不加入任何桶，不会被删除
-            elif self._is_filler_message(m):
-                filler_ids.add(id(m))
+            if self._msg_matches_tokens(m, tokens) or self._is_important_message(m):
+                imp_unrel_msgs.append(m)
             else:
-                deletable.append(m)
-
-        # 计算删除目标
+                unimp_unrel_msgs.append(m)
+        # 计算总删除目标数量
         total_unrel = len(msgs)
         delete_target = int(total_unrel * proportion)
         if proportion > 0 and total_unrel > 0 and delete_target == 0:
             delete_target = 1
-        max_deletable = min(len(filler_ids) + len(deletable), max(0, total_unrel - 1))
+        imp_del_cap = min(int(len(imp_unrel_msgs) * proportion), len(imp_unrel_msgs))
+        unimp_del_cap = len(unimp_unrel_msgs)
+        max_capacity = max(0, len(msgs) - 1)
+        max_deletable = min(imp_del_cap + unimp_del_cap, max_capacity)
         delete_target = min(delete_target, max_deletable)
+        # 删除配额分配
+        del_unimp = min(delete_target, unimp_del_cap)
+        rem = delete_target - del_unimp
+        del_imp = min(rem, imp_del_cap)
 
-        # 优先删填充，再删其他可删消息（按出现顺序）
-        to_delete_ids: set = set()
+        # 选取删除集合
+        unimp_delete_ids = []
+        imp_delete_ids = []
+        if del_unimp > 0:
+            # 按出现顺序选取前 del_unimp 条不重要消息进行删除（确定性、可复现）
+            unimp_delete_ids = [id(m) for m in unimp_unrel_msgs[:del_unimp]]
+        if del_imp > 0:
+            imp_sorted = sorted(imp_unrel_msgs, key=lambda m: self._importance_score(m))
+            imp_delete_ids = [id(m) for m in imp_sorted[:del_imp]]
+
+        # 统计实际删除数量（重要/不重要）
+        actual_unimp_deleted = 0
+        actual_imp_deleted = 0
+        kept_msgs = []
+        delete_targets = set(unimp_delete_ids) | set(imp_delete_ids)
         for m in msgs:
-            if len(to_delete_ids) >= delete_target:
-                break
-            if id(m) in filler_ids:
-                to_delete_ids.add(id(m))
-        for m in deletable:
-            if len(to_delete_ids) >= delete_target:
-                break
-            to_delete_ids.add(id(m))
-
-        kept_msgs = [m for m in msgs if id(m) not in to_delete_ids]
+            mid = id(m)
+            if mid in delete_targets:
+                if mid in set(unimp_delete_ids) and actual_unimp_deleted < del_unimp:
+                    actual_unimp_deleted += 1
+                    continue
+                if mid in set(imp_delete_ids) and actual_imp_deleted < del_imp:
+                    actual_imp_deleted += 1
+                    continue
+            kept_msgs.append(m)
         if not kept_msgs and msgs:
             kept_msgs = [msgs[0]]
 
-        deleted_total = len(msgs) - len(kept_msgs)
-        protected_count = len(msgs) - len(filler_ids) - len(deletable)
+        deleted_total = actual_unimp_deleted + actual_imp_deleted
         self._log(
-            f"[剪枝-对话] 对话ID={dialog.id} 总消息={len(msgs)} "
-            f"(保护={protected_count} 填充={len(filler_ids)} 可删={len(deletable)}) "
-            f"删除目标={delete_target} 实删={deleted_total} 保留={len(kept_msgs)}"
+            f"[剪枝-对话] 对话ID={dialog.id} 总消息={len(msgs)} 删除目标={delete_target} 实删={deleted_total} 保留={len(kept_msgs)}"
         )
 
         dialog.context = ConversationContext(msgs=kept_msgs)
@@ -459,14 +248,12 @@ class SemanticPruner:
     async def prune_dataset(self, dialogs: List[DialogData]) -> List[DialogData]:
         """数据集层面：全局消息级剪枝，保留所有对话。
 
-        改进版：
-        - 消息级独立判断，每条消息根据场景规则独立评估
-        - 问答对保护已注释（暂不启用，留作观察）
-        - 优化删除策略：填充消息 → 不重要消息 → 低分重要消息
-        - 只删除"不重要的不相关消息"，重要信息（时间、编号等）强制保留
-        - 保证每段对话至少保留1条消息，不会删除整段对话
+        - 仅在"不相关对话"的范围内执行消息剪枝；相关对话不动。
+        - 只删除"不重要的不相关消息"，重要信息（时间、编号等）强制保留。
+        - 删除总量 = 阈值 * 全部不相关可删消息数，按可删容量比例分配；顺序删除。
+        - 保证每段对话至少保留1条消息，不会删除整段对话。
         """
-        # 如果剪枝功能关闭，直接返回原始数据集
+        # 如果剪枝功能关闭，直接返回原始数据集。
         if not self.config.pruning_switch:
             return dialogs
 
@@ -477,139 +264,179 @@ class SemanticPruner:
             proportion = 0.9
         if proportion < 0.0:
             proportion = 0.0
+        evaluated_dialogs = []  # list of dicts: {dialog, is_related}
 
         self._log(
-            f"[剪枝-数据集] 对话总数={len(dialogs)} 场景={self.config.pruning_scene} 删除比例={proportion} 开关={self.config.pruning_switch} 模式=消息级独立判断"
+            f"[剪枝-数据集] 对话总数={len(dialogs)} 场景={self.config.pruning_scene} 删除比例={proportion} 开关={self.config.pruning_switch}"
         )
-        
+        # 对话级相关性分类（一次性对整段对话文本进行判断，顺序执行并复用缓存）
+        evaluated_dialogs = []
+        for idx, dd in enumerate(dialogs):
+            try:
+                ex = await self._extract_dialog_important(dd.content)
+                evaluated_dialogs.append({
+                    "dialog": dd,
+                    "is_related": bool(ex.is_related),
+                    "index": idx,
+                    "extraction": ex
+                })
+            except Exception:
+                evaluated_dialogs.append({
+                    "dialog": dd,
+                    "is_related": True,
+                    "index": idx,
+                    "extraction": None
+                })
+
+        # 统计相关 / 不相关对话
+        not_related_dialogs = [d for d in evaluated_dialogs if not d["is_related"]]
+        related_dialogs = [d for d in evaluated_dialogs if d["is_related"]]
+        self._log(
+            f"[剪枝-数据集] 相关对话数={len(related_dialogs)} 不相关对话数={len(not_related_dialogs)}"
+        )
+
+        # 简洁打印第几段对话相关/不相关（索引基于1）
+        def _fmt_indices(items, cap: int = 10):
+            inds = [i["index"] + 1 for i in items]
+            if len(inds) <= cap:
+                return inds
+            # 超过上限时只打印前cap个，并标注总数
+            return inds[:cap] + ["...", f"共{len(inds)}个"]
+
+        rel_inds = _fmt_indices(related_dialogs)
+        nrel_inds = _fmt_indices(not_related_dialogs)
+        self._log(f"[剪枝-数据集] 相关对话：第{rel_inds}段；不相关对话：第{nrel_inds}段")
+
         result: List[DialogData] = []
-        total_original_msgs = 0
-        total_deleted_msgs = 0
+        if not_related_dialogs:
+            # 为每个不相关对话进行一次性抽取，识别重要/不重要（避免逐条 LLM）
+            per_dialog_info = {}
+            total_unrelated = 0
+            total_capacity = 0
+            for d in not_related_dialogs:
+                dd = d["dialog"]
+                extraction = d.get("extraction")
+                if extraction is None:
+                    extraction = await self._extract_dialog_important(dd.content)
+                # 合并所有重要标记
+                tokens = extraction.times + extraction.ids + extraction.amounts + extraction.contacts + extraction.addresses + extraction.keywords
+                msgs = dd.context.msgs
+                # 分类消息
+                imp_unrel_msgs = [m for m in msgs if self._msg_matches_tokens(m, tokens) or self._is_important_message(m)]
+                unimp_unrel_msgs = [m for m in msgs if m not in imp_unrel_msgs]
+                # 重要消息按重要性排序
+                imp_sorted_ids = [id(m) for m in sorted(imp_unrel_msgs, key=lambda m: self._importance_score(m))]
+                info = {
+                    "dialog": dd,
+                    "total_msgs": len(msgs),
+                    "unrelated_count": len(msgs),
+                    "imp_ids_sorted": imp_sorted_ids,
+                    "unimp_ids": [id(m) for m in unimp_unrel_msgs],
+                }
+                per_dialog_info[d["index"]] = info
+                total_unrelated += info["unrelated_count"]
+            # 全局删除配额：比例作用于全部不相关消息（重要+不重要）
+            global_delete = int(total_unrelated * proportion)
+            if proportion > 0 and total_unrelated > 0 and global_delete == 0:
+                global_delete = 1
+            # 每段的最大可删容量：不重要全部 + 重要最多删除 floor(len(重要)*比例)，且至少保留1条消息
+            capacities = []
+            for d in not_related_dialogs:
+                idx = d["index"]
+                info = per_dialog_info[idx]
+                # 统计重要数量
+                imp_count = len(info["imp_ids_sorted"])
+                unimp_count = len(info["unimp_ids"])
+                imp_cap = int(imp_count * proportion)
+                cap = min(unimp_count + imp_cap, max(0, info["total_msgs"] - 1))
+                capacities.append(cap)
+            total_capacity = sum(capacities)
+            if global_delete > total_capacity:
+                print(f"[剪枝-数据集] 不相关消息总数={total_unrelated}，目标删除={global_delete}，最大可删={total_capacity}（重要消息按比例保留）。将按最大可删执行。")
+                global_delete = total_capacity
 
-        # 并发执行所有对话的 LLM 抽取（获取 preserve_keywords 等保护信息）
-        semaphore = asyncio.Semaphore(self.max_concurrent)
-
-        async def extract_with_semaphore(dd: DialogData) -> DialogExtractionResponse:
-            async with semaphore:
-                try:
-                    return await self._extract_dialog_important(dd.content)
-                except Exception as e:
-                    self._log(f"[剪枝-LLM] 对话抽取失败，使用降级策略: {str(e)[:100]}")
-                    return DialogExtractionResponse(is_related=True)
-
-        extraction_tasks = [extract_with_semaphore(dd) for dd in dialogs]
-        extraction_results: List[DialogExtractionResponse] = await asyncio.gather(*extraction_tasks)
-
-        for d_idx, (dd, extraction) in enumerate(zip(dialogs, extraction_results)):
-            msgs = dd.context.msgs
-            original_count = len(msgs)
-            total_original_msgs += original_count
-
-            # 从 LLM 抽取结果中获取所有需要保留的 token
-            preserve_tokens = (
-                extraction.times + extraction.ids + extraction.amounts +
-                extraction.contacts + extraction.addresses + extraction.keywords +
-                extraction.preserve_keywords  # 情绪/兴趣/爱好关键词
-            )
-
-            # 判断是否需要详细日志
-            should_log_details = self._detailed_prune_logging and original_count <= self._max_debug_msgs_per_dialog
-            if self._detailed_prune_logging and original_count > self._max_debug_msgs_per_dialog:
-                self._log(f"  对话[{d_idx}]消息数={original_count}，仅采样前{self._max_debug_msgs_per_dialog}条进行详细日志")
-
-            if extraction.preserve_keywords:
-                self._log(f"  对话[{d_idx}] LLM抽取到情绪/兴趣保护词: {extraction.preserve_keywords}")
-
-            # 消息级分类：LLM保护 / 填充 / 其他可删
-            llm_protected_msgs = []  # LLM 保护消息（preserve_tokens 命中）：绝对不可删除
-            filler_msgs = []         # 填充消息（优先删除）
-            deletable_msgs = []      # 其余消息（按比例删除）
-
-            for idx, m in enumerate(msgs):
-                msg_text = m.msg.strip()
-
-                if self._msg_matches_tokens(m, preserve_tokens):
-                    llm_protected_msgs.append((idx, m))
-                    if should_log_details or idx < self._max_debug_msgs_per_dialog:
-                        self._log(f"  [{idx}] '{msg_text[:30]}...' → 保护（LLM，不可删）")
-                elif self._is_filler_message(m):
-                    filler_msgs.append((idx, m))
-                    if should_log_details or idx < self._max_debug_msgs_per_dialog:
-                        self._log(f"  [{idx}] '{msg_text[:30]}...' → 填充")
-                else:
-                    deletable_msgs.append((idx, m))
-                    if should_log_details or idx < self._max_debug_msgs_per_dialog:
-                        self._log(f"  [{idx}] '{msg_text[:30]}...' → 可删")
-
-            # important_msgs 仅用于日志统计
-            important_msgs = llm_protected_msgs
-            
-            # 计算删除配额
-            delete_target = int(original_count * proportion)
-            if proportion > 0 and original_count > 0 and delete_target == 0:
-                delete_target = 1
-            
-            # 确保至少保留1条消息
-            max_deletable = max(0, original_count - 1)
-            delete_target = min(delete_target, max_deletable)
-            
-            # 删除策略：优先删填充消息，再按出现顺序删其余可删消息
-            to_delete_indices = set()
-            deleted_details = []
-
-            # 第一步：删除填充消息
-            for idx, msg in filler_msgs:
-                if len(to_delete_indices) >= delete_target:
+            # 配额分配：按不相关消息占比分配到各对话，但不超过各自容量
+            alloc = []
+            for i, d in enumerate(not_related_dialogs):
+                idx = d["index"]
+                info = per_dialog_info[idx]
+                share = int(global_delete * (info["unrelated_count"] / total_unrelated)) if total_unrelated > 0 else 0
+                alloc.append(min(share, capacities[i]))
+            allocated = sum(alloc)
+            rem = global_delete - allocated
+            turn = 0
+            while rem > 0 and turn < 100000:
+                progressed = False
+                for i in range(len(not_related_dialogs)):
+                    if rem <= 0:
+                        break
+                    if alloc[i] < capacities[i]:
+                        alloc[i] += 1
+                        rem -= 1
+                        progressed = True
+                if not progressed:
                     break
-                to_delete_indices.add(idx)
-                deleted_details.append(f"[{idx}] 填充: '{msg.msg[:50]}'")
+                turn += 1
 
-            # 第二步：如果还需要删除，按出现顺序删可删消息
-            for idx, msg in deletable_msgs:
-                if len(to_delete_indices) >= delete_target:
-                    break
-                to_delete_indices.add(idx)
-                deleted_details.append(f"[{idx}] 可删: '{msg.msg[:50]}'")
-            
-            # 执行删除
-            kept_msgs = []
-            for idx, m in enumerate(msgs):
-                if idx not in to_delete_indices:
-                    kept_msgs.append(m)
-            
-            # 确保至少保留1条
-            if not kept_msgs and msgs:
-                kept_msgs = [msgs[0]]
-            
-            dd.context.msgs = kept_msgs
-            deleted_count = original_count - len(kept_msgs)
-            total_deleted_msgs += deleted_count
-            
-            # 输出删除详情
-            if deleted_details:
-                self._log(f"[剪枝-删除详情] 对话 {d_idx+1} 删除了以下消息:")
-                for detail in deleted_details:
-                    self._log(f"  {detail}")
-            
-            # ========== 问答对统计（已注释） ==========
-            # qa_info = f"，问答对={len(qa_pairs)}" if qa_pairs else ""
-            # ========================================
-            
-            self._log(
-                f"[剪枝-对话] 对话 {d_idx+1} 总消息={original_count} "
-                f"(保护={len(important_msgs)} 填充={len(filler_msgs)} 可删={len(deletable_msgs)}) "
-                f"删除={deleted_count} 保留={len(kept_msgs)}"
-            )
-            
-            result.append(dd)
-        
+            # 应用删除：相关对话不动；不相关按分配先删不重要，再删重要（低分优先）
+            total_deleted_confirm = 0
+            for d in evaluated_dialogs:
+                dd = d["dialog"]
+                msgs = dd.context.msgs
+                original = len(msgs)
+                if d["is_related"]:
+                    result.append(dd)
+                    continue
+                idx_in_unrel = next((k for k, x in enumerate(not_related_dialogs) if x["index"] == d["index"]), None)
+                if idx_in_unrel is None:
+                    result.append(dd)
+                    continue
+                quota = alloc[idx_in_unrel]
+                info = per_dialog_info[d["index"]]
+                # 计算本对话重要最多可删数量
+                imp_count = len(info["imp_ids_sorted"])
+                imp_del_cap = int(imp_count * proportion)
+                # 先构造顺序删除的"不重要ID集合"（按出现顺序前 quota 条）
+                unimp_delete_ids = set(info["unimp_ids"][:min(quota, len(info["unimp_ids"]))])
+                del_unimp = min(quota, len(unimp_delete_ids))
+                rem_quota = quota - del_unimp
+                # 再从重要里选低分优先的删除ID（不超过 imp_del_cap）
+                imp_delete_ids = set(info["imp_ids_sorted"][:min(rem_quota, imp_del_cap)])
+                deleted_here = 0
+                actual_unimp_deleted = 0
+                actual_imp_deleted = 0
+                kept = []
+                for m in msgs:
+                    mid = id(m)
+                    if mid in unimp_delete_ids and actual_unimp_deleted < del_unimp:
+                        actual_unimp_deleted += 1
+                        deleted_here += 1
+                        continue
+                    if mid in imp_delete_ids and actual_imp_deleted < len(imp_delete_ids):
+                        actual_imp_deleted += 1
+                        deleted_here += 1
+                        continue
+                    kept.append(m)
+                if not kept and msgs:
+                    kept = [msgs[0]]
+                dd.context.msgs = kept
+                total_deleted_confirm += deleted_here
+                self._log(
+                    f"[剪枝-对话] 对话 {d['index']+1} 总消息={original} 分配删除={quota} 实删={deleted_here} 保留={len(kept)}"
+                )
+                result.append(dd)
+            self._log(f"[剪枝-数据集] 全局消息级顺序剪枝完成，总删除 {total_deleted_confirm} 条（不相关消息，重要按比例保留）。")
+        else:
+            # 全部相关：不执行剪枝
+            result = [d["dialog"] for d in evaluated_dialogs]
         self._log(f"[剪枝-数据集] 剩余对话数={len(result)}")
 
-        # 保存日志
+        # 将本次剪枝阶段的终端输出保存为 JSON 文件（仅在剪枝器内部完成）
         try:
             from app.core.config import settings
             settings.ensure_memory_output_dir()
             log_output_path = settings.get_memory_output_path("pruned_terminal.json")
+            # 去除日志前缀标签（如 [剪枝-数据集]、[剪枝-对话]）后再解析为结构化字段保存
             sanitized_logs = [self._sanitize_log_line(l) for l in self.run_logs]
             payload = self._parse_logs_to_structured(sanitized_logs)
             with open(log_output_path, "w", encoding="utf-8") as f:
@@ -621,7 +448,6 @@ class SemanticPruner:
         if not result:
             print("警告: 语义剪枝后数据集为空，已回退为未剪枝数据以避免流程中断")
             return dialogs
-        
         return result
 
     def _log(self, msg: str) -> None:

api/app/core/memory/storage_services/extraction_engine/data_preprocessing/scene_config.py

@@ -1,66 +0,0 @@
-"""
-场景特定配置 - 统一填充词库
-
-重要性判断已完全交由 extracat_Pruning.jinja2 提示词 + LLM preserve_tokens 机制承担。
-本模块仅保留统一填充词库（filler_phrases），用于识别无意义寒暄/表情/口头禅。
-所有场景共用同一份词库，场景差异由 LLM 语义判断处理。
-"""
-
-from typing import List, Set
-from dataclasses import dataclass, field
-
-
-@dataclass
-class ScenePatterns:
-    """场景特定的识别模式（仅保留填充词库）"""
-    filler_phrases: Set[str] = field(default_factory=set)
-
-
-class SceneConfigRegistry:
-    """场景配置注册表 - 所有场景共用统一填充词库"""
-
-    BASE_FILLERS: Set[str] = {
-        # 基础寒暄
-        "你好", "您好", "在吗", "在的", "在呢", "嗯", "嗯嗯", "哦", "哦哦",
-        "好的", "好", "行", "可以", "不可以", "谢谢", "多谢", "感谢",
-        "拜拜", "再见", "88", "拜", "回见",
-        # 口头禅
-        "哈哈", "呵呵", "哈哈哈", "嘿嘿", "嘻嘻", "hiahia",
-        "额", "呃", "啊", "诶", "唉", "哎", "嗯哼",
-        # 确认词
-        "是的", "对", "对的", "没错", "好嘞", "收到", "明白", "了解", "知道了",
-        # 服务类套话
-        "请问", "请稍等", "稍等", "马上", "立即",
-        "正在查询", "正在处理", "正在为您", "帮您查一下",
-        "还有其他问题吗", "还需要什么帮助", "很高兴为您服务",
-        "感谢您的耐心等待", "抱歉让您久等了",
-        "已记录", "已反馈", "已转接", "已升级",
-        "祝您生活愉快", "欢迎下次咨询",
-        # 外呼套话
-        "喂", "hello", "打扰了", "不好意思",
-        "方便接电话吗", "现在方便吗", "占用您一点时间",
-        "我是", "我们是", "我们公司", "我们这边",
-        "了解一下", "介绍一下", "简单说一下",
-        "考虑考虑", "想一想", "再说", "再看看",
-        "不需要", "不感兴趣", "没兴趣", "不用了",
-        "没问题", "那就这样", "再联系", "回头聊", "有需要再说",
-        # 教育场景套话
-        "老师好", "同学们好", "上课", "下课", "起立", "坐下",
-        "举手", "请坐", "很好", "不错", "继续",
-        "下一个", "下一题", "下一位", "还有吗", "还有问题吗",
-        # 标点和符号
-        "。。。", "...", "???", "？？？", "!!!", "！！！",
-        # 表情符号
-        "[微笑]", "[呲牙]", "[发呆]", "[得意]", "[流泪]", "[害羞]", "[闭嘴]",
-        "[睡]", "[大哭]", "[尴尬]", "[发怒]", "[调皮]", "[龇牙]", "[惊讶]",
-        "[难过]", "[酷]", "[冷汗]", "[抓狂]", "[吐]", "[偷笑]", "[可爱]",
-        "[白眼]", "[傲慢]", "[饥饿]", "[困]", "[惊恐]", "[流汗]", "[憨笑]",
-        # 网络用语
-        "hhh", "hhhh", "2333", "666", "gg", "ok", "OK", "okok",
-        "emmm", "emm", "em", "mmp", "wtf", "omg",
-    }
-
-    @classmethod
-    def get_config(cls, scene: str = "") -> ScenePatterns:
-        """所有场景统一返回同一份填充词库"""
-        return ScenePatterns(filler_phrases=cls.BASE_FILLERS)

api/app/core/memory/storage_services/extraction_engine/deduplication/deduped_and_disamb.py

@@ -134,45 +134,42 @@ def _merge_attribute(canonical: ExtractedEntityNode, ent: ExtractedEntityNode):
         if len(desc_b) > len(desc_a):
             canonical.description = desc_b
         # 合并事实摘要：统一保留一个“实体: name”行，来源行去重保序
-        # TODO: fact_summary 功能暂时禁用，待后续开发完善后启用
-        # fact_a = getattr(canonical, "fact_summary", "") or ""
-        # fact_b = getattr(ent, "fact_summary", "") or ""
-        # def _extract_sources(txt: str) -> List[str]:
-            # sources: List[str] = []
-            # if not txt:
-                # return sources
-            # for line in str(txt).splitlines():
-                # ln = line.strip()
+        fact_a = getattr(canonical, "fact_summary", "") or ""
+        fact_b = getattr(ent, "fact_summary", "") or ""
+        def _extract_sources(txt: str) -> List[str]:
+            sources: List[str] = []
+            if not txt:
+                return sources
+            for line in str(txt).splitlines():
+                ln = line.strip()
                 # 支持“来源:”或“来源：”前缀
-                # m = re.match(r"^来源[:：]\s*(.+)$", ln)
-                # if m:
-                    # content = m.group(1).strip()
-                    # if content:
-                        # sources.append(content)
+                m = re.match(r"^来源[:：]\s*(.+)$", ln)
+                if m:
+                    content = m.group(1).strip()
+                    if content:
+                        sources.append(content)
             # 如果不存在“来源”前缀，则将整体文本视为一个来源片段，避免信息丢失
-            # if not sources and txt.strip():
-                # sources.append(txt.strip())
-            # return sources
+            if not sources and txt.strip():
+                sources.append(txt.strip())
+            return sources
         try:
-            #     src_a = _extract_sources(fact_a)
-            #     src_b = _extract_sources(fact_b)
-            #     seen = set()
-            #     merged_sources: List[str] = []
-            #     for s in src_a + src_b:
-            #         if s and s not in seen:
-            #             seen.add(s)
-            #             merged_sources.append(s)
-            #     if merged_sources:
-            #         name_line = f"实体: {getattr(canonical, 'name', '')}".strip()
-            #         canonical.fact_summary = "\n".join([name_line] + [f"来源: {s}" for s in merged_sources])
-            #     elif fact_b and not fact_a:
-            #         canonical.fact_summary = fact_b
-            pass
+            src_a = _extract_sources(fact_a)
+            src_b = _extract_sources(fact_b)
+            seen = set()
+            merged_sources: List[str] = []
+            for s in src_a + src_b:
+                if s and s not in seen:
+                    seen.add(s)
+                    merged_sources.append(s)
+            if merged_sources:
+                name_line = f"实体: {getattr(canonical, 'name', '')}".strip()
+                canonical.fact_summary = "\n".join([name_line] + [f"来源: {s}" for s in merged_sources])
+            elif fact_b and not fact_a:
+                canonical.fact_summary = fact_b
         except Exception:
             # 兜底：若解析失败，保留较长文本
-            # if len(fact_b) > len(fact_a):
-            #     canonical.fact_summary = fact_b
-            pass
+            if len(fact_b) > len(fact_a):
+                canonical.fact_summary = fact_b
     except Exception:
         pass
 

api/app/core/memory/storage_services/extraction_engine/deduplication/entity_dedup_llm.py

@@ -145,13 +145,10 @@ def _choose_canonical(a: ExtractedEntityNode, b: ExtractedEntityNode) -> int: #
      # 2. 第二优先级：按“描述+事实摘要”的总长度排序（内容越长，信息越完整）
     desc_a = (getattr(a, "description", "") or "")
     desc_b = (getattr(b, "description", "") or "")
-    # TODO: fact_summary 功能暂时禁用，待后续开发完善后启用
-    # fact_a = (getattr(a, "fact_summary", "") or "")
-    # fact_b = (getattr(b, "fact_summary", "") or "")
-    # score_a = len(desc_a) + len(fact_a)
-    # score_b = len(desc_b) + len(fact_b)
-    score_a = len(desc_a)
-    score_b = len(desc_b)
+    fact_a = (getattr(a, "fact_summary", "") or "")
+    fact_b = (getattr(b, "fact_summary", "") or "")
+    score_a = len(desc_a) + len(fact_a)
+    score_b = len(desc_b) + len(fact_b)
     if score_a != score_b:
         return 0 if score_a >= score_b else 1
     return 0
@@ -192,8 +189,7 @@ async def _judge_pair(
         "entity_type": getattr(a, "entity_type", None),
         "description": getattr(a, "description", None),
         "aliases": getattr(a, "aliases", None) or [],
-        # TODO: fact_summary 功能暂时禁用，待后续开发完善后启用
-        # "fact_summary": getattr(a, "fact_summary", None),
+        "fact_summary": getattr(a, "fact_summary", None),
         "connect_strength": getattr(a, "connect_strength", None),
     }
     entity_b = {
@@ -201,8 +197,7 @@ async def _judge_pair(
         "entity_type": getattr(b, "entity_type", None),
         "description": getattr(b, "description", None),
         "aliases": getattr(b, "aliases", None) or [],
-        # TODO: fact_summary 功能暂时禁用，待后续开发完善后启用
-        # "fact_summary": getattr(b, "fact_summary", None),
+        "fact_summary": getattr(b, "fact_summary", None),
         "connect_strength": getattr(b, "connect_strength", None),
     }
  # 5. 渲染LLM提示词（用工具函数填充模板，包含实体信息、上下文、输出格式）
@@ -253,8 +248,7 @@ async def _judge_pair_disamb(
         "entity_type": getattr(a, "entity_type", None),
         "description": getattr(a, "description", None),
         "aliases": getattr(a, "aliases", None) or [],
-        # TODO: fact_summary 功能暂时禁用，待后续开发完善后启用
-        # "fact_summary": getattr(a, "fact_summary", None),
+        "fact_summary": getattr(a, "fact_summary", None),
         "connect_strength": getattr(a, "connect_strength", None),
     }
     entity_b = {
@@ -262,8 +256,7 @@ async def _judge_pair_disamb(
         "entity_type": getattr(b, "entity_type", None),
         "description": getattr(b, "description", None),
         "aliases": getattr(b, "aliases", None) or [],
-        # TODO: fact_summary 功能暂时禁用，待后续开发完善后启用
-        # "fact_summary": getattr(b, "fact_summary", None),
+        "fact_summary": getattr(b, "fact_summary", None),
         "connect_strength": getattr(b, "connect_strength", None),
     }
     prompt = render_entity_dedup_prompt(

api/app/core/memory/storage_services/extraction_engine/deduplication/second_layer_dedup.py

@@ -72,8 +72,7 @@ def _row_to_entity(row: Dict[str, Any]) -> ExtractedEntityNode:
         description=row.get("description") or "",
         aliases=row.get("aliases") or [],
         name_embedding=row.get("name_embedding") or [],
-        # TODO: fact_summary 功能暂时禁用，待后续开发完善后启用
-        # fact_summary=row.get("fact_summary") or "",
+        fact_summary=row.get("fact_summary") or "",
         connect_strength=row.get("connect_strength") or "",
     )
 

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
         )
 
         # 全局并行处理所有陈述句
@@ -1131,8 +1085,7 @@ class ExtractionOrchestrator:
                                     entity_type=getattr(entity, 'type', 'unknown'),  # 使用 type 而不是 entity_type
                                     description=getattr(entity, 'description', ''),  # 添加必需的 description 字段
                                     example=getattr(entity, 'example', ''),  # 新增：传递示例字段
-                                    # TODO: fact_summary 功能暂时禁用，待后续开发完善后启用
-                                    # fact_summary=getattr(entity, 'fact_summary', ''),  # 添加必需的 fact_summary 字段
+                                    fact_summary=getattr(entity, 'fact_summary', ''),  # 添加必需的 fact_summary 字段
                                     connect_strength=entity_connect_strength if entity_connect_strength is not None else 'Strong',  # 添加必需的 connect_strength 字段
                                     aliases=getattr(entity, 'aliases', []) or [],  # 传递从三元组提取阶段获取的aliases
                                     name_embedding=getattr(entity, 'name_embedding', None),
@@ -1932,17 +1885,17 @@ def preprocess_data(
     Returns:
         经过清洗转换后的 DialogData 列表
     """
-    logger.debug("=== 数据预处理 ===")
+    print("\n=== 数据预处理 ===")
     from app.core.memory.storage_services.extraction_engine.data_preprocessing.data_preprocessor import (
         DataPreprocessor,
     )
     preprocessor = DataPreprocessor()
     try:
         cleaned_data = preprocessor.preprocess(input_path=input_path, output_path=output_path, skip_cleaning=skip_cleaning, indices=indices)
-        logger.debug(f"数据预处理完成！共处理了 {len(cleaned_data)} 条对话数据")
+        print(f"数据预处理完成！共处理了 {len(cleaned_data)} 条对话数据")
         return cleaned_data
     except Exception as e:
-        logger.error(f"数据预处理过程中出现错误: {e}")
+        print(f"数据预处理过程中出现错误: {e}")
         raise
 
 
@@ -1961,7 +1914,7 @@ async def get_chunked_dialogs_from_preprocessed(
     Returns:
         带 chunks 的 DialogData 列表
     """
-    logger.debug(f"=== 批量对话分块处理 (使用 {chunker_strategy}) ===")
+    print(f"\n=== 批量对话分块处理 (使用 {chunker_strategy}) ===")
     if not data:
         raise ValueError("预处理数据为空，无法进行分块")
         
@@ -1988,7 +1941,6 @@ async def get_chunked_dialogs_with_preprocessing(
     input_data_path: Optional[str] = None,
     llm_client: Optional[Any] = None,
     skip_cleaning: bool = True,
-    pruning_config: Optional[Dict] = None,
 ) -> List[DialogData]:
     """包含数据预处理步骤的完整分块流程
     
@@ -2001,12 +1953,11 @@ async def get_chunked_dialogs_with_preprocessing(
         input_data_path: 输入数据路径
         llm_client: LLM 客户端
         skip_cleaning: 是否跳过数据清洗步骤（默认False）
-        pruning_config: 剪枝配置字典，包含 pruning_switch, pruning_scene, pruning_threshold
         
     Returns:
         带 chunks 的 DialogData 列表
     """
-    logger.debug("=== 完整数据处理流程（包含预处理）===")
+    print("\n=== 完整数据处理流程（包含预处理）===")
 
     if input_data_path is None:
         input_data_path = os.path.join(
@@ -2032,19 +1983,7 @@ async def get_chunked_dialogs_with_preprocessing(
         from app.core.memory.storage_services.extraction_engine.data_preprocessing.data_pruning import (
             SemanticPruner,
         )
-        from app.core.memory.models.config_models import PruningConfig
-        
-        # 构建剪枝配置
-        if pruning_config:
-            # 使用传入的配置
-            config = PruningConfig(**pruning_config)
-            logger.debug(f"[剪枝] 使用传入配置: switch={config.pruning_switch}, scene={config.pruning_scene}, threshold={config.pruning_threshold}")
-        else:
-            # 使用默认配置（关闭剪枝）
-            config = None
-            logger.debug("[剪枝] 未提供配置，使用默认配置（剪枝关闭）")
-        
-        pruner = SemanticPruner(config=config, llm_client=llm_client)
+        pruner = SemanticPruner(llm_client=llm_client)
         
         # 记录单对话场景下剪枝前的消息数量
         single_dialog_original_msgs = None
@@ -2057,12 +1996,12 @@ async def get_chunked_dialogs_with_preprocessing(
         if len(preprocessed_data) == 1 and single_dialog_original_msgs is not None:
             remaining_msgs = len(preprocessed_data[0].context.msgs) if preprocessed_data[0].context else 0
             deleted_msgs = max(0, single_dialog_original_msgs - remaining_msgs)
-            logger.debug(
+            print(
                 f"语义剪枝完成！剩余 1 条对话！原始消息数：{single_dialog_original_msgs}，"
                 f"保留消息数：{remaining_msgs}，删除 {deleted_msgs} 条。"
             )
         else:
-            logger.debug(f"语义剪枝完成！剩余 {len(preprocessed_data)} 条对话")
+            print(f"语义剪枝完成！剩余 {len(preprocessed_data)} 条对话")
             
         # 保存剪枝后的数据
         try:
@@ -2073,9 +2012,9 @@ async def get_chunked_dialogs_with_preprocessing(
             dp = DataPreprocessor(output_file_path=pruned_output_path)
             dp.save_data(preprocessed_data, output_path=pruned_output_path)
         except Exception as se:
-            logger.error(f"保存剪枝结果失败：{se}")
+            print(f"保存剪枝结果失败：{se}")
     except Exception as e:
-        logger.error(f"语义剪枝过程中出现错误，跳过剪枝: {e}")
+        print(f"语义剪枝过程中出现错误，跳过剪枝: {e}")
         
     # 步骤3: 对话分块
     return await get_chunked_dialogs_from_preprocessed(

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

@@ -8,5 +8,4 @@
 - TemporalExtractor: 时间信息提取
 - EmbeddingGenerator: 嵌入向量生成
 - MemorySummaryGenerator: 记忆摘要生成
-- OntologyExtractor: 本体类提取
 """

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

@@ -1,7 +1,5 @@
 import os
-from typing import Optional, List, Any
-from enum import Enum
-from pathlib import Path
+from typing import Optional
 
 from app.core.logging_config import get_memory_logger
 from app.core.memory.models.message_models import DialogData, Chunk
@@ -12,20 +10,6 @@ from app.core.memory.utils.config.config_utils import get_chunker_config
 logger = get_memory_logger(__name__)
 
 
-class ChunkerStrategy(Enum):
-    """Supported chunking strategies."""
-    RECURSIVE = "RecursiveChunker"
-    SEMANTIC = "SemanticChunker"
-    LATE = "LateChunker"
-    NEURAL = "NeuralChunker"
-    LLM = "LLMChunker"
-    
-    @classmethod
-    def get_valid_strategies(cls) -> List[str]:
-        """Get list of valid strategy names."""
-        return [strategy.value for strategy in cls]
-
-
 class DialogueChunker:
     """A class that processes dialogues and fills them with chunks based on a specified strategy.
 
@@ -33,51 +17,23 @@ class DialogueChunker:
     of different chunking strategies to dialogue data.
     """
 
-    def __init__(self, chunker_strategy: str = "RecursiveChunker", llm_client: Optional[Any] = None):
+    def __init__(self, chunker_strategy: str = "RecursiveChunker", llm_client=None):
         """Initialize the DialogueChunker with a specific chunking strategy.
 
         Args:
             chunker_strategy: The chunking strategy to use (default: RecursiveChunker)
-                             Options: SemanticChunker, RecursiveChunker, LateChunker, NeuralChunker, LLMChunker
-            llm_client: LLM client instance (required for LLMChunker strategy)
-            
-        Raises:
-            ValueError: If chunker_strategy is invalid or required parameters are missing
+                             Options: SemanticChunker, RecursiveChunker, LateChunker, NeuralChunker
         """
-        # Validate strategy
-        valid_strategies = ChunkerStrategy.get_valid_strategies()
-        if chunker_strategy not in valid_strategies:
-            raise ValueError(
-                f"Invalid chunker_strategy: '{chunker_strategy}'. "
-                f"Must be one of {valid_strategies}"
-            )
-        
         self.chunker_strategy = chunker_strategy
-        logger.info(f"Initializing DialogueChunker with strategy: {chunker_strategy}")
+        chunker_config_dict = get_chunker_config(chunker_strategy)
+        self.chunker_config = ChunkerConfig.model_validate(chunker_config_dict)
         
-        try:
-            # Load and validate configuration
-            chunker_config_dict = get_chunker_config(chunker_strategy)
-            if not chunker_config_dict:
-                raise ValueError(f"Failed to load configuration for strategy: {chunker_strategy}")
-            
-            self.chunker_config = ChunkerConfig.model_validate(chunker_config_dict)
-            
-            # Initialize chunker client
-            if self.chunker_config.chunker_strategy == "LLMChunker":
-                if not llm_client:
-                    raise ValueError("llm_client is required for LLMChunker strategy")
-                self.chunker_client = ChunkerClient(self.chunker_config, llm_client)
-            else:
-                self.chunker_client = ChunkerClient(self.chunker_config)
-            
-            logger.info(f"DialogueChunker initialized successfully with strategy: {chunker_strategy}")
-            
-        except Exception as e:
-            logger.error(f"Failed to initialize DialogueChunker: {e}", exc_info=True)
-            raise
+        if self.chunker_config.chunker_strategy == "LLMChunker":
+            self.chunker_client = ChunkerClient(self.chunker_config, llm_client)
+        else:
+            self.chunker_client = ChunkerClient(self.chunker_config)
 
-    async def process_dialogue(self, dialogue: DialogData) -> List[Chunk]:
+    async def process_dialogue(self, dialogue: DialogData) -> list[Chunk]:
         """Process a dialogue by generating chunks and adding them to the DialogData object.
 
         Args:
@@ -87,125 +43,54 @@ class DialogueChunker:
             A list of Chunk objects
 
         Raises:
-            ValueError: If dialogue is invalid or chunking fails
-            Exception: If chunking process encounters an error
+            ValueError: If chunking fails or returns empty chunks
         """
-        # Validate input
-        if not dialogue:
-            raise ValueError("dialogue cannot be None")
-        
-        if not dialogue.context or not dialogue.context.msgs:
+        result_dialogue = await self.chunker_client.generate_chunks(dialogue)
+        chunks = result_dialogue.chunks
+
+        if not chunks or len(chunks) == 0:
             raise ValueError(
-                f"Dialogue {dialogue.ref_id} has no messages to chunk. "
-                f"Context: {dialogue.context is not None}, "
-                f"Messages: {len(dialogue.context.msgs) if dialogue.context else 0}"
+                f"Chunking failed: No chunks generated for dialogue {dialogue.ref_id}. "
+                f"Messages: {len(dialogue.context.msgs) if dialogue.context else 0}, "
+                f"Strategy: {self.chunker_config.chunker_strategy}"
             )
-        
-        logger.info(
-            f"Processing dialogue {dialogue.ref_id} with {len(dialogue.context.msgs)} messages "
-            f"using strategy: {self.chunker_strategy}"
-        )
-        
-        try:
-            # Generate chunks
-            result_dialogue = await self.chunker_client.generate_chunks(dialogue)
-            chunks = result_dialogue.chunks
 
-            # Validate results
-            if not chunks or len(chunks) == 0:
-                raise ValueError(
-                    f"Chunking failed: No chunks generated for dialogue {dialogue.ref_id}. "
-                    f"Messages: {len(dialogue.context.msgs)}, "
-                    f"Content length: {len(dialogue.content) if dialogue.content else 0}, "
-                    f"Strategy: {self.chunker_config.chunker_strategy}"
-                )
+        return chunks
 
-            logger.info(
-                f"Successfully generated {len(chunks)} chunks for dialogue {dialogue.ref_id}. "
-                f"Total characters processed: {len(dialogue.content) if dialogue.content else 0}"
-            )
-            
-            return chunks
-            
-        except ValueError:
-            # Re-raise validation errors
-            raise
-        except Exception as e:
-            logger.error(
-                f"Error processing dialogue {dialogue.ref_id} with strategy {self.chunker_strategy}: {e}",
-                exc_info=True
-            )
-            raise
-
-    def save_chunking_results(
-        self, 
-        chunks: List[Chunk], 
-        dialogue: DialogData, 
-        output_path: Optional[str] = None,
-        preview_length: int = 100
-    ) -> str:
+    def save_chunking_results(self, dialogue: DialogData, output_path: Optional[str] = None) -> str:
         """Save the chunking results to a file and return the output path.
 
         Args:
-            chunks: List of Chunk objects to save
-            dialogue: The DialogData object that was processed
-            output_path: Optional path to save the output (defaults to current directory)
-            preview_length: Maximum length of content preview (default: 100)
+            dialogue: The processed DialogData object with chunks
+            output_path: Optional path to save the output
 
         Returns:
             The path where the output was saved
-            
-        Raises:
-            ValueError: If chunks or dialogue is invalid
-            IOError: If file writing fails
         """
-        # Validate input
-        if not chunks:
-            raise ValueError("chunks list cannot be empty")
-        if not dialogue:
-            raise ValueError("dialogue cannot be None")
-        
-        # Generate default output path if not provided
         if not output_path:
-            output_dir = Path(__file__).parent.parent.parent
-            output_path = str(output_dir / f"chunker_output_{self.chunker_strategy.lower()}.txt")
+            output_path = os.path.join(
+                os.path.dirname(__file__), "..", "..",
+                f"chunker_output_{self.chunker_strategy.lower()}.txt"
+            )
+
+        output_lines = [
+            f"=== Chunking Results ({self.chunker_strategy}) ===",
+            f"Dialogue ID: {dialogue.ref_id}",
+            f"Original conversation has {len(dialogue.context.msgs)} messages",
+            f"Total characters: {len(dialogue.content)}",
+            f"Generated {len(dialogue.chunks)} chunks:"
+        ]
         
-        logger.info(f"Saving chunking results to: {output_path}")
-        
-        try:
-            # Prepare output content
-            output_lines = [
-                f"=== Chunking Results ({self.chunker_strategy}) ===",
-                f"Dialogue ID: {dialogue.ref_id}",
-                f"Original conversation has {len(dialogue.context.msgs) if dialogue.context else 0} messages",
-                f"Total characters: {len(dialogue.content) if dialogue.content else 0}",
-                f"Generated {len(chunks)} chunks:",
-                ""
-            ]
-            
-            for i, chunk in enumerate(chunks, 1):
-                content_preview = chunk.content[:preview_length] if chunk.content else ""
-                if len(chunk.content) > preview_length:
-                    content_preview += "..."
-                
-                output_lines.append(f"  Chunk {i}: {len(chunk.content)} characters")
-                output_lines.append(f"    Content preview: {content_preview}")
-                if chunk.metadata:
-                    output_lines.append(f"    Metadata: {chunk.metadata}")
-                output_lines.append("")
+        for i, chunk in enumerate(dialogue.chunks):
+            output_lines.append(f"  Chunk {i+1}: {len(chunk.content)} characters")
+            output_lines.append(f"    Content preview: {chunk.content}...")
+            if chunk.metadata:
+                output_lines.append(f"    Metadata: {chunk.metadata}")
 
-            # Write to file
-            with open(output_path, "w", encoding="utf-8") as f:
-                f.write("\n".join(output_lines))
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write("\n".join(output_lines))
 
-            logger.info(f"Successfully saved chunking results to: {output_path}")
-            return output_path
-            
-        except IOError as e:
-            logger.error(f"Failed to write chunking results to {output_path}: {e}", exc_info=True)
-            raise
-        except Exception as e:
-            logger.error(f"Unexpected error saving chunking results: {e}", exc_info=True)
-            raise
+        logger.info(f"Chunking results saved to: {output_path}")
+        return output_path
 
 

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

@@ -10,7 +10,6 @@ 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__)
@@ -32,8 +31,7 @@ class MemorySummaryResponse(RobustLLMResponse):
 
 async def generate_title_and_type_for_summary(
     content: str,
-    llm_client,
-    language: str = "zh"
+    llm_client
 ) -> Tuple[str, str]:
     """
     为MemorySummary生成标题和类型
@@ -43,16 +41,12 @@ async def generate_title_and_type_for_summary(
     Args:
         content: Summary的内容文本
         llm_client: LLM客户端实例
-        language: 生成标题使用的语言 ("zh" 中文, "en" 英文)，默认中文
         
     Returns:
         (标题, 类型)元组
     """
     from app.core.memory.utils.prompt.prompt_utils import render_episodic_title_and_type_prompt
     
-    # 验证语言参数
-    language = validate_language(language)
-    
     # 定义有效的类型集合
     VALID_TYPES = {
         "conversation",      # 对话
@@ -63,19 +57,13 @@ async def generate_title_and_type_for_summary(
     }
     DEFAULT_TYPE = "conversation"  # 默认类型
     
-    # 根据语言设置默认标题
-    DEFAULT_TITLE = "空内容" if language == "zh" else "Empty Content"
-    PARSE_ERROR_TITLE = "解析失败" if language == "zh" else "Parse Failed"
-    ERROR_TITLE = "错误" if language == "zh" else "Error"
-    UNKNOWN_TITLE = "未知标题" if language == "zh" else "Unknown Title"
-    
     try:
         if not content:
-            logger.warning(f"content为空，无法生成标题和类型 (language={language})")
-            return (DEFAULT_TITLE, DEFAULT_TYPE)
+            logger.warning("content为空，无法生成标题和类型")
+            return ("空内容", DEFAULT_TYPE)
         
-        # 1. 渲染Jinja2提示词模板，传递语言参数
-        prompt = await render_episodic_title_and_type_prompt(content, language=language)
+        # 1. 渲染Jinja2提示词模板
+        prompt = await render_episodic_title_and_type_prompt(content)
         
         # 2. 调用LLM生成标题和类型
         messages = [
@@ -114,7 +102,7 @@ async def generate_title_and_type_for_summary(
             json_str = json_str.strip()
             
             result_data = json.loads(json_str)
-            title = result_data.get("title", UNKNOWN_TITLE)
+            title = result_data.get("title", "未知标题")
             episodic_type_raw = result_data.get("type", DEFAULT_TYPE)
             
             # 5. 校验和归一化类型
@@ -142,23 +130,22 @@ async def generate_title_and_type_for_summary(
                     f"已归一化为 '{episodic_type}'"
                 )
             
-            logger.info(f"成功生成标题和类型 (language={language}): title={title}, type={episodic_type}")
+            logger.info(f"成功生成标题和类型: title={title}, type={episodic_type}")
             return (title, episodic_type)
             
         except json.JSONDecodeError:
-            logger.error(f"无法解析LLM响应为JSON (language={language}): {full_response}")
-            return (PARSE_ERROR_TITLE, DEFAULT_TYPE)
+            logger.error(f"无法解析LLM响应为JSON: {full_response}")
+            return ("解析失败", DEFAULT_TYPE)
         
     except Exception as e:
-        logger.error(f"生成标题和类型时出错 (language={language}): {str(e)}", exc_info=True)
-        return (ERROR_TITLE, DEFAULT_TYPE)
+        logger.error(f"生成标题和类型时出错: {str(e)}", exc_info=True)
+        return ("错误", DEFAULT_TYPE)
 
 async def _process_chunk_summary(
     dialog: DialogData,
     chunk,
     llm_client,
     embedder: OpenAIEmbedderClient,
-    language: str = "zh",
 ) -> Optional[MemorySummaryNode]:
     """Process a single chunk to generate a memory summary node."""
     # Skip empty chunks
@@ -166,15 +153,11 @@ async def _process_chunk_summary(
         return None
 
     try:
-        # 验证语言参数
-        language = validate_language(language)
-        
         # Render prompt via Jinja2 for a single chunk
         prompt_content = await render_memory_summary_prompt(
             chunk_texts=chunk.content,
             json_schema=MemorySummaryResponse.model_json_schema(),
             max_words=200,
-            language=language,
         )
 
         messages = [
@@ -195,10 +178,9 @@ async def _process_chunk_summary(
         try:
             title, episodic_type = await generate_title_and_type_for_summary(
                 content=summary_text,
-                llm_client=llm_client,
-                language=language
+                llm_client=llm_client
             )
-            logger.info(f"Generated title and type for MemorySummary (language={language}): title={title}, type={episodic_type}")
+            logger.info(f"Generated title and type for MemorySummary: title={title}, type={episodic_type}")
         except Exception as e:
             logger.warning(f"Failed to generate title and type for chunk {chunk.id}: {e}")
             # Continue without title and type
@@ -237,21 +219,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

@@ -1,489 +0,0 @@
-"""Ontology class extraction from scenario descriptions using LLM.
-
-This module provides the OntologyExtractor class for extracting ontology classes
-from natural language scenario descriptions. It uses LLM-driven extraction combined
-with two-layer validation (string validation + OWL semantic validation).
-
-Classes:
-    OntologyExtractor: Extracts ontology classes from scenario descriptions
-"""
-
-import asyncio
-import logging
-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 (
-    OntologyClass,
-    OntologyExtractionResponse,
-)
-from app.core.memory.utils.validation.ontology_validator import OntologyValidator
-from app.core.memory.utils.validation.owl_validator import OWLValidator
-from app.core.memory.utils.prompt.prompt_utils import render_ontology_extraction_prompt
-
-
-logger = logging.getLogger(__name__)
-
-
-class OntologyExtractor:
-    """Extractor for ontology classes from scenario descriptions.
-    
-    This extractor uses LLM to identify abstract classes and concepts from
-    natural language scenario descriptions, following OWL ontology engineering
-    standards. It performs two-layer validation:
-    1. String validation (naming conventions, reserved words, duplicates)
-    2. OWL semantic validation (consistency checking, circular inheritance)
-    
-    Attributes:
-        llm_client: OpenAI client for LLM calls
-        validator: String validator for class names and descriptions
-        owl_validator: OWL validator for semantic validation
-    """
-    
-    def __init__(self, llm_client: OpenAIClient):
-        """Initialize the OntologyExtractor.
-        
-        Args:
-            llm_client: OpenAIClient instance for LLM processing
-        """
-        self.llm_client = llm_client
-        self.validator = OntologyValidator()
-        self.owl_validator = OWLValidator()
-        
-        logger.info("OntologyExtractor initialized")
-    
-    async def extract_ontology_classes(
-        self,
-        scenario: str,
-        domain: Optional[str] = None,
-        max_classes: int = 15,
-        min_classes: int = 5,
-        enable_owl_validation: bool = True,
-        llm_temperature: float = 0.3,
-        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.
-        
-        This is the main extraction method that orchestrates the entire process:
-        1. Call LLM to extract ontology classes
-        2. Perform first-layer validation (string validation and cleaning)
-        3. Perform second-layer validation (OWL semantic validation)
-        4. Filter invalid classes based on validation errors
-        5. Return validated ontology classes
-        
-        Args:
-            scenario: Natural language scenario description
-            domain: Optional domain hint (e.g., "Healthcare", "Education")
-            max_classes: Maximum number of classes to extract (default: 15)
-            min_classes: Minimum number of classes to extract (default: 5)
-            enable_owl_validation: Whether to enable OWL validation (default: True)
-            llm_temperature: LLM temperature parameter (default: 0.3)
-            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
-            
-        Raises:
-            ValueError: If scenario is empty or invalid
-            asyncio.TimeoutError: If extraction times out
-            
-        Examples:
-            >>> extractor = OntologyExtractor(llm_client)
-            >>> response = await extractor.extract_ontology_classes(
-            ...     scenario="A hospital manages patient records...",
-            ...     domain="Healthcare",
-            ...     max_classes=10,
-            ...     timeout=30.0
-            ... )
-            >>> len(response.classes)
-            7
-        """
-        # Start timing
-        start_time = time.time()
-        
-        # Validate input
-        if not scenario or not scenario.strip():
-            logger.error("Scenario description is empty")
-            raise ValueError("Scenario description cannot be empty")
-        
-        scenario = scenario.strip()
-        
-        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}"
-        )
-        
-        try:
-            # Step 1: Call LLM for extraction with timeout
-            logger.info("Step 1: Calling LLM for ontology extraction")
-            llm_start_time = time.time()
-            
-            if timeout is not None:
-                # Wrap LLM call with timeout
-                try:
-                    response = await asyncio.wait_for(
-                        self._call_llm_for_extraction(
-                            scenario=scenario,
-                            domain=domain,
-                            max_classes=max_classes,
-                            llm_temperature=llm_temperature,
-                            llm_max_tokens=llm_max_tokens,
-                            language=language,
-                        ),
-                        timeout=timeout
-                    )
-                except asyncio.TimeoutError:
-                    llm_duration = time.time() - llm_start_time
-                    logger.error(
-                        f"LLM extraction timed out after {timeout} seconds "
-                        f"(actual duration: {llm_duration:.2f}s)"
-                    )
-                    # Return empty response on timeout
-                    return OntologyExtractionResponse(
-                        classes=[],
-                        domain=domain or "Unknown",
-                    )
-            else:
-                # No timeout specified, call directly
-                response = await self._call_llm_for_extraction(
-                    scenario=scenario,
-                    domain=domain,
-                    max_classes=max_classes,
-                    llm_temperature=llm_temperature,
-                    llm_max_tokens=llm_max_tokens,
-                    language=language,
-                )
-            
-            llm_duration = time.time() - llm_start_time
-            logger.info(
-                f"LLM returned {len(response.classes)} classes in {llm_duration:.2f}s"
-            )
-            
-            # Step 2: First-layer validation (string validation and cleaning)
-            logger.info("Step 2: Performing first-layer validation (string validation)")
-            validation_start_time = time.time()
-            
-            response = self._validate_and_clean(
-                response=response,
-                max_description_length=max_description_length,
-            )
-            
-            validation_duration = time.time() - validation_start_time
-            logger.info(
-                f"After first-layer validation: {len(response.classes)} classes remain "
-                f"(validation took {validation_duration:.2f}s)"
-            )
-            
-            # Check if we have enough classes after first-layer validation
-            if len(response.classes) < min_classes:
-                logger.warning(
-                    f"Only {len(response.classes)} classes remain after validation, "
-                    f"which is below minimum of {min_classes}"
-                )
-            
-            # Step 3: Second-layer validation (OWL semantic validation)
-            if enable_owl_validation and response.classes:
-                logger.info("Step 3: Performing second-layer validation (OWL validation)")
-                owl_start_time = time.time()
-                
-                is_valid, errors, world = self.owl_validator.validate_ontology_classes(
-                    classes=response.classes,
-                )
-                
-                owl_duration = time.time() - owl_start_time
-                
-                if not is_valid:
-                    logger.warning(
-                        f"OWL validation found {len(errors)} issues in {owl_duration:.2f}s: {errors}"
-                    )
-                    
-                    # Filter invalid classes based on errors
-                    response = self._filter_invalid_classes(
-                        response=response,
-                        errors=errors,
-                    )
-                    
-                    logger.info(
-                        f"After second-layer validation: {len(response.classes)} classes remain"
-                    )
-                else:
-                    logger.info(f"OWL validation passed successfully in {owl_duration:.2f}s")
-            else:
-                if not enable_owl_validation:
-                    logger.info("Step 3: OWL validation disabled, skipping")
-                else:
-                    logger.info("Step 3: No classes to validate, skipping OWL validation")
-            
-            # Calculate total duration
-            total_duration = time.time() - start_time
-            
-            # Log extraction statistics
-            logger.info(
-                f"Ontology extraction completed - "
-                f"final_class_count={len(response.classes)}, "
-                f"domain={response.domain}, "
-                f"total_duration={total_duration:.2f}s, "
-                f"llm_duration={llm_duration:.2f}s"
-            )
-            
-            return response
-            
-        except asyncio.TimeoutError:
-            # Re-raise timeout errors
-            total_duration = time.time() - start_time
-            logger.error(
-                f"Ontology extraction timed out after {timeout} seconds "
-                f"(total duration: {total_duration:.2f}s)",
-                exc_info=True
-            )
-            raise
-        except Exception as e:
-            total_duration = time.time() - start_time
-            logger.error(
-                f"Ontology extraction failed after {total_duration:.2f}s: {str(e)}",
-                exc_info=True
-            )
-            # Return empty response on failure
-            return OntologyExtractionResponse(
-                classes=[],
-                domain=domain or "Unknown",
-            )
-    
-    async def _call_llm_for_extraction(
-        self,
-        scenario: str,
-        domain: Optional[str],
-        max_classes: int,
-        llm_temperature: float,
-        llm_max_tokens: int,
-        language: str = "zh",
-    ) -> OntologyExtractionResponse:
-        """Call LLM to extract ontology classes from scenario.
-        
-        This method renders the extraction prompt using the Jinja2 template
-        and calls the LLM with structured output to get ontology classes.
-        
-        Args:
-            scenario: Scenario description text
-            domain: Optional domain hint
-            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
-            
-        Raises:
-            Exception: If LLM call fails
-        """
-        try:
-            # Render prompt using template
-            prompt_content = await render_ontology_extraction_prompt(
-                scenario=scenario,
-                domain=domain,
-                max_classes=max_classes,
-                json_schema=OntologyExtractionResponse.model_json_schema(),
-                language=language,
-            )
-            
-            logger.debug(f"Rendered prompt length: {len(prompt_content)}")
-            
-            # Create messages for LLM
-            messages = [
-                {
-                    "role": "system",
-                    "content": (
-                        "You are an expert ontology engineer specializing in knowledge "
-                        "representation and OWL standards. Extract ontology classes from "
-                        "scenario descriptions following the provided instructions. "
-                        "Return valid JSON conforming to the schema."
-                    ),
-                },
-                {
-                    "role": "user",
-                    "content": prompt_content,
-                },
-            ]
-            
-            # Call LLM with structured output
-            logger.debug(
-                f"Calling LLM with temperature={llm_temperature}, "
-                f"max_tokens={llm_max_tokens}"
-            )
-            
-            response = await self.llm_client.response_structured(
-                messages=messages,
-                response_model=OntologyExtractionResponse,
-            )
-            
-            logger.info(
-                f"LLM extraction successful - extracted {len(response.classes)} classes"
-            )
-            
-            return response
-            
-        except Exception as e:
-            logger.error(
-                f"LLM extraction failed: {str(e)}",
-                exc_info=True
-            )
-            raise
-    
-    def _validate_and_clean(
-        self,
-        response: OntologyExtractionResponse,
-        max_description_length: int,
-    ) -> OntologyExtractionResponse:
-        """Perform first-layer validation: string validation and cleaning.
-        
-        This method validates and cleans the extracted ontology classes:
-        1. Validate class names (PascalCase, no reserved words)
-        2. Sanitize invalid class names
-        3. Truncate long descriptions
-        4. Remove duplicate classes
-        
-        Args:
-            response: OntologyExtractionResponse from LLM
-            max_description_length: Maximum description length
-            
-        Returns:
-            Cleaned OntologyExtractionResponse
-        """
-        if not response.classes:
-            logger.debug("No classes to validate")
-            return response
-        
-        logger.debug(f"Validating {len(response.classes)} classes")
-        
-        validated_classes = []
-        
-        for ontology_class in response.classes:
-            # Validate class name
-            is_valid, error_msg = self.validator.validate_class_name(
-                ontology_class.name
-            )
-            
-            if not is_valid:
-                logger.warning(
-                    f"Invalid class name '{ontology_class.name}': {error_msg}"
-                )
-                
-                # Attempt to sanitize
-                sanitized_name = self.validator.sanitize_class_name(
-                    ontology_class.name
-                )
-                
-                logger.info(
-                    f"Sanitized class name: '{ontology_class.name}' -> '{sanitized_name}'"
-                )
-                
-                # Update class name
-                ontology_class.name = sanitized_name
-                
-                # Re-validate sanitized name
-                is_valid, error_msg = self.validator.validate_class_name(
-                    sanitized_name
-                )
-                
-                if not is_valid:
-                    logger.error(
-                        f"Failed to sanitize class name '{ontology_class.name}': {error_msg}. "
-                        "Skipping this class."
-                    )
-                    continue
-            
-            # Truncate description if too long
-            if ontology_class.description:
-                original_length = len(ontology_class.description)
-                ontology_class.description = self.validator.truncate_description(
-                    ontology_class.description,
-                    max_length=max_description_length,
-                )
-                
-                if len(ontology_class.description) < original_length:
-                    logger.debug(
-                        f"Truncated description for '{ontology_class.name}': "
-                        f"{original_length} -> {len(ontology_class.description)} chars"
-                    )
-            
-            validated_classes.append(ontology_class)
-        
-        # Remove duplicates (case-insensitive)
-        original_count = len(validated_classes)
-        validated_classes = self.validator.remove_duplicates(validated_classes)
-        
-        if len(validated_classes) < original_count:
-            logger.info(
-                f"Removed {original_count - len(validated_classes)} duplicate classes"
-            )
-        
-        # Return cleaned response
-        return OntologyExtractionResponse(
-            classes=validated_classes,
-            domain=response.domain,
-        )
-    
-    def _filter_invalid_classes(
-        self,
-        response: OntologyExtractionResponse,
-        errors: List[str],
-    ) -> OntologyExtractionResponse:
-        """Filter invalid classes based on OWL validation errors.
-        
-        This method analyzes OWL validation errors and removes classes
-        that caused validation failures (e.g., circular inheritance,
-        inconsistencies).
-        
-        Args:
-            response: OntologyExtractionResponse to filter
-            errors: List of error messages from OWL validation
-            
-        Returns:
-            Filtered OntologyExtractionResponse
-        """
-        if not errors:
-            return response
-        
-        logger.debug(f"Filtering classes based on {len(errors)} OWL validation errors")
-        
-        # Extract class names mentioned in errors
-        invalid_class_names = set()
-        
-        for error in errors:
-            # Look for class names in error messages
-            for ontology_class in response.classes:
-                if ontology_class.name in error:
-                    invalid_class_names.add(ontology_class.name)
-                    logger.debug(
-                        f"Class '{ontology_class.name}' marked as invalid due to error: {error}"
-                    )
-        
-        # Filter out invalid classes
-        if invalid_class_names:
-            original_count = len(response.classes)
-            
-            filtered_classes = [
-                c for c in response.classes
-                if c.name not in invalid_class_names
-            ]
-            
-            logger.info(
-                f"Filtered out {original_count - len(filtered_classes)} invalid classes: "
-                f"{invalid_class_names}"
-            )
-            
-            return OntologyExtractionResponse(
-                classes=filtered_classes,
-                domain=response.domain,
-            )
-        
-        return response

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,30 +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
-        
-        Returns:
-            Language code ("zh" or "en")
-        """
-        return self.language
 
     async def _extract_triplets(self, statement: Statement, chunk_content: str) -> TripletExtractionResponse:
         """Process a single statement and return extracted triplets and entities"""
@@ -58,9 +40,7 @@ class TripletExtractor:
             statement=statement.statement,
             chunk_content=chunk_content,
             json_schema=TripletExtractionResponse.model_json_schema(),
-            predicate_instructions=PREDICATE_DEFINITIONS,
-            language=self._get_language(),
-            ontology_types=self.ontology_types,
+            predicate_instructions=PREDICATE_DEFINITIONS
         )
 
         # 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/alias_utils.py

@@ -296,9 +296,7 @@ def resolve_alias_cycles(entities: List[Any], cycles: Dict[str, Set[str]]) -> Li
             key=lambda eid: (
                 _strength_rank(eid),
                 len(getattr(entity_by_id.get(eid), 'description', '') or ''),
-                # TODO: fact_summary 功能暂时禁用，待后续开发完善后启用
-                # len(getattr(entity_by_id.get(eid), 'fact_summary', '') or '')
-                0  # 临时占位
+                len(getattr(entity_by_id.get(eid), 'fact_summary', '') or '')
             ),
             reverse=True
         )

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"]