Merge branch 'develop' into release/v0.2.7

feat(web): app api support shared_only key

.gitignore

@@ -29,6 +29,7 @@ search_results.json
 api/migrations/versions
 tmp
 files
+powers/ 
 
 # Exclude dep files
 huggingface.co/

README.md

@@ -226,8 +226,8 @@ REDIS_PORT=6379
 REDIS_DB=1 
 
 # Celery (Using Redis as broker)
-BROKER_URL=redis://127.0.0.1:6379/0
-RESULT_BACKEND=redis://127.0.0.1:6379/0
+REDIS_DB_CELERY_BROKER=1
+REDIS_DB_CELERY_BACKEND=2
 
 # 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)
-BROKER_URL=redis://127.0.0.1:6379/0
-RESULT_BACKEND=redis://127.0.0.1:6379/0
+REDIS_DB_CELERY_BROKER=1
+REDIS_DB_CELERY_BACKEND=2
 
 # JWT密钥 (生成方式: openssl rand -hex 32)
 SECRET_KEY=your-secret-key-here

api/Dockerfile

@@ -45,7 +45,8 @@ 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 ghostscript && \
+    apt install -y libmagic1
 
 RUN if [ "$NEED_MIRROR" == "1" ]; then \
         pip3 config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple && \

api/alembic.ini

@@ -60,7 +60,12 @@ version_path_separator = os  # Use os.pathsep. Default configuration used for ne
 # are written from script.py.mako
 # output_encoding = utf-8
 
-sqlalchemy.url = postgresql://user:password@localhost/dbname
+# Database connection URL - DO NOT hardcode credentials here!
+# Connection string is set dynamically from environment variables in migrations/env.py
+# Required env vars: DB_USER, DB_PASSWORD, DB_HOST, DB_PORT, DB_NAME
+# Example: postgresql://user:password@localhost:5432/dbname
+; sqlalchemy.url = postgresql://user:password@host:port/dbname
+sqlalchemy.url = driver://user:password@host:port/dbname
 
 
 [post_write_hooks]

api/app/aioRedis.py

@@ -1,16 +1,16 @@
-import os
 import asyncio
 import json
 import logging
 from typing import Dict, Any, Optional
+
 import redis.asyncio as redis
 from redis.asyncio import ConnectionPool
+
 from app.core.config import settings
 
 # 设置日志记录器
 logger = logging.getLogger(__name__)
 
-
 # 创建连接池
 pool = ConnectionPool.from_url(
     f"redis://{settings.REDIS_HOST}:{settings.REDIS_PORT}",
@@ -21,6 +21,7 @@ pool = ConnectionPool.from_url(
 )
 aio_redis = redis.StrictRedis(connection_pool=pool)
 
+
 async def get_redis_connection():
     """获取Redis连接"""
     try:
@@ -29,7 +30,8 @@ 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:
@@ -40,7 +42,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)
@@ -50,6 +52,7 @@ 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:
@@ -58,6 +61,7 @@ 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:
@@ -66,6 +70,7 @@ 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:
@@ -78,9 +83,10 @@ 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
@@ -88,25 +94,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)
@@ -127,7 +133,7 @@ class RedisSubscriber:
         finally:
             await self._queue.put(None)
             await self._cleanup()
-    
+
     async def _cleanup(self):
         """清理资源"""
         if self.pubsub:
@@ -141,7 +147,7 @@ class RedisSubscriber:
                 await self.conn.close()
             except Exception:
                 pass
-    
+
     async def get_message(self) -> Optional[Dict[str, Any]]:
         """获取消息"""
         if self.is_closed:
@@ -153,7 +159,7 @@ class RedisSubscriber:
         except Exception as e:
             logger.error(f"获取消息错误: {str(e)}")
             return None
-    
+
     async def close(self):
         """关闭订阅器"""
         if self.is_closed:
@@ -163,32 +169,33 @@ 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():
@@ -196,6 +203,6 @@ class RedisPubSubManager:
         self.subscribers.clear()
         return count
 
+
 # 全局实例
 pubsub_manager = RedisPubSubManager()
-

api/app/cache/__init__.py

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

api/app/cache/memory/__init__.py

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

api/app/cache/memory/activity_stats_cache.py

@@ -0,0 +1,124 @@
+"""
+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/interest_memory.py

@@ -0,0 +1,122 @@
+"""
+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

@@ -7,20 +7,48 @@ 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')
 
 # 创建 Celery 应用实例
-# broker: 任务队列（使用 Redis DB 0）
-# backend: 结果存储（使用 Redis DB 10）
+# 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)
+
 celery_app = Celery(
     "redbear_tasks",
-    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}",
+    broker=_broker_url,
+    backend=_backend_url,
 )
 
+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'
 
@@ -35,56 +63,60 @@ celery_app.conf.update(
     accept_content=['json'],
     result_serializer='json',
     
-    # 时区
-    timezone='Asia/Shanghai',
-    enable_utc=True,
+    # # 时区
+    # timezone='Asia/Shanghai',
+    # enable_utc=False,
     
     # 任务追踪
     task_track_started=True,
     task_ignore_result=False,
-    
+
     # 超时设置
-    task_time_limit=1800,  # 30分钟硬超时
-    task_soft_time_limit=1500,  # 25分钟软超时
-    
+    task_time_limit=3600,  # 60分钟硬超时
+    task_soft_time_limit=3000,  # 50分钟软超时
+
     # Worker 设置 (per-worker settings are in docker-compose command line)
     worker_prefetch_multiplier=1,  # Don't hoard tasks, fairer distribution
-    
+
     # 结果过期时间
     result_expires=3600,  # 结果保存1小时
-    
+
     # 任务确认设置
     task_acks_late=True,
     task_reject_on_worker_lost=True,
     worker_disable_rate_limits=True,
-    
+
     # FLower setting 
     worker_send_task_events=True,
     task_send_sent_event=True,
-    
+
     # task routing
     task_routes={
         # Memory tasks → memory_tasks queue (threads worker)
         'app.core.memory.agent.read_message_priority': {'queue': 'memory_tasks'},
         'app.core.memory.agent.read_message': {'queue': 'memory_tasks'},
         'app.core.memory.agent.write_message': {'queue': 'memory_tasks'},
-        
+        'app.tasks.write_perceptual_memory': {'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'},
+        'app.tasks.init_community_clustering_for_users': {'queue': 'periodic_tasks'},
     },
 )
 
@@ -92,7 +124,7 @@ celery_app.conf.update(
 celery_app.autodiscover_tasks(['app'])
 
 # Celery Beat schedule for periodic tasks
-memory_increment_schedule = timedelta(hours=settings.MEMORY_INCREMENT_INTERVAL_HOURS)
+memory_increment_schedule = crontab(hour=settings.MEMORY_INCREMENT_HOUR, minute=settings.MEMORY_INCREMENT_MINUTE)
 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)
@@ -101,7 +133,7 @@ implicit_emotions_update_schedule = crontab(
     minute=settings.IMPLICIT_EMOTIONS_UPDATE_MINUTE,
 )
 
-#构建定时任务配置
+# 构建定时任务配置
 beat_schedule_config = {
     "run-workspace-reflection": {
         "task": "app.tasks.workspace_reflection_task",

api/app/celery_worker.py

@@ -13,4 +13,4 @@ logger.info("Celery worker logging initialized")
 # 导入任务模块以注册任务
 import app.tasks
 
-__all__ = ['celery_app']
+__all__ = ['celery_app']

api/app/config/__init__.py

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

api/app/config/default_ontology_config.py

@@ -0,0 +1,239 @@
+"""默认本体场景配置
+
+本模块定义系统预设的本体场景和实体类型配置。
+这些配置用于在工作空间创建时自动初始化默认场景。
+支持中英文双语配置，根据用户语言偏好创建对应语言的场景。
+"""
+
+# 在线教育场景配置
+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

@@ -0,0 +1,249 @@
+# -*- 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

@@ -16,6 +16,7 @@ from . import (
     file_controller,
     file_storage_controller,
     home_page_controller,
+    i18n_controller,
     implicit_memory_controller,
     knowledge_controller,
     knowledgeshare_controller,
@@ -94,5 +95,6 @@ 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)
+manager_router.include_router(i18n_controller.router)
 
 __all__ = ["manager_router"]

api/app/controllers/app_controller.py

@@ -1,9 +1,12 @@
 import uuid
+import io
 from typing import Optional, Annotated
 
-from fastapi import APIRouter, Depends, Path
+import yaml
+from fastapi import APIRouter, Depends, Path, Form, UploadFile, File
 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
@@ -17,12 +20,14 @@ 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
+from app.schemas.workflow_schema import WorkflowConfigUpdate, WorkflowImportSave
 from app.services import app_service, workspace_service
 from app.services.agent_config_helper import enrich_agent_config
 from app.services.app_service import AppService
-from app.services.workflow_service import WorkflowService, get_workflow_service
 from app.services.app_statistics_service import AppStatisticsService
+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()
@@ -48,6 +53,7 @@ def list_apps(
         status: str | None = None,
         search: str | None = None,
         include_shared: bool = True,
+        shared_only: bool = False,
         page: int = 1,
         pagesize: int = 10,
         ids: Optional[str] = None,
@@ -65,7 +71,7 @@ def list_apps(
 
     # 当 ids 存在且不为 None 时，根据 ids 获取应用
     if ids is not None:
-        app_ids = [id.strip() for id in ids.split(',') if id.strip()]
+        app_ids = [app_id.strip() for app_id in ids.split(',') if app_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)
@@ -79,6 +85,7 @@ def list_apps(
         status=status,
         search=search,
         include_shared=include_shared,
+        shared_only=shared_only,
         page=page,
         pagesize=pagesize,
     )
@@ -88,6 +95,37 @@ def list_apps(
     return success(data=PageData(page=meta, items=items))
 
 
+@router.get("/my-shared-out", summary="列出本工作空间主动分享出去的记录")
+@cur_workspace_access_guard()
+def list_my_shared_out(
+        db: Session = Depends(get_db),
+        current_user=Depends(get_current_user),
+):
+    """列出本工作空间主动分享给其他工作空间的所有记录（我的共享）"""
+    workspace_id = current_user.current_workspace_id
+    service = app_service.AppService(db)
+    shares = service.list_my_shared_out(workspace_id=workspace_id)
+    data = [app_schema.AppShare.model_validate(s) for s in shares]
+    return success(data=data)
+
+
+@router.delete("/share/{target_workspace_id}", summary="取消对某工作空间的所有应用分享")
+@cur_workspace_access_guard()
+def unshare_all_apps_to_workspace(
+        target_workspace_id: uuid.UUID,
+        db: Session = Depends(get_db),
+        current_user=Depends(get_current_user),
+):
+    """Cancel all app shares from current workspace to a target workspace."""
+    workspace_id = current_user.current_workspace_id
+    service = app_service.AppService(db)
+    count = service.unshare_all_apps_to_workspace(
+        target_workspace_id=target_workspace_id,
+        workspace_id=workspace_id
+    )
+    return success(msg=f"已取消 {count} 个应用的分享", data={"count": count})
+
+
 @router.get("/{app_id}", summary="获取应用详情")
 @cur_workspace_access_guard()
 def get_app(
@@ -297,7 +335,8 @@ def share_app(
         app_id=app_id,
         target_workspace_ids=payload.target_workspace_ids,
         user_id=current_user.id,
-        workspace_id=workspace_id
+        workspace_id=workspace_id,
+        permission=payload.permission
     )
 
     data = [app_schema.AppShare.model_validate(s) for s in shares]
@@ -328,6 +367,32 @@ def unshare_app(
     return success(msg="应用分享已取消")
 
 
+@router.patch("/{app_id}/share/{target_workspace_id}", summary="更新共享权限")
+@cur_workspace_access_guard()
+def update_share_permission(
+        app_id: uuid.UUID,
+        target_workspace_id: uuid.UUID,
+        payload: app_schema.UpdateSharePermissionRequest,
+        db: Session = Depends(get_db),
+        current_user=Depends(get_current_user),
+):
+    """更新共享权限（readonly <-> editable）
+
+    - 只能修改自己工作空间应用的共享权限
+    """
+    workspace_id = current_user.current_workspace_id
+
+    service = app_service.AppService(db)
+    share = service.update_share_permission(
+        app_id=app_id,
+        target_workspace_id=target_workspace_id,
+        permission=payload.permission,
+        workspace_id=workspace_id
+    )
+
+    return success(data=app_schema.AppShare.model_validate(share))
+
+
 @router.get("/{app_id}/shares", summary="列出应用的分享记录")
 @cur_workspace_access_guard()
 def list_app_shares(
@@ -351,6 +416,46 @@ def list_app_shares(
     return success(data=data)
 
 
+@router.delete("/shared/{source_workspace_id}", summary="批量移除某来源工作空间的所有共享应用")
+@cur_workspace_access_guard()
+def remove_all_shared_apps_from_workspace(
+        source_workspace_id: uuid.UUID,
+        db: Session = Depends(get_db),
+        current_user=Depends(get_current_user),
+):
+    """Remove all shared apps from a specific source workspace (recipient operation)."""
+    workspace_id = current_user.current_workspace_id
+    service = app_service.AppService(db)
+    count = service.remove_all_shared_apps_from_workspace(
+        source_workspace_id=source_workspace_id,
+        workspace_id=workspace_id
+    )
+    return success(msg=f"已移除 {count} 个共享应用", data={"count": count})
+
+
+@router.delete("/{app_id}/shared", summary="移除共享给我的应用")
+@cur_workspace_access_guard()
+def remove_shared_app(
+        app_id: uuid.UUID,
+        db: Session = Depends(get_db),
+        current_user=Depends(get_current_user),
+):
+    """被共享者从自己的工作空间移除共享应用
+
+    - 不会删除源应用，只删除共享记录
+    - 只能移除共享给自己工作空间的应用
+    """
+    workspace_id = current_user.current_workspace_id
+
+    service = app_service.AppService(db)
+    service.remove_shared_app(
+        app_id=app_id,
+        workspace_id=workspace_id
+    )
+
+    return success(msg="已移除共享应用")
+
+
 @router.post("/{app_id}/draft/run", summary="试运行 Agent（使用当前草稿配置）")
 @cur_workspace_access_guard()
 async def draft_run(
@@ -394,10 +499,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 DraftRunService
+    from app.services.draft_run_service import AgentRunService
 
     service = AppService(db)
-    draft_service = DraftRunService(db)
+    draft_service = AgentRunService(db)
 
     # 1. 验证应用
     app = service._get_app_or_404(app_id)
@@ -482,8 +587,8 @@ async def draft_run(
             }
         )
 
-        from app.services.draft_run_service import DraftRunService
-        draft_service = DraftRunService(db)
+        from app.services.draft_run_service import AgentRunService
+        draft_service = AgentRunService(db)
         result = await draft_service.run(
             agent_config=agent_cfg,
             model_config=model_config,
@@ -739,6 +844,15 @@ async def draft_run_compare(
         raise BusinessException("只有 Agent 类型应用支持试运行", BizCode.APP_TYPE_NOT_SUPPORTED)
     service._validate_app_accessible(app, workspace_id)
 
+    if payload.user_id is None:
+        end_user_repo = EndUserRepository(db)
+        new_end_user = end_user_repo.get_or_create_end_user(
+            app_id=app_id,
+            other_id=str(current_user.id),
+            original_user_id=str(current_user.id)  # Save original user_id to other_id
+        )
+        payload.user_id = str(new_end_user.id)
+
     # 2. 获取 Agent 配置
     from sqlalchemy import select
     from app.models import AgentConfig
@@ -784,18 +898,20 @@ async def draft_run_compare(
             "conversation_id": model_item.conversation_id  # 传递每个模型的 conversation_id
         })
 
+
+
     # 流式返回
     if payload.stream:
         async def event_generator():
-            from app.services.draft_run_service import DraftRunService
-            draft_service = DraftRunService(db)
+            from app.services.draft_run_service import AgentRunService
+            draft_service = AgentRunService(db)
             async for event in draft_service.run_compare_stream(
                     agent_config=agent_cfg,
                     models=model_configs,
                     message=payload.message,
                     workspace_id=workspace_id,
                     conversation_id=payload.conversation_id,
-                    user_id=payload.user_id or str(current_user.id),
+                    user_id=payload.user_id,
                     variables=payload.variables,
                     storage_type=storage_type,
                     user_rag_memory_id=user_rag_memory_id,
@@ -818,22 +934,23 @@ async def draft_run_compare(
         )
 
     # 非流式返回
-    from app.services.draft_run_service import DraftRunService
-    draft_service = DraftRunService(db)
+    from app.services.draft_run_service import AgentRunService
+    draft_service = AgentRunService(db)
     result = await draft_service.run_compare(
         agent_config=agent_cfg,
         models=model_configs,
         message=payload.message,
         workspace_id=workspace_id,
         conversation_id=payload.conversation_id,
-        user_id=payload.user_id or str(current_user.id),
+        user_id=payload.user_id,
         variables=payload.variables,
         storage_type=storage_type,
         user_rag_memory_id=user_rag_memory_id,
         web_search=True,
         memory=True,
         parallel=payload.parallel,
-        timeout=payload.timeout or 60
+        timeout=payload.timeout or 60,
+        files=payload.files
     )
 
     logger.info(
@@ -879,6 +996,60 @@ async def update_workflow_config(
     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(
@@ -889,12 +1060,14 @@ def get_app_statistics(
         current_user=Depends(get_current_user),
 ):
     """获取应用统计数据
-    
+
     Args:
         app_id: 应用ID
         start_date: 开始时间戳（毫秒）
         end_date: 结束时间戳（毫秒）
-    
+        db: 数据库连接
+        current_user: 当前用户
+
     Returns:
         - daily_conversations: 每日会话数统计
         - total_conversations: 总会话数
@@ -931,6 +1104,8 @@ def get_workspace_api_statistics(
     Args:
         start_date: 开始时间戳（毫秒）
         end_date: 结束时间戳（毫秒）
+        db: 数据库连接
+        current_user: 当前用户
     
     Returns:
         每日统计数据列表，每项包含：
@@ -949,3 +1124,57 @@ def get_workspace_api_statistics(
     )
 
     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

@@ -1,4 +1,5 @@
 from datetime import datetime, timedelta, timezone
+from typing import Callable
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 
@@ -16,6 +17,7 @@ from app.core.exceptions import BusinessException
 from app.core.error_codes import BizCode
 from app.dependencies import get_current_user, oauth2_scheme
 from app.models.user_model import User
+from app.i18n.dependencies import get_translator
 
 # 获取专用日志器
 auth_logger = get_auth_logger()
@@ -26,7 +28,8 @@ router = APIRouter(tags=["Authentication"])
 @router.post("/token", response_model=ApiResponse)
 async def login_for_access_token(
     form_data: TokenRequest,
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
+    t: Callable = Depends(get_translator)
 ):
     """用户登录获取token"""
     auth_logger.info(f"用户登录请求: {form_data.email}")
@@ -40,10 +43,10 @@ async def login_for_access_token(
         invite_info = workspace_service.validate_invite_token(db, form_data.invite)
         
         if not invite_info.is_valid:
-            raise BusinessException("邀请码无效或已过期", code=BizCode.BAD_REQUEST)
+            raise BusinessException(t("auth.invite.invalid"), code=BizCode.BAD_REQUEST)
         
         if invite_info.email != form_data.email:
-            raise BusinessException("邀请邮箱与登录邮箱不匹配", code=BizCode.BAD_REQUEST)        
+            raise BusinessException(t("auth.invite.email_mismatch"), code=BizCode.BAD_REQUEST)        
         auth_logger.info(f"邀请码验证成功: workspace={invite_info.workspace_name}")
         try:
             # 尝试认证用户
@@ -69,7 +72,7 @@ async def login_for_access_token(
             elif e.code == BizCode.PASSWORD_ERROR:
                 # 用户存在但密码错误
                 auth_logger.warning(f"接受邀请失败，密码验证错误: {form_data.email}")
-                raise BusinessException("接受邀请失败，密码验证错误", BizCode.LOGIN_FAILED)
+                raise BusinessException(t("auth.invite.password_verification_failed"), BizCode.LOGIN_FAILED)
             else:
                 # 其他认证失败情况，直接抛出
                 raise
@@ -82,7 +85,7 @@ async def login_for_access_token(
         except BusinessException as e:
             
             # 其他认证失败情况，直接抛出
-            raise BusinessException(e.message,BizCode.LOGIN_FAILED)
+            raise BusinessException(e.message, BizCode.LOGIN_FAILED)
 
     # 创建 tokens
     access_token, access_token_id = security.create_access_token(subject=user.id)
@@ -110,14 +113,15 @@ async def login_for_access_token(
             expires_at=access_expires_at,
             refresh_expires_at=refresh_expires_at
         ),
-        msg="登录成功"
+        msg=t("auth.login.success")
     )
 
 
 @router.post("/refresh", response_model=ApiResponse)
 async def refresh_token(
     refresh_request: RefreshTokenRequest,
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
+    t: Callable = Depends(get_translator)
 ):
     """刷新token"""
     auth_logger.info("收到token刷新请求")
@@ -125,18 +129,18 @@ async def refresh_token(
     # 验证 refresh token
     userId = security.verify_token(refresh_request.refresh_token, "refresh")
     if not userId:
-        raise BusinessException("无效的refresh token", code=BizCode.TOKEN_INVALID)
+        raise BusinessException(t("auth.token.invalid_refresh_token"), code=BizCode.TOKEN_INVALID)
     
     # 检查用户是否存在
     user = auth_service.get_user_by_id(db, userId)
     if not user:
-        raise BusinessException("用户不存在", code=BizCode.USER_NOT_FOUND)
+        raise BusinessException(t("auth.user.not_found"), code=BizCode.USER_NOT_FOUND)
     
     # 检查 refresh token 黑名单
     if settings.ENABLE_SINGLE_SESSION:
         refresh_token_id = security.get_token_id(refresh_request.refresh_token)
         if refresh_token_id and await SessionService.is_token_blacklisted(refresh_token_id):
-            raise BusinessException("Refresh token已失效", code=BizCode.TOKEN_BLACKLISTED)
+            raise BusinessException(t("auth.token.refresh_token_blacklisted"), code=BizCode.TOKEN_BLACKLISTED)
     
     # 生成新 tokens
     new_access_token, new_access_token_id = security.create_access_token(subject=user.id)
@@ -167,7 +171,7 @@ async def refresh_token(
             expires_at=access_expires_at,
             refresh_expires_at=refresh_expires_at
         ),
-        msg="token刷新成功"
+        msg=t("auth.token.refresh_success")
     )
 
 
@@ -175,14 +179,15 @@ async def refresh_token(
 async def logout(
     token: str = Depends(oauth2_scheme),
     current_user: User = Depends(get_current_user),
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
+    t: Callable = Depends(get_translator)
 ):
     """登出当前用户：加入token黑名单并清理会话"""
     auth_logger.info(f"用户 {current_user.username} 请求登出")
     
     token_id = security.get_token_id(token)
     if not token_id:
-        raise BusinessException("无效的access token", code=BizCode.TOKEN_INVALID)
+        raise BusinessException(t("auth.token.invalid"), code=BizCode.TOKEN_INVALID)
 
     # 加入黑名单
     await SessionService.blacklist_token(token_id)
@@ -192,5 +197,5 @@ async def logout(
         await SessionService.clear_user_session(current_user.username)
 
     auth_logger.info(f"用户 {current_user.username} 登出成功")
-    return success(msg="登出成功")
+    return success(msg=t("auth.logout.success"))
 

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)
+            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)
             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)
+            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)
             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)
-            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)
+            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)
             # Efficient deduplication
             seen_ids = set()
             unique_rs = []

api/app/controllers/i18n_controller.py

@@ -0,0 +1,833 @@
+"""
+I18n Management API Controller
+
+This module provides management APIs for:
+- Language management (list, get, add, update languages)
+- Translation management (get, update, reload translations)
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import Callable, Optional
+
+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, get_current_superuser
+from app.i18n.dependencies import get_translator
+from app.i18n.service import get_translation_service
+from app.models.user_model import User
+from app.schemas.i18n_schema import (
+    LanguageInfo,
+    LanguageListResponse,
+    LanguageCreateRequest,
+    LanguageUpdateRequest,
+    TranslationResponse,
+    TranslationUpdateRequest,
+    MissingTranslationsResponse,
+    ReloadResponse
+)
+from app.schemas.response_schema import ApiResponse
+
+api_logger = get_api_logger()
+
+router = APIRouter(
+    prefix="/i18n",
+    tags=["I18n Management"],
+)
+
+
+# ============================================================================
+# Language Management APIs
+# ============================================================================
+
+@router.get("/languages", response_model=ApiResponse)
+def get_languages(
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Get list of all supported languages.
+    
+    Returns:
+        List of language information including code, name, and status
+    """
+    api_logger.info(f"Get languages request from user: {current_user.username}")
+    
+    from app.core.config import settings
+    translation_service = get_translation_service()
+    
+    # Get available locales from translation service
+    available_locales = translation_service.get_available_locales()
+    
+    # Build language info list
+    languages = []
+    for locale in available_locales:
+        is_default = locale == settings.I18N_DEFAULT_LANGUAGE
+        is_enabled = locale in settings.I18N_SUPPORTED_LANGUAGES
+        
+        # Get native names
+        native_names = {
+            "zh": "中文（简体）",
+            "en": "English",
+            "ja": "日本語",
+            "ko": "한국어",
+            "fr": "Français",
+            "de": "Deutsch",
+            "es": "Español"
+        }
+        
+        language_info = LanguageInfo(
+            code=locale,
+            name=f"{locale.upper()}",
+            native_name=native_names.get(locale, locale),
+            is_enabled=is_enabled,
+            is_default=is_default
+        )
+        languages.append(language_info)
+    
+    response = LanguageListResponse(languages=languages)
+    
+    api_logger.info(f"Returning {len(languages)} languages")
+    return success(data=response.dict(), msg=t("common.success.retrieved"))
+
+
+@router.get("/languages/{locale}", response_model=ApiResponse)
+def get_language(
+    locale: str,
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Get information about a specific language.
+    
+    Args:
+        locale: Language code (e.g., 'zh', 'en')
+        
+    Returns:
+        Language information
+    """
+    api_logger.info(f"Get language info request: locale={locale}, user={current_user.username}")
+    
+    from app.core.config import settings
+    translation_service = get_translation_service()
+    
+    # Check if locale exists
+    available_locales = translation_service.get_available_locales()
+    if locale not in available_locales:
+        api_logger.warning(f"Language not found: {locale}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=t("i18n.language.not_found", locale=locale)
+        )
+    
+    # Build language info
+    is_default = locale == settings.I18N_DEFAULT_LANGUAGE
+    is_enabled = locale in settings.I18N_SUPPORTED_LANGUAGES
+    
+    native_names = {
+        "zh": "中文（简体）",
+        "en": "English",
+        "ja": "日本語",
+        "ko": "한국어",
+        "fr": "Français",
+        "de": "Deutsch",
+        "es": "Español"
+    }
+    
+    language_info = LanguageInfo(
+        code=locale,
+        name=f"{locale.upper()}",
+        native_name=native_names.get(locale, locale),
+        is_enabled=is_enabled,
+        is_default=is_default
+    )
+    
+    api_logger.info(f"Returning language info for: {locale}")
+    return success(data=language_info.dict(), msg=t("common.success.retrieved"))
+
+
+@router.post("/languages", response_model=ApiResponse)
+def add_language(
+    request: LanguageCreateRequest,
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_superuser)
+):
+    """
+    Add a new language (admin only).
+    
+    Note: This endpoint validates the request but actual language addition
+    requires creating translation files in the locales directory.
+    
+    Args:
+        request: Language creation request
+        
+    Returns:
+        Success message
+    """
+    api_logger.info(
+        f"Add language request: code={request.code}, admin={current_user.username}"
+    )
+    
+    from app.core.config import settings
+    translation_service = get_translation_service()
+    
+    # Check if language already exists
+    available_locales = translation_service.get_available_locales()
+    if request.code in available_locales:
+        api_logger.warning(f"Language already exists: {request.code}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=t("i18n.language.already_exists", locale=request.code)
+        )
+    
+    # Note: Actual language addition requires creating translation files
+    # This endpoint serves as a validation and documentation point
+    
+    api_logger.info(
+        f"Language addition validated: {request.code}. "
+        "Translation files need to be created manually."
+    )
+    
+    return success(
+        msg=t(
+            "i18n.language.add_instructions",
+            locale=request.code,
+            dir=settings.I18N_CORE_LOCALES_DIR
+        )
+    )
+
+
+@router.put("/languages/{locale}", response_model=ApiResponse)
+def update_language(
+    locale: str,
+    request: LanguageUpdateRequest,
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_superuser)
+):
+    """
+    Update language configuration (admin only).
+    
+    Note: This endpoint validates the request but actual configuration
+    changes require updating environment variables or config files.
+    
+    Args:
+        locale: Language code
+        request: Language update request
+        
+    Returns:
+        Success message
+    """
+    api_logger.info(
+        f"Update language request: locale={locale}, admin={current_user.username}"
+    )
+    
+    translation_service = get_translation_service()
+    
+    # Check if language exists
+    available_locales = translation_service.get_available_locales()
+    if locale not in available_locales:
+        api_logger.warning(f"Language not found: {locale}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=t("i18n.language.not_found", locale=locale)
+        )
+    
+    # Note: Actual configuration changes require updating settings
+    # This endpoint serves as a validation and documentation point
+    
+    api_logger.info(
+        f"Language update validated: {locale}. "
+        "Configuration changes require environment variable updates."
+    )
+    
+    return success(msg=t("i18n.language.update_instructions", locale=locale))
+
+
+# ============================================================================
+# Translation Management APIs
+# ============================================================================
+
+@router.get("/translations", response_model=ApiResponse)
+def get_all_translations(
+    locale: Optional[str] = None,
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Get all translations for all or specific locale.
+    
+    Args:
+        locale: Optional locale filter
+        
+    Returns:
+        All translations organized by locale and namespace
+    """
+    api_logger.info(
+        f"Get all translations request: locale={locale}, user={current_user.username}"
+    )
+    
+    translation_service = get_translation_service()
+    
+    if locale:
+        # Get translations for specific locale
+        available_locales = translation_service.get_available_locales()
+        if locale not in available_locales:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=t("i18n.language.not_found", locale=locale)
+            )
+        
+        translations = {
+            locale: translation_service._cache.get(locale, {})
+        }
+    else:
+        # Get all translations
+        translations = translation_service._cache
+    
+    response = TranslationResponse(translations=translations)
+    
+    api_logger.info(f"Returning translations for: {locale or 'all locales'}")
+    return success(data=response.dict(), msg=t("common.success.retrieved"))
+
+
+@router.get("/translations/{locale}", response_model=ApiResponse)
+def get_locale_translations(
+    locale: str,
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Get all translations for a specific locale.
+    
+    Args:
+        locale: Language code
+        
+    Returns:
+        All translations for the locale organized by namespace
+    """
+    api_logger.info(
+        f"Get locale translations request: locale={locale}, user={current_user.username}"
+    )
+    
+    translation_service = get_translation_service()
+    
+    # Check if locale exists
+    available_locales = translation_service.get_available_locales()
+    if locale not in available_locales:
+        api_logger.warning(f"Language not found: {locale}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=t("i18n.language.not_found", locale=locale)
+        )
+    
+    translations = translation_service._cache.get(locale, {})
+    
+    api_logger.info(f"Returning {len(translations)} namespaces for locale: {locale}")
+    return success(data={"locale": locale, "translations": translations}, msg=t("common.success.retrieved"))
+
+
+@router.get("/translations/{locale}/{namespace}", response_model=ApiResponse)
+def get_namespace_translations(
+    locale: str,
+    namespace: str,
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Get translations for a specific namespace in a locale.
+    
+    Args:
+        locale: Language code
+        namespace: Translation namespace (e.g., 'common', 'auth')
+        
+    Returns:
+        Translations for the specified namespace
+    """
+    api_logger.info(
+        f"Get namespace translations request: locale={locale}, "
+        f"namespace={namespace}, user={current_user.username}"
+    )
+    
+    translation_service = get_translation_service()
+    
+    # Check if locale exists
+    available_locales = translation_service.get_available_locales()
+    if locale not in available_locales:
+        api_logger.warning(f"Language not found: {locale}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=t("i18n.language.not_found", locale=locale)
+        )
+    
+    # Get namespace translations
+    locale_translations = translation_service._cache.get(locale, {})
+    namespace_translations = locale_translations.get(namespace, {})
+    
+    if not namespace_translations:
+        api_logger.warning(f"Namespace not found: {namespace} in locale: {locale}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=t("i18n.namespace.not_found", namespace=namespace, locale=locale)
+        )
+    
+    api_logger.info(
+        f"Returning translations for namespace: {namespace} in locale: {locale}"
+    )
+    return success(
+        data={
+            "locale": locale,
+            "namespace": namespace,
+            "translations": namespace_translations
+        },
+        msg=t("common.success.retrieved")
+    )
+
+
+@router.put("/translations/{locale}/{key:path}", response_model=ApiResponse)
+def update_translation(
+    locale: str,
+    key: str,
+    request: TranslationUpdateRequest,
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_superuser)
+):
+    """
+    Update a single translation (admin only).
+    
+    Note: This endpoint validates the request but actual translation updates
+    require modifying translation files in the locales directory.
+    
+    Args:
+        locale: Language code
+        key: Translation key (format: "namespace.key.subkey")
+        request: Translation update request
+        
+    Returns:
+        Success message
+    """
+    api_logger.info(
+        f"Update translation request: locale={locale}, key={key}, "
+        f"admin={current_user.username}"
+    )
+    
+    translation_service = get_translation_service()
+    
+    # Check if locale exists
+    available_locales = translation_service.get_available_locales()
+    if locale not in available_locales:
+        api_logger.warning(f"Language not found: {locale}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=t("i18n.language.not_found", locale=locale)
+        )
+    
+    # Validate key format
+    if "." not in key:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=t("i18n.translation.invalid_key_format", key=key)
+        )
+    
+    # Note: Actual translation updates require modifying JSON files
+    # This endpoint serves as a validation and documentation point
+    
+    api_logger.info(
+        f"Translation update validated: {locale}/{key}. "
+        "Translation files need to be updated manually."
+    )
+    
+    return success(
+        msg=t("i18n.translation.update_instructions", locale=locale, key=key)
+    )
+
+
+@router.get("/translations/missing", response_model=ApiResponse)
+def get_missing_translations(
+    locale: Optional[str] = None,
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Get list of missing translations.
+    
+    Compares translations across locales to find missing keys.
+    
+    Args:
+        locale: Optional locale to check (defaults to checking all non-default locales)
+        
+    Returns:
+        List of missing translation keys
+    """
+    api_logger.info(
+        f"Get missing translations request: locale={locale}, user={current_user.username}"
+    )
+    
+    from app.core.config import settings
+    translation_service = get_translation_service()
+    
+    default_locale = settings.I18N_DEFAULT_LANGUAGE
+    available_locales = translation_service.get_available_locales()
+    
+    # Get default locale translations as reference
+    default_translations = translation_service._cache.get(default_locale, {})
+    
+    # Collect all keys from default locale
+    def collect_keys(data, prefix=""):
+        keys = []
+        for key, value in data.items():
+            full_key = f"{prefix}.{key}" if prefix else key
+            if isinstance(value, dict):
+                keys.extend(collect_keys(value, full_key))
+            else:
+                keys.append(full_key)
+        return keys
+    
+    default_keys = set()
+    for namespace, translations in default_translations.items():
+        namespace_keys = collect_keys(translations, namespace)
+        default_keys.update(namespace_keys)
+    
+    # Find missing keys in target locale(s)
+    missing_by_locale = {}
+    
+    target_locales = [locale] if locale else [
+        loc for loc in available_locales if loc != default_locale
+    ]
+    
+    for target_locale in target_locales:
+        if target_locale not in available_locales:
+            continue
+        
+        target_translations = translation_service._cache.get(target_locale, {})
+        target_keys = set()
+        
+        for namespace, translations in target_translations.items():
+            namespace_keys = collect_keys(translations, namespace)
+            target_keys.update(namespace_keys)
+        
+        missing_keys = default_keys - target_keys
+        if missing_keys:
+            missing_by_locale[target_locale] = sorted(list(missing_keys))
+    
+    response = MissingTranslationsResponse(missing_translations=missing_by_locale)
+    
+    total_missing = sum(len(keys) for keys in missing_by_locale.values())
+    api_logger.info(f"Found {total_missing} missing translations across {len(missing_by_locale)} locales")
+    
+    return success(data=response.dict(), msg=t("common.success.retrieved"))
+
+
+@router.post("/reload", response_model=ApiResponse)
+def reload_translations(
+    locale: Optional[str] = None,
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_superuser)
+):
+    """
+    Trigger hot reload of translation files (admin only).
+    
+    Args:
+        locale: Optional locale to reload (defaults to reloading all locales)
+        
+    Returns:
+        Reload status and statistics
+    """
+    api_logger.info(
+        f"Reload translations request: locale={locale or 'all'}, "
+        f"admin={current_user.username}"
+    )
+    
+    from app.core.config import settings
+    
+    if not settings.I18N_ENABLE_HOT_RELOAD:
+        api_logger.warning("Hot reload is disabled in configuration")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail=t("i18n.reload.disabled")
+        )
+    
+    translation_service = get_translation_service()
+    
+    try:
+        # Reload translations
+        translation_service.reload(locale)
+        
+        # Get statistics
+        available_locales = translation_service.get_available_locales()
+        reloaded_locales = [locale] if locale else available_locales
+        
+        response = ReloadResponse(
+            success=True,
+            reloaded_locales=reloaded_locales,
+            total_locales=len(available_locales)
+        )
+        
+        api_logger.info(
+            f"Successfully reloaded translations for: {', '.join(reloaded_locales)}"
+        )
+        
+        return success(data=response.dict(), msg=t("i18n.reload.success"))
+        
+    except Exception as e:
+        api_logger.error(f"Failed to reload translations: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=t("i18n.reload.failed", error=str(e))
+        )
+
+
+# ============================================================================
+# Performance Monitoring APIs
+# ============================================================================
+
+@router.get("/metrics", response_model=ApiResponse)
+def get_metrics(
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_superuser)
+):
+    """
+    Get i18n performance metrics (admin only).
+    
+    Returns:
+        Performance metrics including:
+        - Request counts
+        - Missing translations
+        - Timing statistics
+        - Locale usage
+        - Error counts
+    """
+    api_logger.info(f"Get metrics request: admin={current_user.username}")
+    
+    translation_service = get_translation_service()
+    metrics = translation_service.get_metrics_summary()
+    
+    api_logger.info("Returning i18n metrics")
+    return success(data=metrics, msg=t("common.success.retrieved"))
+
+
+@router.get("/metrics/cache", response_model=ApiResponse)
+def get_cache_stats(
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_superuser)
+):
+    """
+    Get cache statistics (admin only).
+    
+    Returns:
+        Cache statistics including:
+        - Hit/miss rates
+        - LRU cache performance
+        - Loaded locales
+        - Memory usage
+    """
+    api_logger.info(f"Get cache stats request: admin={current_user.username}")
+    
+    translation_service = get_translation_service()
+    cache_stats = translation_service.get_cache_stats()
+    memory_usage = translation_service.get_memory_usage()
+    
+    data = {
+        "cache": cache_stats,
+        "memory": memory_usage
+    }
+    
+    api_logger.info("Returning cache statistics")
+    return success(data=data, msg=t("common.success.retrieved"))
+
+
+@router.get("/metrics/prometheus")
+def get_prometheus_metrics(
+    current_user: User = Depends(get_current_superuser)
+):
+    """
+    Get metrics in Prometheus format (admin only).
+    
+    Returns:
+        Prometheus-formatted metrics as plain text
+    """
+    api_logger.info(f"Get Prometheus metrics request: admin={current_user.username}")
+    
+    from app.i18n.metrics import get_metrics
+    metrics = get_metrics()
+    prometheus_output = metrics.export_prometheus()
+    
+    from fastapi.responses import PlainTextResponse
+    return PlainTextResponse(content=prometheus_output)
+
+
+@router.post("/metrics/reset", response_model=ApiResponse)
+def reset_metrics(
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_superuser)
+):
+    """
+    Reset all metrics (admin only).
+    
+    Returns:
+        Success message
+    """
+    api_logger.info(f"Reset metrics request: admin={current_user.username}")
+    
+    from app.i18n.metrics import get_metrics
+    metrics = get_metrics()
+    metrics.reset()
+    
+    translation_service = get_translation_service()
+    translation_service.cache.reset_stats()
+    
+    api_logger.info("Metrics reset completed")
+    return success(msg=t("i18n.metrics.reset_success"))
+
+
+# ============================================================================
+# Missing Translation Logging and Reporting APIs
+# ============================================================================
+
+@router.get("/logs/missing", response_model=ApiResponse)
+def get_missing_translation_logs(
+    locale: Optional[str] = None,
+    limit: Optional[int] = 100,
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_superuser)
+):
+    """
+    Get missing translation logs (admin only).
+    
+    Returns logged missing translations with context information.
+    
+    Args:
+        locale: Optional locale filter
+        limit: Maximum number of entries to return (default: 100)
+        
+    Returns:
+        Missing translation logs with context
+    """
+    api_logger.info(
+        f"Get missing translation logs request: locale={locale}, "
+        f"limit={limit}, admin={current_user.username}"
+    )
+    
+    translation_service = get_translation_service()
+    translation_logger = translation_service.translation_logger
+    
+    # Get missing translations
+    missing_translations = translation_logger.get_missing_translations(locale)
+    
+    # Get missing with context
+    missing_with_context = translation_logger.get_missing_with_context(locale, limit)
+    
+    # Get statistics
+    statistics = translation_logger.get_statistics()
+    
+    data = {
+        "missing_translations": missing_translations,
+        "recent_context": missing_with_context,
+        "statistics": statistics
+    }
+    
+    api_logger.info(
+        f"Returning {statistics['total_missing']} missing translations"
+    )
+    return success(data=data, msg=t("common.success.retrieved"))
+
+
+@router.get("/logs/missing/report", response_model=ApiResponse)
+def generate_missing_translation_report(
+    locale: Optional[str] = None,
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_superuser)
+):
+    """
+    Generate a comprehensive missing translation report (admin only).
+    
+    Args:
+        locale: Optional locale filter
+        
+    Returns:
+        Comprehensive report with missing translations and statistics
+    """
+    api_logger.info(
+        f"Generate missing translation report request: locale={locale}, "
+        f"admin={current_user.username}"
+    )
+    
+    translation_service = get_translation_service()
+    translation_logger = translation_service.translation_logger
+    
+    # Generate report
+    report = translation_logger.generate_report(locale)
+    
+    api_logger.info(
+        f"Generated report with {report['total_missing']} missing translations"
+    )
+    return success(data=report, msg=t("common.success.retrieved"))
+
+
+@router.post("/logs/missing/export", response_model=ApiResponse)
+def export_missing_translations(
+    locale: Optional[str] = None,
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_superuser)
+):
+    """
+    Export missing translations to JSON file (admin only).
+    
+    Args:
+        locale: Optional locale filter
+        
+    Returns:
+        Export status and file path
+    """
+    api_logger.info(
+        f"Export missing translations request: locale={locale}, "
+        f"admin={current_user.username}"
+    )
+    
+    from datetime import datetime
+    translation_service = get_translation_service()
+    translation_logger = translation_service.translation_logger
+    
+    # Generate filename with timestamp
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    locale_suffix = f"_{locale}" if locale else "_all"
+    output_file = f"logs/i18n/missing_translations{locale_suffix}_{timestamp}.json"
+    
+    # Export to file
+    translation_logger.export_to_json(output_file)
+    
+    api_logger.info(f"Missing translations exported to: {output_file}")
+    return success(
+        data={"file_path": output_file},
+        msg=t("i18n.logs.export_success", file=output_file)
+    )
+
+
+@router.delete("/logs/missing", response_model=ApiResponse)
+def clear_missing_translation_logs(
+    locale: Optional[str] = None,
+    t: Callable = Depends(get_translator),
+    current_user: User = Depends(get_current_superuser)
+):
+    """
+    Clear missing translation logs (admin only).
+    
+    Args:
+        locale: Optional locale to clear (clears all if not specified)
+        
+    Returns:
+        Success message
+    """
+    api_logger.info(
+        f"Clear missing translation logs request: locale={locale or 'all'}, "
+        f"admin={current_user.username}"
+    )
+    
+    translation_service = get_translation_service()
+    translation_logger = translation_service.translation_logger
+    
+    # Clear logs
+    translation_logger.clear(locale)
+    
+    api_logger.info(f"Cleared missing translation logs for: {locale or 'all locales'}")
+    return success(msg=t("i18n.logs.clear_success"))

api/app/controllers/mcp_market_config_controller.py

@@ -19,7 +19,7 @@ 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
+from app.services import mcp_market_config_service, mcp_market_service
 
 # Obtain a dedicated API logger
 api_logger = get_api_logger()
@@ -55,6 +55,12 @@ async def get_mcp_servers(
             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}")
@@ -64,14 +70,16 @@ async def get_mcp_servers(
     if not db_mcp_market_config:
         api_logger.warning(
             f"The mcp market config does not exist or access is denied: mcp_market_config_id={mcp_market_config_id}")
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="The mcp market config does not exist or access is denied"
-        )
+        return success(msg='The mcp market config does not exist or access is denied')
 
     # 3. Execute paged query
-    api = MCPApi()
     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 = {
@@ -90,7 +98,7 @@ async def get_mcp_servers(
             cookies=cookies)
         raise_for_http_status(r)
     except requests.exceptions.RequestException as e:
-        api_logger.error(f"mFailed to get MCP servers: {str(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)}"
@@ -115,9 +123,81 @@ async def get_mcp_servers(
             "has_next": True if page * pagesize < total else False
         }
     }
+    # 5. Update mck_market.mcp_count
+    db_mcp_market = mcp_market_service.get_mcp_market_by_id(db, mcp_market_id=db_mcp_market_config.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={db_mcp_market_config.mcp_market_id}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="The mcp market does not exist or access is denied"
+        )
+    db_mcp_market.mcp_count = total
+    db.commit()
+    db.refresh(db_mcp_market)
     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,
@@ -139,14 +219,16 @@ async def get_mcp_server(
     if not db_mcp_market_config:
         api_logger.warning(
             f"The mcp market config does not exist or access is denied: mcp_market_config_id={mcp_market_config_id}")
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="The mcp market config does not exist or access is denied"
-        )
+        return success(msg='The mcp market config does not exist or access is denied')
 
     # 2. Get detailed information for a specific MCP Server
-    api = MCPApi()
     token = db_mcp_market_config.token
+    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)
@@ -167,7 +249,26 @@ async def create_mcp_market_config(
 
     try:
         api_logger.debug(f"Start creating the mcp market config: {create_data.mcp_market_id}")
-        # 1. Check if the mcp market name already exists
+        # 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}")
@@ -175,6 +276,30 @@ async def create_mcp_market_config(
                 status_code=status.HTTP_400_BAD_REQUEST,
                 detail=f"The mcp market id already exists: {create_data.mcp_market_id}"
             )
+        # 2. verify token
+        create_data.status = 1
+        try:
+            api = MCPApi()
+            token = create_data.token
+            api.login(token)
+
+            body = {
+                'filter': {},
+                'page_number': 1,
+                'page_size': 20,
+                'search': ""
+            }
+            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)}")
+            create_data.status = 0
+        # 3. create mcp_market_config
         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})")
@@ -203,10 +328,7 @@ async def get_mcp_market_config(
         db_mcp_market_config = mcp_market_config_service.get_mcp_market_config_by_id(db, mcp_market_config_id=mcp_market_config_id, current_user=current_user)
         if not db_mcp_market_config:
             api_logger.warning(f"The mcp market config does not exist or access is denied: mcp_market_config_id={mcp_market_config_id}")
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="The mcp market config does not exist or access is denied"
-            )
+            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)),
@@ -236,10 +358,7 @@ async def get_mcp_market_config_by_mcp_market_id(
         db_mcp_market_config = mcp_market_config_service.get_mcp_market_config_by_mcp_market_id(db, mcp_market_id=mcp_market_id, current_user=current_user)
         if not db_mcp_market_config:
             api_logger.warning(f"The mcp market config does not exist or access is denied: mcp_market_id={mcp_market_id}")
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="The mcp market config does not exist or access is denied"
-            )
+            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)),
@@ -265,12 +384,25 @@ async def update_mcp_market_config(
     if not db_mcp_market_config:
         api_logger.warning(
             f"The mcp market config does not exist or you do not have permission to access it: mcp_market_config_id={mcp_market_config_id}")
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="The mcp market config does not exist or you do not have permission to access it"
-        )
+        return success(msg='The mcp market config does not exist or access is denied')
 
-    # 2. Update fields (only update non-null fields)
+    # 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 = []
@@ -285,7 +417,7 @@ async def update_mcp_market_config(
     if updated_fields:
         api_logger.debug(f"updated fields: {', '.join(updated_fields)}")
 
-    # 3. Save to database
+    # 4. Save to database
     try:
         db.commit()
         db.refresh(db_mcp_market_config)
@@ -298,7 +430,7 @@ async def update_mcp_market_config(
             detail=f"The mcp market config update failed: {str(e)}"
         )
 
-    # 4. Return the updated mcp market config
+    # 5. 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")
 
@@ -322,10 +454,7 @@ async def delete_mcp_market_config(
         if not db_mcp_market_config:
             api_logger.warning(
                 f"The mcp market config does not exist or you do not have permission to access it: mcp_market_config_id={mcp_market_config_id}")
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="The mcp market config does not exist or you do not have permission to access it"
-            )
+            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/app/controllers/memory_agent_controller.py

@@ -1,27 +1,29 @@
 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.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.repositories import knowledge_repository
 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()
@@ -36,7 +38,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
@@ -54,8 +56,9 @@ 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
@@ -74,16 +77,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
@@ -118,10 +121,10 @@ 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,
+        language_type: str = Header(default=None, alias="X-Language-Type"),
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_user)
 ):
     """
     Write service endpoint - processes write operations synchronously
@@ -135,11 +138,11 @@ async def write_server(
     """
     # 使用集中化的语言校验
     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}")
-    
+
     # 获取 storage_type，如果为 None 则使用默认值
     storage_type = workspace_service.get_workspace_storage_type(
         db=db,
@@ -148,7 +151,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:
@@ -160,13 +163,15 @@ 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(
@@ -174,7 +179,7 @@ async def write_server(
             messages_list,
             config_id,
             db,
-            storage_type, 
+            storage_type,
             user_rag_memory_id,
             language
         )
@@ -194,10 +199,10 @@ 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,
+        language_type: str = Header(default=None, alias="X-Language-Type"),
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_user)
 ):
     """
     Async write service endpoint - enqueues write processing to Celery
@@ -212,10 +217,11 @@ async def write_server_async(
     """
     # 使用集中化的语言校验
     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}, language_type={language}")
 
     # 获取 storage_type，如果为 None 则使用默认值
     storage_type = workspace_service.get_workspace_storage_type(
@@ -243,7 +249,7 @@ async def write_server_async(
             args=[user_input.end_user_id, messages_list, config_id, storage_type, user_rag_memory_id, language]
         )
         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)}")
@@ -253,9 +259,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
@@ -290,8 +296,9 @@ 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,
@@ -305,7 +312,8 @@ 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 的方法生成最终答案
@@ -318,7 +326,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
@@ -334,9 +342,10 @@ 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)
+        current_user: User = Depends(get_current_user),
+        db: Session = Depends(get_db),
 ):
     """
     文件上传接口 - 支持图片识别
@@ -349,9 +358,6 @@ 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]
@@ -360,7 +366,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,
@@ -374,12 +380,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))
@@ -429,8 +435,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
@@ -451,7 +457,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", {})
@@ -469,7 +475,7 @@ async def get_read_task_result(
             else:
                 # 旧格式：直接返回结果
                 return success(data=task_result, msg="查询任务已完成")
-                
+
         elif status == "FAILURE":
             # 任务失败
             error_info = result.get("result", "Unknown error")
@@ -478,7 +484,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(
@@ -498,7 +504,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))
@@ -506,8 +512,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
@@ -528,7 +534,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", {})
@@ -546,7 +552,7 @@ async def get_write_task_result(
             else:
                 # 旧格式：直接返回结果
                 return success(data=task_result, msg="写入任务已完成")
-                
+
         elif status == "FAILURE":
             # 任务失败
             error_info = result.get("result", "Unknown error")
@@ -555,7 +561,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(
@@ -575,7 +581,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))
@@ -583,9 +589,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)
@@ -628,9 +634,10 @@ 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)
+        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),
 ):
     """
     统计当前空间下各知识库类型的数量，包含 General | Web | Third-party | Folder。
@@ -639,14 +646,9 @@ async def get_knowledge_type_stats_api(
     - 知识库类型根据当前用户的 current_workspace_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,
@@ -654,48 +656,70 @@ 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/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（可选）"),
-    limit: int = Query(20, description="返回标签数量限制"),
-    current_user: User = Depends(get_current_user),
-    db: Session=Depends(get_db),
+@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),
 ):
     """
-    获取指定用户的热门记忆标签
+    获取指定用户的兴趣分布标签
     
-    注意：标签语言由写入时的 X-Language-Type 决定，查询时不进行翻译
+    与热门标签不同，此接口专注于识别用户的兴趣活动（运动、爱好、学习、创作等），
+    过滤掉纯物品、工具、地点等不代表用户主动参与活动的名词。
     
     返回格式：
     [
-        {"name": "标签名", "frequency": 频次},
+        {"name": "兴趣活动名", "frequency": 频次},
         ...
     ]
     """
-    api_logger.info(f"Hot memory tags by user requested: end_user_id={end_user_id}")
+    language = get_language_from_header(language_type)
+    api_logger.info(f"Interest distribution by user requested: end_user_id={end_user_id}, language={language}")
     try:
-        result = await memory_agent_service.get_hot_memory_tags_by_user(
+        # 优先读取缓存
+        cached = await InterestMemoryCache.get_interest_distribution(
             end_user_id=end_user_id,
-            limit=limit
+            language=language,
         )
-        return success(data=result, msg="获取热门记忆标签成功")
+        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="获取兴趣分布标签成功")
     except Exception as e:
-        api_logger.error(f"Hot memory tags by user failed: {str(e)}")
-        return fail(BizCode.INTERNAL_ERROR, "获取热门记忆标签失败", str(e))
+        api_logger.error(f"Interest distribution 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)
 ):
     """
     获取用户详情，包含：
@@ -733,17 +757,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:
@@ -759,9 +783,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)
 ):
     """
     获取终端用户关联的记忆配置
@@ -780,9 +804,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="获取终端用户关联配置成功")
@@ -791,4 +815,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,4 +1,5 @@
 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
@@ -149,6 +150,21 @@ 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(),
@@ -177,7 +193,16 @@ async def get_workspace_end_users(
         await aio_redis_set(cache_key, json.dumps(result), expire=30)
     except Exception as e:
         api_logger.warning(f"Redis 缓存写入失败: {str(e)}")
-    
+
+    # 触发社区聚类补全任务（异步，不阻塞接口响应）
+    # 对有 ExtractedEntity 但无 Community 节点的存量用户自动补跑全量聚类
+    try:
+        from app.tasks import init_community_clustering_for_users
+        init_community_clustering_for_users.delay(end_user_ids=end_user_ids)
+        api_logger.info(f"已触发社区聚类补全任务，候选用户数: {len(end_user_ids)}")
+    except Exception as e:
+        api_logger.warning(f"触发社区聚类补全任务失败（不影响主流程）: {str(e)}")
+
     api_logger.info(f"成功获取 {len(end_users)} 个宿主记录")
     return success(data=result, msg="宿主列表获取成功")
 
@@ -387,14 +412,15 @@ 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"),
-    limit: int = Query(15, description="返回记录数"),
+    page: int = Query(1, gt=0, description="页码，从1开始"),
+    pagesize: int = Query(15, gt=0, le=100, 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, limit, db, current_user)
+    data = memory_dashboard_service.get_rag_content(end_user_id, page, pagesize, db, current_user)
     return success(data=data, msg="宿主RAGchunk数据获取成功")
 
 
@@ -407,26 +433,18 @@ async def get_chunk_summary_tag(
     current_user: User = Depends(get_current_user),
 ):
     """
-    获取chunk总结、提取的标签和人物形象
-    
+    读取RAG摘要、标签和人物形象（纯读库，不触发生成）。
+
     返回格式：
     {
-        "summary": "chunk内容的总结",
-        "tags": [
-            {"tag": "标签1", "frequency": 5},
-            {"tag": "标签2", "frequency": 3},
-            ...
-        ],
-        "personas": [
-            "产品设计师",
-            "旅行爱好者",
-            "摄影发烧友",
-            ...
-        ]
+        "summary": "用户摘要",
+        "tags": [{"tag": "标签1", "frequency": 5}, ...],
+        "personas": ["产品设计师", ...],
+        "generated": true/false  // false表示尚未生产，请调用 /generate_rag_profile
     }
     """
-    api_logger.info(f"用户 {current_user.username} 请求获取宿主 {end_user_id} 的chunk摘要、标签和人物形象")
-    
+    api_logger.info(f"用户 {current_user.username} 读取宿主 {end_user_id} 的RAG摘要/标签/人物形象")
+
     data = await memory_dashboard_service.get_chunk_summary_and_tags(
         end_user_id=end_user_id,
         limit=limit,
@@ -434,9 +452,8 @@ async def get_chunk_summary_tag(
         db=db,
         current_user=current_user
     )
-    
-    api_logger.info(f"成功获取chunk摘要、{len(data.get('tags', []))} 个标签和 {len(data.get('personas', []))} 个人物形象")
-    return success(data=data, msg="chunk摘要、标签和人物形象获取成功")
+
+    return success(data=data, msg="获取成功")
 
 
 @router.get("/chunk_insight", response_model=ApiResponse)
@@ -447,24 +464,57 @@ async def get_chunk_insight(
     current_user: User = Depends(get_current_user),
 ):
     """
-    获取chunk的洞察内容
-    
+    读取RAG洞察报告（纯读库，不触发生成）。
+
     返回格式：
     {
-        "insight": "对chunk内容的深度洞察分析"
+        "insight": "总体概述",
+        "behavior_pattern": "行为模式",
+        "key_findings": "关键发现",
+        "growth_trajectory": "成长轨迹",
+        "generated": true/false  // false表示尚未生产，请调用 /generate_rag_profile
     }
     """
-    api_logger.info(f"用户 {current_user.username} 请求获取宿主 {end_user_id} 的chunk洞察")
-    
+    api_logger.info(f"用户 {current_user.username} 读取宿主 {end_user_id} 的RAG洞察")
+
     data = await memory_dashboard_service.get_chunk_insight(
         end_user_id=end_user_id,
         limit=limit,
         db=db,
         current_user=current_user
     )
-    
-    api_logger.info("成功获取chunk洞察")
-    return success(data=data, msg="chunk洞察获取成功")
+
+    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画像生产完成")
 
 
 @router.get("/dashboard_data", response_model=ApiResponse)
@@ -606,8 +656,8 @@ async def dashboard_data(
             
             # 获取RAG相关数据
             try:
-                # total_memory: 使用 total_chunk（总chunk数）
-                total_chunk = memory_dashboard_service.get_rag_total_chunk(db, current_user)
+                # total_memory: 只统计用户知识库（permission_id='Memory'）的chunk数
+                total_chunk = memory_dashboard_service.get_rag_user_kb_total_chunk(db, current_user)
                 rag_data["total_memory"] = total_chunk
                 
                 # total_app: 统计当前空间下的所有app数量

api/app/controllers/memory_reflection_controller.py

@@ -1,3 +1,19 @@
+"""
+Memory Reflection Controller
+
+This module provides REST API endpoints for managing memory reflection configurations
+and operations. It handles reflection engine setup, configuration management, and
+execution of self-reflection processes across memory systems.
+
+Key Features:
+- Reflection configuration management (save, retrieve, update)
+- Workspace-wide reflection execution across multiple applications
+- Individual configuration-based reflection runs
+- Multi-language support for reflection outputs
+- Integration with Neo4j memory storage and LLM models
+- Comprehensive error handling and logging
+"""
+
 import asyncio
 import time
 import uuid
@@ -28,9 +44,13 @@ from sqlalchemy.orm import Session
 
 from app.utils.config_utils import resolve_config_id
 
+# Load environment variables for configuration
 load_dotenv()
+
+# Initialize API logger for request tracking and debugging
 api_logger = get_api_logger()
 
+# Configure router with prefix and tags for API organization
 router = APIRouter(
     prefix="/memory",
     tags=["Memory"],
@@ -43,7 +63,38 @@ async def save_reflection_config(
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
 ) -> dict:
-    """Save reflection configuration to data_comfig table"""
+    """
+    Save reflection configuration to memory config table
+    
+    Persists reflection engine configuration settings to the data_config table,
+    including reflection parameters, model settings, and evaluation criteria.
+    Validates configuration parameters and ensures data consistency.
+    
+    Args:
+        request: Memory reflection configuration data including:
+            - config_id: Configuration identifier to update
+            - reflection_enabled: Whether reflection is enabled
+            - reflection_period_in_hours: Reflection execution interval
+            - reflexion_range: Scope of reflection (partial/all)
+            - baseline: Reflection strategy (time/fact/hybrid)
+            - reflection_model_id: LLM model for reflection operations
+            - memory_verify: Enable memory verification checks
+            - quality_assessment: Enable quality assessment evaluation
+        current_user: Authenticated user saving the configuration
+        db: Database session for data operations
+    
+    Returns:
+        dict: Success response with saved reflection configuration data
+        
+    Raises:
+        HTTPException 400: If config_id is missing or parameters are invalid
+        HTTPException 500: If configuration save operation fails
+        
+    Database Operations:
+        - Updates memory_config table with reflection settings
+        - Commits transaction and refreshes entity
+        - Maintains configuration consistency
+    """
     try:
         config_id = request.config_id
         config_id = resolve_config_id(config_id, db)
@@ -54,6 +105,7 @@ async def save_reflection_config(
             )
         api_logger.info(f"用户 {current_user.username} 保存反思配置，config_id: {config_id}")
 
+        # Update reflection configuration in database
         memory_config = MemoryConfigRepository.update_reflection_config(
             db,
             config_id=config_id,
@@ -66,6 +118,7 @@ async def save_reflection_config(
             quality_assessment=request.quality_assessment
         )
 
+        # Commit transaction and refresh entity
         db.commit()
         db.refresh(memory_config)
 
@@ -102,13 +155,55 @@ async def start_workspace_reflection(
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
 ) -> dict:
-    """启动工作空间中所有匹配应用的反思功能"""
+    """
+    Start reflection functionality for all matching applications in workspace
+    
+    Initiates reflection processes across all applications within the user's current
+    workspace that have valid memory configurations. Processes each application's
+    configurations and associated end users, executing reflection operations
+    with proper error isolation and transaction management.
+    
+    This endpoint serves as a workspace-wide reflection orchestrator, ensuring
+    that reflection failures for individual users don't affect other operations.
+    
+    Args:
+        current_user: Authenticated user initiating workspace reflection
+        db: Database session for configuration queries
+    
+    Returns:
+        dict: Success response with reflection results for all processed applications:
+            - app_id: Application identifier
+            - config_id: Memory configuration identifier
+            - end_user_id: End user identifier
+            - reflection_result: Individual reflection operation result
+    
+    Processing Logic:
+        1. Retrieve all applications in the current workspace
+        2. Filter applications with valid memory configurations
+        3. For each configuration, find matching releases
+        4. Execute reflection for each end user with isolated transactions
+        5. Aggregate results with error handling per user
+    
+    Error Handling:
+        - Individual user reflection failures are isolated
+        - Failed operations are logged and included in results
+        - Database transactions are isolated per user to prevent cascading failures
+        - Comprehensive error reporting for debugging
+    
+    Raises:
+        HTTPException 500: If workspace reflection initialization fails
+        
+    Performance Notes:
+        - Uses independent database sessions for each user operation
+        - Prevents transaction failures from affecting other users
+        - Comprehensive logging for operation tracking
+    """
     workspace_id = current_user.current_workspace_id
 
     try:
         api_logger.info(f"用户 {current_user.username} 启动workspace反思，workspace_id: {workspace_id}")
 
-        # 使用独立的数据库会话来获取工作空间应用详情，避免事务失败
+        # Use independent database session to get workspace app details, avoiding transaction failures
         from app.db import get_db_context
         with get_db_context() as query_db:
             service = WorkspaceAppService(query_db)
@@ -116,8 +211,9 @@ async def start_workspace_reflection(
         
         reflection_results = []
         
+        # Process each application in the workspace
         for data in result['apps_detailed_info']:
-            # 跳过没有配置的应用
+            # Skip applications without configurations
             if not data['memory_configs']:
                 api_logger.debug(f"应用 {data['id']} 没有memory_configs，跳过")
                 continue
@@ -126,22 +222,22 @@ async def start_workspace_reflection(
             memory_configs = data['memory_configs']
             end_users = data['end_users']
 
-            # 为每个配置和用户组合执行反思
+            # Execute reflection for each configuration and user combination
             for config in memory_configs:
                 config_id_str = str(config['config_id'])
 
-                # 找到匹配此配置的所有release
+                # Find all releases matching this configuration
                 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")
                     continue
 
-                # 为每个用户执行反思 - 使用独立的数据库会话
+                # Execute reflection for each user - using independent database sessions
                 for user in end_users:
                     api_logger.info(f"为用户 {user['id']} 启动反思，config_id: {config_id_str}")
 
-                    # 为每个用户创建独立的数据库会话，避免事务失败影响其他用户
+                    # Create independent database session for each user to avoid transaction failure impact
                     with get_db_context() as user_db:
                         try:
                             reflection_service = MemoryReflectionService(user_db)
@@ -184,14 +280,51 @@ async def start_reflection_configs(
         current_user: User = Depends(get_current_user),
         db: Session = Depends(get_db),
 ) -> dict:
-    """通过config_id查询memory_config表中的反思配置信息"""
+    """
+    Query reflection configuration information by config_id
+    
+    Retrieves detailed reflection configuration settings from the memory_config
+    table for a specific configuration ID. Provides comprehensive reflection
+    parameters including model settings, evaluation criteria, and operational flags.
+    
+    Args:
+        config_id: Configuration identifier (UUID or integer) to query
+        current_user: Authenticated user making the request
+        db: Database session for data operations
+    
+    Returns:
+        dict: Success response with detailed reflection configuration:
+            - config_id: Resolved configuration identifier
+            - reflection_enabled: Whether reflection is enabled for this config
+            - reflection_period_in_hours: Reflection execution interval
+            - reflexion_range: Scope of reflection operations (partial/all)
+            - baseline: Reflection strategy (time/fact/hybrid)
+            - reflection_model_id: LLM model identifier for reflection
+            - memory_verify: Memory verification flag
+            - quality_assessment: Quality assessment flag
+    
+    Database Operations:
+        - Queries memory_config table by resolved config_id
+        - Retrieves all reflection-related configuration fields
+        - Resolves configuration ID for consistent formatting
+    
+    Raises:
+        HTTPException 404: If configuration with specified ID is not found
+        HTTPException 500: If configuration query operation fails
+        
+    ID Resolution:
+        - Supports both UUID and integer config_id formats
+        - Automatically resolves to appropriate internal format
+        - Maintains consistency across different ID representations
+    """
     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)
-        # 构建返回数据
+        
+        # Build response data with comprehensive configuration details
         reflection_config = {
             "config_id": memory_config_id,
             "reflection_enabled": result.enable_self_reflexion,
@@ -204,10 +337,12 @@ async def start_reflection_configs(
         }
         api_logger.info(f"成功查询反思配置，config_id: {config_id}")
         return success(data=reflection_config, msg="反思配置查询成功")
-        
 
+        api_logger.info(f"Successfully queried reflection config, config_id: {config_id}")
+        return success(data=reflection_config, msg="Reflection configuration query successful")
+        
     except HTTPException:
-        # 重新抛出HTTP异常
+        # Re-raise HTTP exceptions without modification
         raise
     except Exception as e:
         api_logger.error(f"查询反思配置失败: {str(e)}")
@@ -223,13 +358,66 @@ async def reflection_run(
     current_user: User = Depends(get_current_user),
     db: Session = Depends(get_db),
 ) -> dict:
-    """Activate the reflection function for all matching applications in the workspace"""
-    # 使用集中化的语言校验
+    """
+    Execute reflection engine with specified configuration
+    
+    Runs the reflection engine using configuration parameters from the database.
+    Validates model availability, sets up the reflection engine with proper
+    configuration, and executes the reflection process with multi-language support.
+    
+    This endpoint provides a test run capability for reflection configurations,
+    allowing users to validate their reflection settings and see results before
+    deploying to production environments.
+    
+    Args:
+        config_id: Configuration identifier (UUID or integer) for reflection settings
+        language_type: Language preference header for output localization (optional)
+        current_user: Authenticated user executing the reflection
+        db: Database session for configuration queries
+    
+    Returns:
+        dict: Success response with reflection execution results including:
+            - baseline: Reflection strategy used
+            - source_data: Input data processed
+            - memory_verifies: Memory verification results (if enabled)
+            - quality_assessments: Quality assessment results (if enabled)
+            - reflexion_data: Generated reflection insights and solutions
+    
+    Configuration Validation:
+        - Verifies configuration exists in database
+        - Validates LLM model availability
+        - Falls back to default model if specified model is unavailable
+        - Ensures all required parameters are properly set
+    
+    Reflection Engine Setup:
+        - Creates ReflectionConfig with database parameters
+        - Initializes Neo4j connector for memory access
+        - Sets up ReflectionEngine with validated model
+        - Configures language preferences for output
+    
+    Error Handling:
+        - Model validation with fallback to default
+        - Configuration validation and error reporting
+        - Comprehensive logging for debugging
+        - Graceful handling of missing configurations
+    
+    Raises:
+        HTTPException 404: If configuration is not found
+        HTTPException 500: If reflection execution fails
+        
+    Performance Notes:
+        - Direct database query for configuration retrieval
+        - Model validation to prevent runtime failures
+        - Efficient reflection engine initialization
+        - Language-aware output processing
+    """
+    # Use centralized language validation for consistent localization
     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查询反思配置
+    
+    # Query reflection configuration using MemoryConfigRepository
     result = MemoryConfigRepository.query_reflection_config_by_id(db, config_id)
     if not result:
         raise HTTPException(
@@ -239,7 +427,7 @@ async def reflection_run(
 
     api_logger.info(f"成功查询反思配置，config_id: {config_id}")
 
-    # 验证模型ID是否存在
+    # Validate model ID existence
     model_id = result.reflection_model_id
     if model_id:
         try:
@@ -250,6 +438,7 @@ async def reflection_run(
             # 可以设置为None，让反思引擎使用默认模型
             model_id = None
 
+    # Create reflection configuration with database parameters
     config = ReflectionConfig(
         enabled=result.enable_self_reflexion,
         iteration_period=result.iteration_period,
@@ -262,11 +451,13 @@ async def reflection_run(
         model_id=model_id,
         language_type=language_type
     )
+    
+    # Initialize Neo4j connector and reflection engine
     connector = Neo4jConnector()
     engine = ReflectionEngine(
         config=config,
         neo4j_connector=connector,
-        llm_client=model_id  # 传入验证后的 model_id
+        llm_client=model_id  # Pass validated model_id
     )
 
     result=await (engine.reflection_run())

api/app/controllers/memory_short_term_controller.py

@@ -1,19 +1,40 @@
-from fastapi import APIRouter, Depends, HTTPException, status,Header
+"""
+Memory Short Term Controller
+
+This module provides REST API endpoints for managing short-term and long-term memory
+data retrieval and analysis. It handles memory system statistics, data aggregation,
+and provides comprehensive memory insights for end users.
+
+Key Features:
+- Short-term memory data retrieval and statistics
+- Long-term memory data aggregation
+- Entity count integration
+- Multi-language response support
+- Memory system analytics and reporting
+"""
+
+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 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_short_service import ShortService,LongService
-from dotenv import load_dotenv
-from sqlalchemy.orm import Session
-from typing import Optional
+
+# Load environment variables for configuration
 load_dotenv()
+
+# Initialize API logger for request tracking and debugging
 api_logger = get_api_logger()
 
+# Configure router with prefix and tags for API organization
 router = APIRouter(
     prefix="/memory/short",
     tags=["Memory"],
@@ -25,24 +46,73 @@ async def short_term_configs(
         current_user: User = Depends(get_current_user),
         db: Session = Depends(get_db),
 ):
-    # 使用集中化的语言校验
+    """
+    Retrieve comprehensive short-term and long-term memory statistics
+    
+    Provides a comprehensive overview of memory system data for a specific end user,
+    including short-term memory entries, long-term memory aggregations, entity counts,
+    and retrieval statistics. Supports multi-language responses based on request headers.
+    
+    This endpoint serves as a central dashboard for memory system analytics, combining
+    data from multiple memory subsystems to provide a holistic view of user memory state.
+    
+    Args:
+        end_user_id: Unique identifier for the end user whose memory data to retrieve
+        language_type: Language preference header for response localization (optional)
+        current_user: Authenticated user making the request (injected by dependency)
+        db: Database session for data operations (injected by dependency)
+    
+    Returns:
+        dict: Success response containing comprehensive memory statistics:
+            - short_term: List of short-term memory entries with detailed data
+            - long_term: List of long-term memory aggregations and summaries
+            - entity: Count of entities associated with the end user
+            - retrieval_number: Total count of short-term memory retrievals
+            - long_term_number: Total count of long-term memory entries
+    
+    Response Structure:
+        {
+            "code": 200,
+            "msg": "Short-term memory system data retrieved successfully",
+            "data": {
+                "short_term": [...],      # Short-term memory entries
+                "long_term": [...],       # Long-term memory data
+                "entity": 42,             # Entity count
+                "retrieval_number": 156,  # Short-term retrieval count
+                "long_term_number": 23    # Long-term memory count
+            }
+        }
+    
+    Raises:
+        HTTPException: If end_user_id is invalid or data retrieval fails
+        
+    Performance Notes:
+        - Combines multiple service calls for comprehensive data
+        - Entity search is performed asynchronously for better performance
+        - Response time depends on memory data volume for the specified user
+    """
+    # Use centralized language validation for consistent localization
     language = get_language_from_header(language_type)
     
-    # 获取短期记忆数据
-    short_term=ShortService(end_user_id)
-    short_result=short_term.get_short_databasets()
-    short_count=short_term.get_short_count()
+    # Retrieve short-term memory data and statistics
+    short_term = ShortService(end_user_id, db)
+    short_result = short_term.get_short_databasets()  # Get short-term memory entries
+    short_count = short_term.get_short_count()        # Get short-term retrieval count
 
-    long_term=LongService(end_user_id)
-    long_result=long_term.get_long_databasets()
+    # Retrieve long-term memory data and aggregations
+    long_term = LongService(end_user_id, db)
+    long_result = long_term.get_long_databasets()     # Get long-term memory entries
 
+    # Get entity count for the specified end user
     entity_result = await search_entity(end_user_id)
+    
+    # Compile comprehensive memory statistics response
     result = {
-        'short_term': short_result,
-        'long_term': long_result,
-        'entity': entity_result.get('num', 0),
-        "retrieval_number":short_count,
-        "long_term_number":len(long_result)
+        'short_term': short_result,                    # Short-term memory entries
+        'long_term': long_result,                      # Long-term memory data
+        'entity': entity_result.get('num', 0),        # Entity count (default to 0 if not found)
+        "retrieval_number": short_count,               # Short-term retrieval statistics
+        "long_term_number": len(long_result)          # Long-term memory entry count
     }
 
     return success(data=result, msg="短期记忆系统数据获取成功")

api/app/controllers/memory_storage_controller.py

@@ -2,7 +2,7 @@ from typing import Optional
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, Query
-from fastapi.responses import StreamingResponse
+from fastapi.responses import StreamingResponse, JSONResponse
 from sqlalchemy.orm import Session
 
 from app.core.error_codes import BizCode
@@ -85,6 +85,7 @@ 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:
     workspace_id = current_user.current_workspace_id
     # 检查用户是否已选择工作空间
@@ -99,7 +100,29 @@ 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))
 
@@ -521,10 +544,11 @@ 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:
-    api_logger.info("Recent activity stats requested")
+) -> 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}")
     try:
-        result = await analytics_recent_activity_stats()
+        result = await analytics_recent_activity_stats(workspace_id=workspace_id)
         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

@@ -371,6 +371,11 @@ def update_model(
 
     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}")
@@ -469,7 +474,9 @@ async def create_model_api_key_by_provider(
             config=api_key_data.config,
             is_active=api_key_data.is_active,
             priority=api_key_data.priority,
-            model_config_ids=model_config_ids
+            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/app/controllers/ontology_controller.py

@@ -25,13 +25,13 @@ from typing import Dict, Optional, List
 from urllib.parse import quote
 
 from fastapi import APIRouter, Depends, HTTPException, File, UploadFile, Form, Header
-from fastapi.responses import StreamingResponse
+from fastapi.responses import StreamingResponse, JSONResponse
 from sqlalchemy.orm import Session
 
 from app.core.config import settings
 from app.core.error_codes import BizCode
 from app.core.language_utils import get_language_from_header
-from app.core.logging_config import get_api_logger
+from app.core.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
@@ -61,6 +61,7 @@ from app.repositories.ontology_scene_repository import OntologySceneRepository
 
 
 api_logger = get_api_logger()
+business_logger = get_business_logger()
 logger = logging.getLogger(__name__)
 
 router = APIRouter(
@@ -123,15 +124,23 @@ def _get_ontology_service(
             )
         
         # 通过 Repository 获取可用的 API Key（负载均衡逻辑由 Repository 处理）
-        from app.repositories.model_repository import ModelApiKeyRepository
-        api_keys = ModelApiKeyRepository.get_by_model_config(db, model_config.id)
-        if not api_keys:
+        # from app.repositories.model_repository import ModelApiKeyRepository
+        from app.services.model_service import ModelApiKeyService
+        api_key_config = ModelApiKeyService.get_available_api_key(db, model_config.id)
+        if not api_key_config:
             logger.error(f"Model {llm_id} has no active API key")
             raise HTTPException(
                 status_code=400,
                 detail="指定的LLM模型没有可用的API密钥"
             )
-        api_key_config = api_keys[0]
+        # api_keys = ModelApiKeyRepository.get_by_model_config(db, model_config.id)
+        # if not api_keys:
+        #     logger.error(f"Model {llm_id} has no active API key")
+        #     raise HTTPException(
+        #         status_code=400,
+        #         detail="指定的LLM模型没有可用的API密钥"
+        #     )
+        # api_key_config = api_keys[0]
         
         is_composite = getattr(model_config, 'is_composite', False)
         logger.info(
@@ -153,6 +162,7 @@ def _get_ontology_service(
             provider=actual_provider,
             api_key=api_key_config.api_key,
             base_url=api_key_config.api_base,
+            is_omni=api_key_config.is_omni,
             max_retries=3,
             timeout=60.0
         )
@@ -279,7 +289,8 @@ async def extract_ontology(
 async def create_scene(
     request: SceneCreateRequest,
     db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
+    current_user: User = Depends(get_current_user),
+    x_language_type: Optional[str] = Header(None, alias="X-Language-Type")
 ):
     """创建本体场景
     
@@ -350,8 +361,18 @@ async def create_scene(
         return fail(BizCode.BAD_REQUEST, "请求参数无效", str(e))
         
     except RuntimeError as e:
-        api_logger.error(f"Runtime error in scene creation: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "场景创建失败", str(e))
+        err_str = str(e)
+        if "UniqueViolation" in err_str or "uq_workspace_scene_name" in err_str:
+            api_logger.warning(f"Duplicate scene name '{request.scene_name}' in workspace {current_user.current_workspace_id}")
+            from app.core.language_utils import get_language_from_header
+            lang = get_language_from_header(x_language_type)
+            if lang == "en":
+                msg = fail(BizCode.BAD_REQUEST, "Scene name already exists", f"A scene named \"{request.scene_name}\" already exists in the current workspace. Please use a different name.")
+            else:
+                msg = fail(BizCode.BAD_REQUEST, "场景名称已存在", f"当前工作空间下已存在名为「{request.scene_name}」的场景，请使用其他名称")
+            return JSONResponse(status_code=400, content=msg)
+        api_logger.error(f"Runtime error in scene creation: {err_str}", exc_info=True)
+        return fail(BizCode.INTERNAL_ERROR, "场景创建失败", err_str)
         
     except Exception as e:
         api_logger.error(f"Unexpected error in scene creation: {str(e)}", exc_info=True)
@@ -399,6 +420,20 @@ async def update_scene(
             api_logger.warning(f"User {current_user.id} has no current workspace")
             return fail(BizCode.BAD_REQUEST, "请求参数无效", "当前用户没有工作空间")
         
+        # 检查是否为系统默认场景
+        scene_repo = OntologySceneRepository(db)
+        scene = scene_repo.get_by_id(scene_uuid)
+        if scene and scene.is_system_default:
+            business_logger.warning(
+                f"尝试修改系统默认场景: user_id={current_user.id}, "
+                f"scene_id={scene_id}, scene_name={scene.scene_name}"
+            )
+            return fail(
+                BizCode.BAD_REQUEST,
+                "系统默认场景不可修改",
+                "该场景为系统预设场景，不允许修改"
+            )
+        
         # 创建OntologyService实例
         from app.core.memory.llm_tools.openai_client import OpenAIClient
         from app.core.models.base import RedBearModelConfig
@@ -491,6 +526,19 @@ async def delete_scene(
             api_logger.warning(f"User {current_user.id} has no current workspace")
             return fail(BizCode.BAD_REQUEST, "请求参数无效", "当前用户没有工作空间")
         
+        # 检查是否为系统默认场景
+        scene_repo = OntologySceneRepository(db)
+        scene = scene_repo.get_by_id(scene_uuid)
+        if scene and scene.is_system_default:
+            business_logger.warning(
+                f"尝试删除系统默认场景: user_id={current_user.id}, "
+                f"scene_id={scene_id}, scene_name={scene.scene_name}"
+            )
+            raise HTTPException(
+                status_code=400,
+                detail="SYSTEM_DEFAULT_SCENE_CANNOT_DELETE"
+            )
+        
         # 创建OntologyService实例
         from app.core.memory.llm_tools.openai_client import OpenAIClient
         from app.core.models.base import RedBearModelConfig
@@ -514,6 +562,9 @@ async def delete_scene(
         
         return success(data={"deleted": success_flag}, msg="场景删除成功")
         
+    except HTTPException:
+        raise
+
     except ValueError as e:
         api_logger.warning(f"Validation error in scene deletion: {str(e)}")
         return fail(BizCode.BAD_REQUEST, "请求参数无效", str(e))
@@ -621,7 +672,8 @@ async def get_scenes(
 async def create_class(
     request: ClassCreateRequest,
     db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
+    current_user: User = Depends(get_current_user),
+    x_language_type: Optional[str] = Header(None, alias="X-Language-Type")
 ):
     """创建本体类型
     
@@ -636,7 +688,7 @@ async def create_class(
         ApiResponse: 包含创建的类型信息
     """
     from app.controllers.ontology_secondary_routes import create_class_handler
-    return await create_class_handler(request, db, current_user)
+    return await create_class_handler(request, db, current_user, x_language_type)
 
 
 @router.put("/class/{class_id}", response_model=ApiResponse)

api/app/controllers/ontology_secondary_routes.py

@@ -7,11 +7,11 @@
 from uuid import UUID
 from typing import Optional
 
-from fastapi import Depends
+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
+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
@@ -30,9 +30,11 @@ 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:
@@ -56,7 +58,7 @@ async def scenes_handler(
     workspace_id: Optional[str] = None,
     scene_name: Optional[str] = None,
     page: Optional[int] = None,
-    page_size: Optional[int] = None,
+    pagesize: Optional[int] = None,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user)
 ):
@@ -69,14 +71,14 @@ async def scenes_handler(
         workspace_id: 工作空间ID（可选，默认当前用户工作空间）
         scene_name: 场景名称关键词（可选，支持模糊匹配）
         page: 页码（可选，从1开始，仅在全量查询时有效）
-        page_size: 每页数量（可选，仅在全量查询时有效）
+        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}, page_size={page_size}"
+        f"workspace_id={workspace_id}, keyword={scene_name}, page={page}, pagesize={pagesize}"
     )
     
     try:
@@ -103,13 +105,13 @@ async def scenes_handler(
                 api_logger.warning(f"Invalid page number: {page}")
                 return fail(BizCode.BAD_REQUEST, "请求参数无效", "页码必须大于0")
             
-            if page_size is not None and page_size < 1:
-                api_logger.warning(f"Invalid page_size: {page_size}")
+            if pagesize is not None and pagesize < 1:
+                api_logger.warning(f"Invalid pagesize: {pagesize}")
                 return fail(BizCode.BAD_REQUEST, "请求参数无效", "每页数量必须大于0")
             
-            # 如果只提供了page或page_size中的一个，返回错误
-            if (page is not None and page_size is None) or (page is None and page_size is not None):
-                api_logger.warning(f"Incomplete pagination params: page={page}, page_size={page_size}")
+            # 如果只提供了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必须同时提供")
             
             # 模糊搜索场景（支持分页）
@@ -117,17 +119,15 @@ async def scenes_handler(
             total = len(scenes)
             
             # 如果提供了分页参数，进行分页处理
-            if page is not None and page_size is not None:
-                start_idx = (page - 1) * page_size
-                end_idx = start_idx + page_size
+            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:
-                # 获取前3个class_name作为entity_type
                 entity_type = [cls.class_name for cls in scene.classes[:3]] if scene.classes else None
-                # 动态计算 type_num
                 type_num = len(scene.classes) if scene.classes else 0
                 
                 items.append(SceneResponse(
@@ -139,17 +139,16 @@ async def scenes_handler(
                     workspace_id=scene.workspace_id,
                     created_at=scene.created_at,
                     updated_at=scene.updated_at,
-                    classes_count=type_num
+                    classes_count=type_num,
+                    is_system_default=scene.is_system_default
                 ))
             
             # 构建响应（包含分页信息）
-            if page is not None and page_size is not None:
-                # 计算是否有下一页
-                hasnext = (page * page_size) < total
-                
+            if page is not None and pagesize is not None:
+                hasnext = (page * pagesize) < total
                 pagination_info = PaginationInfo(
                     page=page,
-                    pagesize=page_size,
+                    pagesize=pagesize,
                     total=total,
                     hasnext=hasnext
                 )
@@ -163,28 +162,25 @@ async def scenes_handler(
             )
         else:
             # 获取所有场景（支持分页）
-            # 验证分页参数
             if page is not None and page < 1:
                 api_logger.warning(f"Invalid page number: {page}")
                 return fail(BizCode.BAD_REQUEST, "请求参数无效", "页码必须大于0")
             
-            if page_size is not None and page_size < 1:
-                api_logger.warning(f"Invalid page_size: {page_size}")
+            if pagesize is not None and pagesize < 1:
+                api_logger.warning(f"Invalid pagesize: {pagesize}")
                 return fail(BizCode.BAD_REQUEST, "请求参数无效", "每页数量必须大于0")
             
-            # 如果只提供了page或page_size中的一个，返回错误
-            if (page is not None and page_size is None) or (page is None and page_size is not None):
-                api_logger.warning(f"Incomplete pagination params: page={page}, page_size={page_size}")
+            # 如果只提供了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, page_size)
+            scenes, total = service.list_scenes(ws_uuid, page, pagesize)
             
             # 构建响应
             items = []
             for scene in scenes:
-                # 获取前3个class_name作为entity_type
                 entity_type = [cls.class_name for cls in scene.classes[:3]] if scene.classes else None
-                # 动态计算 type_num
                 type_num = len(scene.classes) if scene.classes else 0
                 
                 items.append(SceneResponse(
@@ -196,17 +192,16 @@ async def scenes_handler(
                     workspace_id=scene.workspace_id,
                     created_at=scene.created_at,
                     updated_at=scene.updated_at,
-                    classes_count=type_num
+                    classes_count=type_num,
+                    is_system_default=scene.is_system_default
                 ))
             
             # 构建响应（包含分页信息）
-            if page is not None and page_size is not None:
-                # 计算是否有下一页
-                hasnext = (page * page_size) < total
-                
+            if page is not None and pagesize is not None:
+                hasnext = (page * pagesize) < total
                 pagination_info = PaginationInfo(
                     page=page,
-                    pagesize=page_size,
+                    pagesize=pagesize,
                     total=total,
                     hasnext=hasnext
                 )
@@ -236,7 +231,8 @@ async def scenes_handler(
 async def create_class_handler(
     request: ClassCreateRequest,
     db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user)
+    current_user: User = Depends(get_current_user),
+    x_language_type: Optional[str] = None
 ):
     """创建本体类型（统一使用列表形式，支持单个或批量）"""
     
@@ -269,8 +265,11 @@ async def create_class_handler(
         ]
         
         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"],
@@ -328,12 +327,36 @@ async def create_class_handler(
             return success(data=response.model_dump(mode='json'), msg="批量创建完成")
         
     except ValueError as e:
-        api_logger.warning(f"Validation error in class creation: {str(e)}")
-        return fail(BizCode.BAD_REQUEST, "请求参数无效", str(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:
-        api_logger.error(f"Runtime error in class creation: {str(e)}", exc_info=True)
-        return fail(BizCode.INTERNAL_ERROR, "类型创建失败", str(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)
@@ -366,6 +389,20 @@ async def update_class_handler(
             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)
         
@@ -429,6 +466,20 @@ async def delete_class_handler(
             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)
         
@@ -585,6 +636,7 @@ async def classes_handler(
             scene_id=scene_uuid,
             scene_name=scene.scene_name,
             scene_description=scene.scene_description,
+            is_system_default=scene.is_system_default,
             items=items
         )
         

api/app/controllers/public_share_controller.py

@@ -2,25 +2,32 @@ 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
+from app.core.response_utils import success, fail
 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.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, \
+from app.services.workflow_service import WorkflowService
+from app.utils.app_config_utils import workflow_config_4_app_release, \
     agent_config_4_app_release, multi_agent_config_4_app_release
 
 router = APIRouter(prefix="/public/share", tags=["Public Share"])
@@ -206,15 +213,13 @@ 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)
-    from app.repositories.end_user_repository import EndUserRepository
+    share, release = service.get_release_by_share_token(share_data.share_token, password)
     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),
@@ -293,19 +298,15 @@ 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,
@@ -318,7 +319,6 @@ 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 == "agent":
+        if app_type == AppType.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 == "multi_agent":
+        elif app_type == AppType.MULTI_AGENT:
             # Multi-Agent 类型：验证多 Agent 配置
             config = release.config or {}
             if not config.get("sub_agents"):
@@ -638,6 +638,34 @@ 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

@@ -89,7 +89,6 @@ async def chat(
     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
@@ -135,7 +134,8 @@ async def chat(
         app_id=app.id,
         workspace_id=workspace_id,
         user_id=end_user_id,
-        is_draft=False
+        is_draft=False,
+        conversation_id=payload.conversation_id
     )
 
     if app_type == AppType.AGENT:
@@ -249,6 +249,7 @@ async def chat(
                         app_id=app.id,
                         workspace_id=workspace_id,
                         release_id=app.current_release.id,
+                        public=True
                 ):
                     event_type = event.get("event", "message")
                     event_data = event.get("data", {})

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}, tenant_id: {api_key_auth.tenant_id}")
+    logger.info(f"Memory write request - end_user_id: {payload.end_user_id}, workspace_id: {api_key_auth.workspace_id}")
     
     memory_api_service = MemoryAPIService(db)
     

api/app/controllers/tool_controller.py

@@ -14,6 +14,7 @@ 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"])
 
@@ -97,7 +98,13 @@ async def create_tool(
 ):
     """创建工具"""
     try:
-        tool_id = service.create_tool(
+        # 将 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(
             name=request.name,
             tool_type=request.tool_type,
             tenant_id=current_user.tenant_id,
@@ -107,6 +114,8 @@ 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

@@ -1,6 +1,7 @@
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 import uuid
+from typing import Callable
 
 from app.core.error_codes import BizCode
 from app.core.exceptions import BusinessException
@@ -19,6 +20,7 @@ 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
+from app.i18n.dependencies import get_translator
 
 # 获取API专用日志器
 api_logger = get_api_logger()
@@ -33,7 +35,8 @@ router = APIRouter(
 def create_superuser(
     user: user_schema.UserCreate,
     db: Session = Depends(get_db),
-    current_superuser: User = Depends(get_current_superuser)
+    current_superuser: User = Depends(get_current_superuser),
+    t: Callable = Depends(get_translator)
 ):
     """创建超级管理员（仅超级管理员可访问）"""
     api_logger.info(f"超级管理员创建请求: {user.username}, email: {user.email}")
@@ -42,7 +45,7 @@ def create_superuser(
     api_logger.info(f"超级管理员创建成功: {result.username} (ID: {result.id})")
     
     result_schema = user_schema.User.model_validate(result)
-    return success(data=result_schema, msg="超级管理员创建成功")
+    return success(data=result_schema, msg=t("users.create.superuser_success"))
 
 
 @router.delete("/{user_id}", response_model=ApiResponse)
@@ -50,6 +53,7 @@ def delete_user(
     user_id: uuid.UUID,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    t: Callable = Depends(get_translator)
 ):
     """停用用户（软删除）"""
     api_logger.info(f"用户停用请求: user_id={user_id}, 操作者: {current_user.username}")
@@ -57,13 +61,14 @@ def delete_user(
         db=db, user_id_to_deactivate=user_id, current_user=current_user
     )
     api_logger.info(f"用户停用成功: {result.username} (ID: {result.id})")
-    return success(msg="用户停用成功")
+    return success(msg=t("users.delete.deactivate_success"))
 
 @router.post("/{user_id}/activate", response_model=ApiResponse)
 def activate_user(
     user_id: uuid.UUID,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    t: Callable = Depends(get_translator)
 ):
     """激活用户"""
     api_logger.info(f"用户激活请求: user_id={user_id}, 操作者: {current_user.username}")
@@ -74,13 +79,14 @@ def activate_user(
     api_logger.info(f"用户激活成功: {result.username} (ID: {result.id})")
     
     result_schema = user_schema.User.model_validate(result)
-    return success(data=result_schema, msg="用户激活成功")
+    return success(data=result_schema, msg=t("users.activate.success"))
 
 
 @router.get("", response_model=ApiResponse)
 def get_current_user_info(
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    t: Callable = Depends(get_translator)
 ):
     """获取当前用户信息"""
     api_logger.info(f"当前用户信息请求: {current_user.username}")
@@ -105,7 +111,7 @@ def get_current_user_info(
                 break
     
     api_logger.info(f"当前用户信息获取成功: {result.username}, 角色: {result_schema.role}, 工作空间: {result_schema.current_workspace_name}")
-    return success(data=result_schema, msg="用户信息获取成功")
+    return success(data=result_schema, msg=t("users.info.get_success"))
 
 
 @router.get("/superusers", response_model=ApiResponse)
@@ -113,6 +119,7 @@ def get_tenant_superusers(
     include_inactive: bool = False,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_superuser),
+    t: Callable = Depends(get_translator)
 ):
     """获取当前租户下的超管账号列表（仅超级管理员可访问）"""
     api_logger.info(f"获取租户超管列表请求: {current_user.username}")
@@ -125,7 +132,7 @@ def get_tenant_superusers(
     api_logger.info(f"租户超管列表获取成功: count={len(superusers)}")
     
     superusers_schema = [user_schema.User.model_validate(u) for u in superusers]
-    return success(data=superusers_schema, msg="租户超管列表获取成功")
+    return success(data=superusers_schema, msg=t("users.list.superusers_success"))
 
 
 
@@ -134,6 +141,7 @@ def get_user_info_by_id(
     user_id: uuid.UUID,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    t: Callable = Depends(get_translator)
 ):
     """根据用户ID获取用户信息"""
     api_logger.info(f"获取用户信息请求: user_id={user_id}, 操作者: {current_user.username}")
@@ -144,7 +152,7 @@ def get_user_info_by_id(
     api_logger.info(f"用户信息获取成功: {result.username}")
     
     result_schema = user_schema.User.model_validate(result)
-    return success(data=result_schema, msg="用户信息获取成功")
+    return success(data=result_schema, msg=t("users.info.get_success"))
 
 
 @router.put("/change-password", response_model=ApiResponse)
@@ -152,6 +160,7 @@ async def change_password(
     request: ChangePasswordRequest,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    t: Callable = Depends(get_translator)
 ):
     """修改当前用户密码"""
     api_logger.info(f"用户密码修改请求: {current_user.username}")
@@ -164,7 +173,7 @@ async def change_password(
         current_user=current_user
     )
     api_logger.info(f"用户密码修改成功: {current_user.username}")
-    return success(msg="密码修改成功")
+    return success(msg=t("auth.password.change_success"))
 
 
 @router.put("/admin/change-password", response_model=ApiResponse)
@@ -172,6 +181,7 @@ async def admin_change_password(
     request: AdminChangePasswordRequest,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_superuser),
+    t: Callable = Depends(get_translator)
 ):
     """超级管理员修改指定用户的密码"""
     api_logger.info(f"管理员密码修改请求: 管理员 {current_user.username} 修改用户 {request.user_id}")
@@ -186,16 +196,17 @@ async def admin_change_password(
     # 根据是否生成了随机密码来构造响应
     if request.new_password:
         api_logger.info(f"管理员密码修改成功: 用户 {request.user_id}")
-        return success(msg="密码修改成功")
+        return success(msg=t("auth.password.change_success"))
     else:
         api_logger.info(f"管理员密码重置成功: 用户 {request.user_id}, 随机密码已生成")
-        return success(data=generated_password, msg="密码重置成功")
+        return success(data=generated_password, msg=t("auth.password.reset_success"))
 
 
 @router.post("/verify_pwd", response_model=ApiResponse)
 def verify_pwd(
     request: VerifyPasswordRequest,
     current_user: User = Depends(get_current_user),
+    t: Callable = Depends(get_translator)
 ):
     """验证当前用户密码"""
     api_logger.info(f"用户验证密码请求: {current_user.username}")
@@ -203,8 +214,8 @@ def verify_pwd(
     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="验证完成")
+        raise BusinessException(t("users.errors.password_verification_failed"), code=BizCode.VALIDATION_FAILED)
+    return success(data={"valid": is_valid}, msg=t("common.success.retrieved"))
 
 
 @router.post("/send-email-code", response_model=ApiResponse)
@@ -212,6 +223,7 @@ async def send_email_code(
     request: SendEmailCodeRequest,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    t: Callable = Depends(get_translator)
 ):
     """发送邮箱验证码"""
     api_logger.info(f"用户请求发送邮箱验证码: {current_user.username}, email={request.email}")
@@ -219,7 +231,7 @@ async def send_email_code(
     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="验证码已发送到您的邮箱，请查收")
+    return success(msg=t("users.email.code_sent"))
 
 
 @router.put("/change-email", response_model=ApiResponse)
@@ -227,6 +239,7 @@ async def change_email(
     request: VerifyEmailCodeRequest,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    t: Callable = Depends(get_translator)
 ):
     """验证验证码并修改邮箱"""
     api_logger.info(f"用户修改邮箱: {current_user.username}, new_email={request.new_email}")
@@ -239,4 +252,51 @@ async def change_email(
     )
     
     api_logger.info(f"用户邮箱修改成功: {current_user.username}")
-    return success(msg="邮箱修改成功")
+    return success(msg=t("users.email.change_success"))
+
+
+
+@router.get("/me/language", response_model=ApiResponse)
+def get_current_user_language(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+    t: Callable = Depends(get_translator)
+):
+    """获取当前用户的语言偏好"""
+    api_logger.info(f"获取用户语言偏好: {current_user.username}")
+    
+    language = user_service.get_user_language_preference(
+        db=db,
+        user_id=current_user.id,
+        current_user=current_user
+    )
+    
+    api_logger.info(f"用户语言偏好获取成功: {current_user.username}, language={language}")
+    return success(
+        data=user_schema.LanguagePreferenceResponse(language=language),
+        msg=t("users.language.get_success")
+    )
+
+
+@router.put("/me/language", response_model=ApiResponse)
+def update_current_user_language(
+    request: user_schema.LanguagePreferenceRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+    t: Callable = Depends(get_translator)
+):
+    """设置当前用户的语言偏好"""
+    api_logger.info(f"更新用户语言偏好: {current_user.username}, language={request.language}")
+    
+    updated_user = user_service.update_user_language_preference(
+        db=db,
+        user_id=current_user.id,
+        language=request.language,
+        current_user=current_user
+    )
+    
+    api_logger.info(f"用户语言偏好更新成功: {current_user.username}, language={request.language}")
+    return success(
+        data=user_schema.LanguagePreferenceResponse(language=updated_user.preferred_language),
+        msg=t("users.language.update_success")
+    )

api/app/controllers/user_memory_controllers.py

@@ -17,6 +17,7 @@ from app.services.user_memory_service import (
     UserMemoryService,
     analytics_memory_types,
     analytics_graph_data,
+    analytics_community_graph_data,
 )
 from app.services.memory_entity_relationship_service import MemoryEntityService,MemoryEmotion,MemoryInteraction
 from app.schemas.response_schema import ApiResponse
@@ -295,6 +296,42 @@ async def get_graph_data_api(
         return fail(BizCode.INTERNAL_ERROR, "图数据查询失败", str(e))
 
 
+@router.get("/analytics/community_graph", response_model=ApiResponse)
+async def get_community_graph_data_api(
+    end_user_id: str,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+) -> dict:
+    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")
+
+    api_logger.info(
+        f"社区图谱查询请求: end_user_id={end_user_id}, user={current_user.username}, "
+        f"workspace={workspace_id}"
+    )
+
+    try:
+        result = await analytics_community_graph_data(db=db, end_user_id=end_user_id)
+
+        if "message" in result and result["statistics"]["total_nodes"] == 0:
+            api_logger.warning(f"社区图谱查询返回空结果: {result.get('message')}")
+            return success(data=result, msg=result.get("message", "查询成功"))
+
+        api_logger.info(
+            f"成功获取社区图谱: end_user_id={end_user_id}, "
+            f"nodes={result['statistics']['total_nodes']}, "
+            f"edges={result['statistics']['total_edges']}"
+        )
+        return success(data=result, msg="查询成功")
+
+    except Exception as e:
+        api_logger.error(f"社区图谱查询失败: end_user_id={end_user_id}, error={str(e)}")
+        return fail(BizCode.INTERNAL_ERROR, "社区图谱查询失败", str(e))
+
+
 @router.get("/read_end_user/profile", response_model=ApiResponse)
 async def get_end_user_profile(
     end_user_id: str,

api/app/controllers/workspace_controller.py

@@ -1,7 +1,7 @@
 import uuid
 from typing import List, Optional
 
-from fastapi import APIRouter, Depends, HTTPException, Query, status
+from fastapi import APIRouter, Depends, Header, HTTPException, Query, status
 from sqlalchemy.orm import Session
 
 from app.core.logging_config import get_api_logger
@@ -14,6 +14,12 @@ from app.dependencies import (
     get_current_user,
     workspace_access_guard,
 )
+from app.i18n.dependencies import get_current_language, get_translator
+from app.i18n.serializers import (
+    WorkspaceSerializer,
+    WorkspaceMemberSerializer,
+    WorkspaceInviteSerializer
+)
 from app.models.tenant_model import Tenants
 from app.models.user_model import User
 from app.models.workspace_model import InviteStatus
@@ -65,7 +71,9 @@ def get_workspaces(
     include_current: bool = Query(True, description="是否包含当前工作空间"),
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
-    current_tenant: Tenants = Depends(get_current_tenant)
+    current_tenant: Tenants = Depends(get_current_tenant),
+    language: str = Depends(get_current_language),
+    t: callable = Depends(get_translator)
 ):
     """获取当前租户下用户参与的所有工作空间
 
@@ -88,25 +96,50 @@ def get_workspaces(
         )
 
     api_logger.info(f"成功获取 {len(workspaces)} 个工作空间")
-    workspaces_schema = [WorkspaceResponse.model_validate(w) for w in workspaces]
-    return success(data=workspaces_schema, msg="工作空间列表获取成功")
+    
+    # 使用序列化器添加国际化字段
+    serializer = WorkspaceSerializer()
+    workspaces_data = [WorkspaceResponse.model_validate(w).model_dump() for w in workspaces]
+    workspaces_i18n = serializer.serialize_list(workspaces_data, language)
+    
+    return success(data=workspaces_i18n, msg=t("workspace.list_retrieved"))
 
 
 @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),
+    language: str = Depends(get_current_language),
+    t: callable = Depends(get_translator)
 ):
     """创建新的工作空间"""
-    api_logger.info(f"用户 {current_user.username} 请求创建工作空间: {workspace.name}")
+    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}"
+    )
 
     result = workspace_service.create_workspace(
-        db=db, workspace=workspace, user=current_user)
+        db=db, workspace=workspace, user=current_user, 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_logger.info(
+        f"工作空间创建成功 - 名称: {workspace.name}, ID: {result.id}, "
+        f"创建者: {current_user.username}, language={language}"
+    )
+    
+    # 使用序列化器添加国际化字段
+    serializer = WorkspaceSerializer()
+    result_data = WorkspaceResponse.model_validate(result).model_dump()
+    result_i18n = serializer.serialize(result_data, language)
+    
+    return success(data=result_i18n, msg=t("workspace.created"))
 
 @router.put("", response_model=ApiResponse)
 @cur_workspace_access_guard()
@@ -114,6 +147,8 @@ def update_workspace(
     workspace: WorkspaceUpdate,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    language: str = Depends(get_current_language),
+    t: callable = Depends(get_translator)
 ):
     """更新工作空间"""
     workspace_id = current_user.current_workspace_id
@@ -126,14 +161,21 @@ def update_workspace(
         user=current_user,
     )
     api_logger.info(f"工作空间更新成功 - ID: {workspace_id}, 用户: {current_user.username}")
-    result_schema = WorkspaceResponse.model_validate(result)
-    return success(data=result_schema, msg="工作空间更新成功")
+    
+    # 使用序列化器添加国际化字段
+    serializer = WorkspaceSerializer()
+    result_data = WorkspaceResponse.model_validate(result).model_dump()
+    result_i18n = serializer.serialize(result_data, language)
+    
+    return success(data=result_i18n, msg=t("workspace.updated"))
 
 @router.get("/members", response_model=ApiResponse)
 @cur_workspace_access_guard()
 def get_cur_workspace_members(
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    language: str = Depends(get_current_language),
+    t: callable = Depends(get_translator)
 ):
     """获取工作空间成员列表（关系序列化）"""
     api_logger.info(f"用户 {current_user.username} 请求获取工作空间 {current_user.current_workspace_id} 的成员列表")
@@ -144,8 +186,14 @@ def get_cur_workspace_members(
         user=current_user,
     )
     api_logger.info(f"工作空间成员列表获取成功 - ID: {current_user.current_workspace_id}, 数量: {len(members)}")
+    
+    # 转换为表格项并使用序列化器添加国际化字段
     table_items = _convert_members_to_table_items(members)
-    return success(data=table_items, msg="工作空间成员列表获取成功")
+    serializer = WorkspaceMemberSerializer()
+    members_data = [item.model_dump() for item in table_items]
+    members_i18n = serializer.serialize_list(members_data, language)
+    
+    return success(data=members_i18n, msg=t("workspace.members.list_retrieved"))
 
 
 @router.put("/members", response_model=ApiResponse)
@@ -155,6 +203,7 @@ def update_workspace_members(
     updates: List[WorkspaceMemberUpdate],
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    t: callable = Depends(get_translator)
 ):
     workspace_id = current_user.current_workspace_id
     api_logger.info(f"用户 {current_user.username} 请求更新工作空间 {workspace_id} 的成员角色")
@@ -165,7 +214,7 @@ def update_workspace_members(
         user=current_user,
     )
     api_logger.info(f"工作空间成员角色更新成功 - ID: {workspace_id}, 数量: {len(members)}")
-    return success(msg="成员角色更新成功")
+    return success(msg=t("workspace.members.role_updated"))
 
 
 @router.delete("/members/{member_id}", response_model=ApiResponse)
@@ -174,6 +223,7 @@ def delete_workspace_member(
     member_id: uuid.UUID,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    t: callable = Depends(get_translator)
 ):
     workspace_id = current_user.current_workspace_id
     api_logger.info(f"用户 {current_user.username} 请求删除工作空间 {workspace_id} 的成员 {member_id}")
@@ -185,7 +235,7 @@ def delete_workspace_member(
         user=current_user,
     )
     api_logger.info(f"工作空间成员删除成功 - ID: {workspace_id}, 成员: {member_id}")
-    return success(msg="成员删除成功")
+    return success(msg=t("workspace.members.deleted"))
 
 
 # 创建空间协作邀请
@@ -195,6 +245,8 @@ def create_workspace_invite(
     invite_data: WorkspaceInviteCreate,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    language: str = Depends(get_current_language),
+    t: callable = Depends(get_translator)
 ):
     """创建工作空间邀请"""
     workspace_id = current_user.current_workspace_id
@@ -207,7 +259,12 @@ def create_workspace_invite(
         user=current_user
     )
     api_logger.info(f"工作空间邀请创建成功 - 工作空间: {workspace_id}, 邮箱: {invite_data.email}")
-    return success(data=result, msg="邀请创建成功")
+    
+    # 使用序列化器添加国际化字段
+    serializer = WorkspaceInviteSerializer()
+    result_i18n = serializer.serialize(result, language)
+    
+    return success(data=result_i18n, msg=t("workspace.invites.created"))
 
 
 @router.get("/invites", response_model=ApiResponse)
@@ -219,6 +276,8 @@ def get_workspace_invites(
     offset: int = Query(0, ge=0),
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    language: str = Depends(get_current_language),
+    t: callable = Depends(get_translator)
 ):
     """获取工作空间邀请列表"""
     workspace_id = current_user.current_workspace_id
@@ -233,18 +292,30 @@ def get_workspace_invites(
         offset=offset
     )
     api_logger.info(f"成功获取 {len(invites)} 个邀请记录")
-    return success(data=invites, msg="邀请列表获取成功")
+    
+    # 使用序列化器添加国际化字段
+    serializer = WorkspaceInviteSerializer()
+    invites_i18n = serializer.serialize_list(invites, language)
+    
+    return success(data=invites_i18n, msg=t("workspace.invites.list_retrieved"))
 
 
 @public_router.get("/invites/validate/{token}", response_model=ApiResponse)
 def get_workspace_invite_info(
     token: str,
     db: Session = Depends(get_db),
+    language: str = Depends(get_current_language),
+    t: callable = Depends(get_translator)
 ):
     """获取工作空间邀请用户信息（无需认证）"""
     result = workspace_service.validate_invite_token(db=db, token=token)
     api_logger.info(f"工作空间邀请验证成功 - 邀请: {token}")
-    return success(data=result, msg="邀请验证成功")
+    
+    # 使用序列化器添加国际化字段
+    serializer = WorkspaceInviteSerializer()
+    result_i18n = serializer.serialize(result, language)
+    
+    return success(data=result_i18n, msg=t("workspace.invites.validated"))
 
 
 @router.delete("/invites/{invite_id}", response_model=ApiResponse)
@@ -254,6 +325,8 @@ def revoke_workspace_invite(
     invite_id: uuid.UUID,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    language: str = Depends(get_current_language),
+    t: callable = Depends(get_translator)
 ):
     """撤销工作空间邀请"""
     workspace_id = current_user.current_workspace_id
@@ -266,7 +339,12 @@ def revoke_workspace_invite(
         user=current_user
     )
     api_logger.info(f"工作空间邀请撤销成功 - 邀请: {invite_id}")
-    return success(data=result, msg="邀请撤销成功")
+    
+    # 使用序列化器添加国际化字段
+    serializer = WorkspaceInviteSerializer()
+    result_i18n = serializer.serialize(result, language)
+    
+    return success(data=result_i18n, msg=t("workspace.invites.revoked"))
 
 # ==================== 公开邀请接口（无需认证） ====================
 
@@ -289,6 +367,7 @@ def switch_workspace(
     workspace_id: uuid.UUID,
     db: Session = Depends(get_db),
     current_user: User = Depends(get_current_user),
+    t: callable = Depends(get_translator)
 ):
     """切换工作空间"""
     api_logger.info(f"用户 {current_user.username} 请求切换工作空间为 {workspace_id}")
@@ -299,7 +378,7 @@ def switch_workspace(
         user=current_user,
     )
     api_logger.info(f"成功切换工作空间为 {workspace_id}")
-    return success(msg="工作空间切换成功")
+    return success(msg=t("workspace.switched"))
 
 
 @router.get("/storage", response_model=ApiResponse)
@@ -307,6 +386,7 @@ def switch_workspace(
 def get_workspace_storage_type(
         db: Session = Depends(get_db),
         current_user: User = Depends(get_current_user),
+        t: callable = Depends(get_translator)
 ):
     """获取当前工作空间的存储类型"""
     workspace_id = current_user.current_workspace_id
@@ -318,7 +398,7 @@ def get_workspace_storage_type(
         user=current_user
     )
     api_logger.info(f"成功获取工作空间 {workspace_id} 的存储类型: {storage_type}")
-    return success(data={"storage_type": storage_type}, msg="存储类型获取成功")
+    return success(data={"storage_type": storage_type}, msg=t("workspace.storage.type_retrieved"))
 
 
 @router.get("/workspace_models", response_model=ApiResponse)
@@ -326,6 +406,8 @@ def get_workspace_storage_type(
 def workspace_models_configs(
         db: Session = Depends(get_db),
         current_user: User = Depends(get_current_user),
+        language: str = Depends(get_current_language),
+        t: callable = Depends(get_translator)
 ):
     """获取当前工作空间的模型配置（llm, embedding, rerank）"""
     workspace_id = current_user.current_workspace_id
@@ -341,14 +423,14 @@ def workspace_models_configs(
         api_logger.warning(f"工作空间 {workspace_id} 不存在或无权访问")
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
-            detail="工作空间不存在或无权访问"
+            detail=t("workspace.not_found")
         )
 
     api_logger.info(
         f"成功获取工作空间 {workspace_id} 的模型配置: "
         f"llm={configs.get('llm')}, embedding={configs.get('embedding')}, rerank={configs.get('rerank')}"
     )
-    return success(data=WorkspaceModelsConfig.model_validate(configs), msg="模型配置获取成功")
+    return success(data=WorkspaceModelsConfig.model_validate(configs), msg=t("workspace.models.config_retrieved"))
 
 
 @router.put("/workspace_models", response_model=ApiResponse)
@@ -357,6 +439,7 @@ def update_workspace_models_configs(
         models_update: WorkspaceModelsUpdate,
         db: Session = Depends(get_db),
         current_user: User = Depends(get_current_user),
+        t: callable = Depends(get_translator)
 ):
     """更新当前工作空间的模型配置（llm, embedding, rerank）"""
     workspace_id = current_user.current_workspace_id
@@ -373,5 +456,5 @@ def update_workspace_models_configs(
         f"成功更新工作空间 {workspace_id} 的模型配置: "
         f"llm={updated_workspace.llm}, embedding={updated_workspace.embedding}, rerank={updated_workspace.rerank}"
     )
-    return success(data=WorkspaceModelsConfig.model_validate(updated_workspace), msg="模型配置更新成功")
+    return success(data=WorkspaceModelsConfig.model_validate(updated_workspace), msg=t("workspace.models.config_updated"))
 

api/app/core/agent/langchain_agent.py

@@ -11,35 +11,37 @@ LangChain Agent 封装
 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.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.models import RedBearLLM, RedBearModelConfig
-from app.models.models_model import ModelType
+from app.models.models_model import ModelType, ModelProvider
 from app.services.memory_agent_service import (
     get_end_user_connected_config,
 )
 from langchain.agents import create_agent
 from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
 from langchain_core.tools import BaseTool
+
 logger = get_business_logger()
 
 
 class LangChainAgent:
 
     def __init__(
-        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,
-        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,
+            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  # 单个工具最大连续调用次数
     ):
         """初始化 LangChain Agent
 
@@ -60,12 +62,13 @@ class LangChainAgent:
         self.provider = provider
         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:
@@ -73,9 +76,9 @@ class LangChainAgent:
             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)}, "
@@ -89,6 +92,7 @@ class LangChainAgent:
             provider=provider,
             api_key=api_key,
             base_url=api_base,
+            is_omni=is_omni,
             extra_params={
                 "temperature": temperature,
                 "max_tokens": max_tokens,
@@ -143,21 +147,22 @@ class LangChainAgent:
         """
         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):
                     """包装后的工具函数，跟踪连续调用次数"""
@@ -168,13 +173,13 @@ class LangChainAgent:
                         # 切换到新工具，重置计数器
                         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(
@@ -185,12 +190,12 @@ class LangChainAgent:
                             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,
@@ -198,17 +203,17 @@ class LangChainAgent:
                 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,
+            files: Optional[List[Dict[str, Any]]] = None
     ) -> List[BaseMessage]:
         """准备消息列表
 
@@ -248,7 +253,7 @@ class LangChainAgent:
             messages.append(HumanMessage(content=user_content))
 
         return messages
-    
+
     def _build_multimodal_content(self, text: str, files: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
         """
         构建多模态消息内容
@@ -261,23 +266,26 @@ class LangChainAgent:
             List[Dict]: 消息内容列表
         """
         # 根据 provider 使用不同的文本格式
-        if self.provider.lower() in ["bedrock", "anthropic"]:
-            # Anthropic/Bedrock: {"type": "text", "text": "..."}
-            content_parts = [{"type": "text", "text": text}]
-        else:
-            # 通义千问等: {"text": "..."}
-            content_parts = [{"text": text}]
-        
+        # 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}]
+
         # 添加文件内容
         # MultimodalService 已经根据 provider 返回了正确格式，直接使用
         content_parts.extend(files)
-        
+
         logger.debug(
             f"构建多模态消息: provider={self.provider}, "
             f"parts={len(content_parts)}, "
             f"files={len(files)}"
         )
-        
+
         return content_parts
 
     async def chat(
@@ -302,7 +310,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
@@ -322,8 +330,8 @@ 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)}')
         try:
             # 准备消息列表（支持多模态）
             messages = self._prepare_messages(message, history, context, files)
@@ -367,14 +375,14 @@ class LangChainAgent:
             # 获取最后的 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
@@ -407,12 +415,13 @@ class LangChainAgent:
                     response_meta = msg.response_metadata if hasattr(msg, 'response_metadata') else None
                     total_tokens = response_meta.get("token_usage", {}).get("total_tokens", 0) if response_meta else 0
                     break
-            
+
             logger.info(f"最终提取的内容长度: {len(content)}")
 
             elapsed_time = time.time() - start_time
             if memory_flag:
-                await write_long_term(storage_type, end_user_id, message_chat, content, user_rag_memory_id, actual_config_id)
+                await write_long_term(storage_type, end_user_id, message_chat, content, user_rag_memory_id,
+                                      actual_config_id)
             response = {
                 "content": content,
                 "model": self.model_name,
@@ -439,16 +448,16 @@ 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,
+            files: Optional[List[Dict[str, Any]]] = None  # 新增：多模态文件
     ) -> AsyncGenerator[str, None]:
         """执行流式对话
 
@@ -482,7 +491,6 @@ class LangChainAgent:
             except Exception as e:
                 logger.warning(f"Failed to get db session: {e}")
 
-
             # 注意：不在这里写入用户消息，等 AI 回复后一起写入
         try:
             # 准备消息列表（支持多模态）
@@ -500,13 +508,13 @@ class LangChainAgent:
             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",
+                        config={"recursion_limit": self.max_iterations}
                 ):
                     chunk_count += 1
                     kind = event.get("event")
-                    
+
                     # 处理所有可能的流式事件
                     if kind == "on_chat_model_stream":
                         # LLM 流式输出
@@ -540,7 +548,7 @@ class LangChainAgent:
                                         full_content += item
                                         yield item
                                         yielded_content = True
-                    
+
                     elif kind == "on_llm_stream":
                         # 另一种 LLM 流式事件
                         chunk = event.get("data", {}).get("chunk")
@@ -577,13 +585,13 @@ class LangChainAgent:
                                 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", [])
@@ -595,7 +603,8 @@ class LangChainAgent:
                         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)
+                    await write_long_term(storage_type, end_user_id, message_chat, full_content, user_rag_memory_id,
+                                          actual_config_id)
             except Exception as e:
                 logger.error(f"Agent astream_events 失败: {str(e)}", exc_info=True)
                 raise
@@ -609,5 +618,3 @@ 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 Any, Dict, Optional
+from typing import Annotated, 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,7 +57,6 @@ 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")
@@ -91,7 +90,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", "{}")
@@ -115,6 +114,7 @@ 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)
@@ -162,6 +162,44 @@ class Settings:
     # This controls the language used for memory summary titles and other generated content
     DEFAULT_LANGUAGE: str = os.getenv("DEFAULT_LANGUAGE", "zh")
 
+    # ========================================================================
+    # Internationalization (i18n) Configuration
+    # ========================================================================
+    # Default language for API responses
+    I18N_DEFAULT_LANGUAGE: str = os.getenv("I18N_DEFAULT_LANGUAGE", "zh")
+    
+    # Supported languages (comma-separated)
+    I18N_SUPPORTED_LANGUAGES: list[str] = [
+        lang.strip()
+        for lang in os.getenv("I18N_SUPPORTED_LANGUAGES", "zh,en").split(",")
+        if lang.strip()
+    ]
+    
+    # Core locales directory (community edition)
+    # Use absolute path to work from any working directory
+    I18N_CORE_LOCALES_DIR: str = os.getenv(
+        "I18N_CORE_LOCALES_DIR",
+        os.path.join(os.path.dirname(os.path.dirname(__file__)), "locales")
+    )
+    
+    # Premium locales directory (enterprise edition, optional)
+    I18N_PREMIUM_LOCALES_DIR: Optional[str] = os.getenv("I18N_PREMIUM_LOCALES_DIR", None)
+    
+    # Enable translation cache
+    I18N_ENABLE_TRANSLATION_CACHE: bool = os.getenv("I18N_ENABLE_TRANSLATION_CACHE", "true").lower() == "true"
+    
+    # LRU cache size for hot translations
+    I18N_LRU_CACHE_SIZE: int = int(os.getenv("I18N_LRU_CACHE_SIZE", "1000"))
+    
+    # Enable hot reload of translation files
+    I18N_ENABLE_HOT_RELOAD: bool = os.getenv("I18N_ENABLE_HOT_RELOAD", "false").lower() == "true"
+    
+    # Fallback language when translation is missing
+    I18N_FALLBACK_LANGUAGE: str = os.getenv("I18N_FALLBACK_LANGUAGE", "zh")
+    
+    # Log missing translations
+    I18N_LOG_MISSING_TRANSLATIONS: bool = os.getenv("I18N_LOG_MISSING_TRANSLATIONS", "true").lower() == "true"
+
     # 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,8 +228,12 @@ class Settings:
     LOG_FILE_MAX_SIZE_MB: int = int(os.getenv("LOG_FILE_MAX_SIZE_MB", "10"))  # 10MB
 
     # Celery configuration (internal)
-    CELERY_BROKER: int = int(os.getenv("CELERY_BROKER", "1"))
-    CELERY_BACKEND: int = int(os.getenv("CELERY_BACKEND", "2"))
+    # 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")
@@ -201,21 +243,30 @@ class Settings:
 
     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"))
     REFLECTION_INTERVAL_TIME: Optional[str] = int(os.getenv("REFLECTION_INTERVAL_TIME", 30))
 
     # Memory Cache Regeneration Configuration
     MEMORY_CACHE_REGENERATION_HOURS: int = int(os.getenv("MEMORY_CACHE_REGENERATION_HOURS", "24"))
 
-    # Periodic Task Schedule Configuration
-    # workspace_reflection: 每隔多少秒执行一次
-    WORKSPACE_REFLECTION_INTERVAL_SECONDS: int = int(os.getenv("WORKSPACE_REFLECTION_INTERVAL_SECONDS", "30"))
-    # forgetting_cycle: 每隔多少小时执行一次
-    FORGETTING_CYCLE_INTERVAL_HOURS: int = int(os.getenv("FORGETTING_CYCLE_INTERVAL_HOURS", "24"))
-    # implicit_emotions_update: 每天几点执行（小时，0-23）
+    # 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)
+    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")
 
@@ -232,27 +283,28 @@ class Settings:
     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", "General_purpose_entity.ttl")
-    
+    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"
 

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

@@ -2,15 +2,37 @@ from app.core.memory.agent.utils.llm_tools import ReadState, WriteState
 
 
 def content_input_node(state: ReadState) -> ReadState:
-    """开始节点 - 提取内容并保持状态信息"""
+    """
+    Start node - Extract content and maintain state information
+
+    Extracts the content from the first message in the state and returns it
+    as the data field while preserving all other state information.
+
+    Args:
+        state: ReadState containing messages and other state data
+
+    Returns:
+        ReadState: Updated state with extracted content in data field
+    """
 
     content = state['messages'][0].content if state.get('messages') else ''
-    # 返回内容并保持所有状态信息
+    # Return content and maintain all state information
     return {"data": content}
 
+
 def content_input_write(state: WriteState) -> WriteState:
-    """开始节点 - 提取内容并保持状态信息"""
+    """
+    Start node - Extract content and maintain state information for write operations
+
+    Extracts the content from the first message in the state for write operations.
+
+    Args:
+        state: WriteState containing messages and other state data
+
+    Returns:
+        WriteState: Updated state with extracted content in data field
+    """
 
     content = state['messages'][0].content if state.get('messages') else ''
-    # 返回内容并保持所有状态信息
-    return {"data": content}
+    # Return content and maintain all state information
+    return {"data": content}

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

@@ -1,10 +1,10 @@
-import os
 import json
+import os
 import time
-from app.core.logging_config import get_agent_logger
-from app.db import get_db
 
+from app.core.logging_config import get_agent_logger
 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,27 +12,46 @@ 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.memory.agent.services.optimized_llm_service import LLMServiceMixin
+from app.db import get_db_context
 
 template_root = os.path.join(PROJECT_ROOT_, 'memory', 'agent', 'utils', 'prompt')
-db_session = next(get_db())
 logger = get_agent_logger(__name__)
 
 
 class ProblemNodeService(LLMServiceMixin):
-    """问题处理节点服务类"""
+    """
+    Problem processing node service class
+    
+    Handles problem decomposition and extension operations using LLM services.
+    Inherits from LLMServiceMixin to provide structured LLM calling capabilities.
+    
+    Attributes:
+        template_service: Service for rendering Jinja2 templates
+    """
 
     def __init__(self):
         super().__init__()
         self.template_service = TemplateService(template_root)
 
 
-# 创建全局服务实例
+# Create global service instance
 problem_service = ProblemNodeService()
 
 
 async def Split_The_Problem(state: ReadState) -> ReadState:
-    """问题分解节点"""
+    """
+    Problem decomposition node
+    
+    Breaks down complex user queries into smaller, more manageable sub-problems.
+    Uses LLM to analyze the input and generate structured problem decomposition
+    with question types and reasoning.
+    
+    Args:
+        state: ReadState containing user input and configuration
+        
+    Returns:
+        ReadState: Updated state with problem decomposition results
+    """
     # 从状态中获取数据
     content = state.get('data', '')
     end_user_id = state.get('end_user_id', '')
@@ -53,18 +72,19 @@ async def Split_The_Problem(state: ReadState) -> ReadState:
 
     try:
         # 使用优化的LLM服务
-        structured = await problem_service.call_llm_structured(
-            state=state,
-            db_session=db_session,
-            system_prompt=system_prompt,
-            response_model=ProblemExtensionResponse,
-            fallback_value=[]
-        )
+        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=[]
+            )
 
         # 添加更详细的日志记录
         logger.info(f"Split_The_Problem: 开始处理问题分解，内容长度: {len(content)}")
 
-        # 验证结构化响应
+        # Validate structured response
         if not structured or not hasattr(structured, 'root'):
             logger.warning("Split_The_Problem: 结构化响应为空或格式不正确")
             split_result = json.dumps([], ensure_ascii=False)
@@ -106,17 +126,17 @@ async def Split_The_Problem(state: ReadState) -> ReadState:
             exc_info=True
         )
 
-        # 提供更详细的错误信息
+        # Provide more detailed error information
         error_details = {
             "error_type": type(e).__name__,
             "error_message": str(e),
             "content_length": len(content),
-            "llm_model_id": memory_config.llm_model_id if memory_config else None
+            "llm_model_id": str(memory_config.llm_model_id) if memory_config else None
         }
 
         logger.error(f"Split_The_Problem error details: {error_details}")
 
-        # 创建默认的空结果
+        # Create default empty result
         result = {
             "context": json.dumps([], ensure_ascii=False),
             "original": content,
@@ -130,13 +150,25 @@ async def Split_The_Problem(state: ReadState) -> ReadState:
             }
         }
 
-    # 返回更新后的状态，包含spit_context字段
+    # Return updated state including spit_context field
     return {"spit_data": result}
 
 
 async def Problem_Extension(state: ReadState) -> ReadState:
-    """问题扩展节点"""
-    # 获取原始数据和分解结果
+    """
+    Problem extension node
+    
+    Extends the decomposed problems from Split_The_Problem node by generating
+    additional related questions and organizing them by original question.
+    Uses LLM to create comprehensive question extensions for better memory retrieval.
+    
+    Args:
+        state: ReadState containing decomposed problems and configuration
+        
+    Returns:
+        ReadState: Updated state with extended problem results
+    """
+    # Get original data and decomposition results
     start = time.time()
     content = state.get('data', '')
     data = state.get('spit_data', '')['context']
@@ -171,17 +203,18 @@ async def Problem_Extension(state: ReadState) -> ReadState:
 
     try:
         # 使用优化的LLM服务
-        response_content = await problem_service.call_llm_structured(
-            state=state,
-            db_session=db_session,
-            system_prompt=system_prompt,
-            response_model=ProblemExtensionResponse,
-            fallback_value=[]
-        )
+        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=[]
+            )
 
         logger.info(f"Problem_Extension: 开始处理问题扩展，问题数量: {len(databasets)}")
 
-        # 验证结构化响应
+        # Validate structured response
         if not response_content or not hasattr(response_content, 'root'):
             logger.warning("Problem_Extension: 结构化响应为空或格式不正确")
             aggregated_dict = {}
@@ -215,12 +248,12 @@ async def Problem_Extension(state: ReadState) -> ReadState:
             exc_info=True
         )
 
-        # 提供更详细的错误信息
+        # Provide more detailed error information
         error_details = {
             "error_type": type(e).__name__,
             "error_message": str(e),
             "questions_count": len(databasets),
-            "llm_model_id": memory_config.llm_model_id if memory_config else None
+            "llm_model_id": str(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,34 +6,41 @@ 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):
+    """
+    Configure RAG (Retrieval-Augmented Generation) settings
+    
+    Creates configuration for knowledge base retrieval including similarity thresholds,
+    weights, and reranker settings.
+    
+    Args:
+        state: Current state containing user_rag_memory_id
+        
+    Returns:
+        dict: RAG configuration dictionary
+    """
     user_rag_memory_id = state.get('user_rag_memory_id', '')
     kb_config = {
         "knowledge_bases": [
@@ -50,10 +57,25 @@ async def rag_config(state):
         "reranker_top_k": 10
     }
     return kb_config
-async def rag_knowledge(state,question):
+
+
+async def rag_knowledge(state, question):
+    """
+    Retrieve knowledge using RAG approach
+    
+    Performs knowledge retrieval from configured knowledge bases using the
+    provided question and returns formatted results.
+    
+    Args:
+        state: Current state containing configuration
+        question: Question to search for
+        
+    Returns:
+        tuple: (retrieval_knowledge, clean_content, cleaned_query, raw_results)
+    """
     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]
@@ -61,22 +83,34 @@ 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:
+    """
+    Get LLM configuration information from state
+    
+    Retrieves model configuration details including model ID and tenant ID
+    from the memory configuration in the current state.
+    
+    Args:
+        state: ReadState containing memory configuration
+        
+    Returns:
+        ReadState: Model configuration as Pydantic model
+    """
     memory_config = state.get('memory_config', None)
     model_id = memory_config.llm_model_id
     tenant_id = memory_config.tenant_id
 
-    # 使用现有的 memory_config 而不是重新查询数据库
-    # 或者使用线程安全的数据库访问
+    # Use existing memory_config instead of re-querying database
+    # or use thread-safe database access
     with get_db_context() as db:
         result_orm = ModelConfigService.get_model_by_id(db=db, model_id=model_id, tenant_id=tenant_id)
         result_pydantic = model_schema.ModelConfig.model_validate(result_orm)
@@ -85,16 +119,20 @@ async def llm_infomation(state: ReadState) -> ReadState:
 
 async def clean_databases(data) -> str:
     """
-    简化的数据库搜索结果清理函数
+    Simplified database search result cleaning function
+    
+    Processes and cleans search results from various sources including
+    reranked results and time-based search results. Extracts text content
+    from structured data and returns as formatted string.
     
     Args:
-        data: 搜索结果数据
+        data: Search result data (can be string, dict, or other types)
         
     Returns:
-        清理后的内容字符串
+        str: Cleaned content string
     """
     try:
-        # 解析JSON字符串
+        # Parse JSON string
         if isinstance(data, str):
             try:
                 data = json.loads(data)
@@ -104,24 +142,24 @@ async def clean_databases(data) -> str:
         if not isinstance(data, dict):
             return str(data)
 
-        # 获取结果数据
+        # Get result data
         # with open("搜索结果.json","w",encoding='utf-8') as f:
         #     f.write(json.dumps(data, indent=4, ensure_ascii=False))
         results = data.get('results', data)
         if not isinstance(results, dict):
             return str(results)
 
-        # 收集所有内容
+        # Collect all content
         content_list = []
-        
-        # 处理重排序结果
+
+        # Process reranked results
         reranked = results.get('reranked_results', {})
         if reranked:
             for category in ['summaries', 'statements', 'chunks', 'entities']:
                 items = reranked.get(category, [])
                 if isinstance(items, list):
                     content_list.extend(items)
-        # 处理时间搜索结果
+        # Process time search results
         time_search = results.get('time_search', {})
         if time_search:
             if isinstance(time_search, dict):
@@ -131,7 +169,7 @@ async def clean_databases(data) -> str:
             elif isinstance(time_search, list):
                 content_list.extend(time_search)
 
-        # 提取文本内容
+        # Extract text content
         text_parts = []
         for item in content_list:
             if isinstance(item, dict):
@@ -141,7 +179,6 @@ async def clean_databases(data) -> str:
             elif isinstance(item, str):
                 text_parts.append(item)
 
-
         return '\n'.join(text_parts).strip()
 
     except Exception as e:
@@ -150,24 +187,33 @@ async def clean_databases(data) -> str:
 
 
 async def retrieve_nodes(state: ReadState) -> ReadState:
+    """
+    Retrieve information using simplified search approach
+    
+    Processes extended problems from previous nodes and performs retrieval
+    using either RAG or hybrid search based on storage type. Handles concurrent
+    processing of multiple questions and deduplicates results.
+    
+    Args:
+        state: ReadState containing problem extensions and configuration
+        
+    Returns:
+        ReadState: Updated state with retrieval results and intermediate outputs
+    """
 
-    '''
-
-    模型信息
-    '''
-
-    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}")
-    # 创建异步任务处理单个问题
+
+    # Create async task to process individual questions
     async def process_question_nodes(idx, question):
         try:
             # Prepare search parameters based on storage type
@@ -213,7 +259,7 @@ async def retrieve_nodes(state: ReadState) -> ReadState:
                 }
             }
 
-    # 并发处理所有问题
+    # Process all questions concurrently
     tasks = [process_question_nodes(idx, question) for idx, question in enumerate(problem_list)]
     databases_anser = await asyncio.gather(*tasks)
     databases_data = {
@@ -244,7 +290,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
@@ -257,15 +303,26 @@ 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
+    """
+    Advanced retrieve function using LangChain agents and tools
+    
+    Uses LangChain agents with specialized retrieval tools (time-based and hybrid)
+    to perform sophisticated information retrieval. Supports both RAG and traditional
+    memory storage approaches with concurrent processing and result deduplication.
+    
+    Args:
+        state: ReadState containing problem extensions and configuration
+        
+    Returns:
+        ReadState: Updated state with retrieval results and intermediate outputs
+    """
+    # Get end_user_id from state
     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', '')
@@ -283,6 +340,7 @@ 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
@@ -296,28 +354,29 @@ 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}"
     )
 
-    # 创建异步任务处理单个问题
+    # Create async task to process individual questions
     import asyncio
 
-    # 在模块级别定义信号量，限制最大并发数
-    SEMAPHORE = asyncio.Semaphore(5)  # 限制最多5个并发数据库操作
+    # Define semaphore at module level to limit maximum concurrency
+    SEMAPHORE = asyncio.Semaphore(5)  # Limit to maximum 5 concurrent database operations
 
     async def process_question(idx, question):
-        async with SEMAPHORE:  # 限制并发
+        async with SEMAPHORE:  # Limit concurrency
             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
+                    # Use asyncio to run synchronous agent.invoke in thread pool
                     import asyncio
                     response = await asyncio.get_event_loop().run_in_executor(
                         None,
@@ -366,7 +425,7 @@ async def retrieve(state: ReadState) -> ReadState:
                     }
                 }
 
-    # 并发处理所有问题
+    # Process all questions concurrently
     import asyncio
     tasks = [process_question(idx, question) for idx, question in enumerate(problem_list)]
     databases_anser = await asyncio.gather(*tasks)
@@ -413,5 +472,3 @@ 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,5 +1,3 @@
-
-
 import os
 import time
 
@@ -17,34 +15,143 @@ 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
+from app.core.rag.nlp.search import knowledge_retrieval
+from app.db import get_db_context
 
 template_root = os.path.join(PROJECT_ROOT_, 'memory', 'agent', 'utils', 'prompt')
 logger = get_agent_logger(__name__)
-db_session = next(get_db())
+
 
 class SummaryNodeService(LLMServiceMixin):
-    """总结节点服务类"""
+    """
+    Summary node service class
     
+    Handles summary generation operations using LLM services. Inherits from 
+    LLMServiceMixin to provide structured LLM calling capabilities for 
+    generating summaries from retrieved information.
+    
+    Attributes:
+        template_service: Service for rendering Jinja2 templates
+    """
+
     def __init__(self):
         super().__init__()
         self.template_service = TemplateService(template_root)
 
-# 创建全局服务实例
+
+# Create global service instance
 summary_service = SummaryNodeService()
 
+
+async def rag_config(state):
+    """
+    Configure RAG (Retrieval-Augmented Generation) settings for summary operations
+    
+    Creates configuration for knowledge base retrieval including similarity thresholds,
+    weights, and reranker settings specifically for summary generation.
+    
+    Args:
+        state: Current state containing user_rag_memory_id
+        
+    Returns:
+        dict: RAG configuration dictionary with knowledge base settings
+    """
+    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):
+    """
+    Retrieve knowledge using RAG approach for summary generation
+    
+    Performs knowledge retrieval from configured knowledge bases using the
+    provided question and returns formatted results for summary processing.
+    
+    Args:
+        state: Current state containing configuration
+        question: Question to search for in knowledge base
+        
+    Returns:
+        tuple: (retrieval_knowledge, clean_content, cleaned_query, raw_results)
+            - retrieval_knowledge: List of retrieved knowledge chunks
+            - clean_content: Formatted content string
+            - cleaned_query: Processed query string
+            - raw_results: Raw retrieval results
+    """
+    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:
+    """
+    Retrieve conversation history for summary context
+    
+    Gets the conversation history for the current user to provide context
+    for summary generation operations.
+    
+    Args:
+        state: ReadState containing end_user_id
+        
+    Returns:
+        ReadState: Conversation history data
+    """
     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函数，包含更好的错误处理和数据验证
+    Enhanced summary_llm function with better error handling and data validation
+    
+    Generates summaries using LLM with structured output. Includes fallback mechanisms
+    for handling LLM failures and provides robust error recovery.
+    
+    Args:
+        state: ReadState containing current context
+        history: Conversation history for context
+        retrieve_info: Retrieved information to summarize
+        template_name: Jinja2 template name for prompt generation
+        operation_name: Type of operation (summary, input_summary, retrieve_summary)
+        response_model: Pydantic model for structured output
+        search_mode: Search mode flag ("0" for simple, "1" for complex)
+        
+    Returns:
+        str: Generated summary text or fallback message
     """
     data = state.get("data", '')
-    
-    # 构建系统提示词
+
+    # Build system prompt
     if str(search_mode) == "0":
         system_prompt = await summary_service.template_service.render_template(
             template_name=template_name,
@@ -61,40 +168,41 @@ async def summary_llm(state: ReadState, history, retrieve_info, template_name, o
             retrieve_info=retrieve_info
         )
     try:
-        # 使用优化的LLM服务进行结构化输出
-        structured = await summary_service.call_llm_structured(
-            state=state,
-            db_session=db_session,
-            system_prompt=system_prompt,
-            response_model=response_model,
-            fallback_value=None
-        )
-        # 验证结构化响应
+        # Use optimized LLM service for structured output
+        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
+            )
+        # Validate structured response
         if structured is None:
-            logger.warning(f"LLM返回None，使用默认回答")
+            logger.warning("LLM返回None，使用默认回答")
             return "信息不足，无法回答"
-        
-        # 根据操作类型提取答案
+
+        # Extract answer based on operation type
         if operation_name == "summary":
             aimessages = getattr(structured, 'query_answer', None) or "信息不足，无法回答"
         else:
-            # 处理RetrieveSummaryResponse
+            # Handle RetrieveSummaryResponse
             if hasattr(structured, 'data') and structured.data:
                 aimessages = getattr(structured.data, 'query_answer', None) or "信息不足，无法回答"
             else:
-                logger.warning(f"结构化响应缺少data字段")
+                logger.warning("结构化响应缺少data字段")
                 aimessages = "信息不足，无法回答"
-        
-        # 验证答案不为空
+
+        # Validate answer is not empty
         if not aimessages or aimessages.strip() == "":
             aimessages = "信息不足，无法回答"
-            
+
         return aimessages
-        
+
     except Exception as e:
         logger.error(f"结构化输出失败: {e}", exc_info=True)
-        
-        # 尝试非结构化输出作为fallback
+
+        # Try unstructured output as fallback
         try:
             logger.info("尝试非结构化输出作为fallback")
             response = await summary_service.call_llm_simple(
@@ -103,24 +211,38 @@ async def summary_llm(state: ReadState, history, retrieve_info, template_name, o
                 system_prompt=system_prompt,
                 fallback_message="信息不足，无法回答"
             )
-            
+
             if response and response.strip():
-                # 简单清理响应
+                # Simple response cleaning
                 cleaned_response = response.strip()
-                # 移除可能的JSON标记
+                # Remove possible JSON markers
                 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:
+    """
+    Save summary results to Redis session storage
+    
+    Stores the generated summary and user query in Redis for session management
+    and conversation history tracking.
+    
+    Args:
+        state: ReadState containing user and query information
+        aimessages: Generated summary message to save
+        
+    Returns:
+        ReadState: Updated state after saving to Redis
+    """
     data = state.get("data", '')
     end_user_id = state.get("end_user_id", '')
     await SessionService(store).save_session(
@@ -132,10 +254,26 @@ 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:
+    """
+    Format summary results for different output types
+    
+    Creates structured output formats for both input summary and retrieval summary
+    operations, including metadata and intermediate results for frontend display.
+    
+    Args:
+        state: ReadState containing storage and user information
+        aimessages: Generated summary message
+        raw_results: Raw search/retrieval results
+        
+    Returns:
+        tuple: (input_summary, retrieve_summary) formatted result dictionaries
+    """
+    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,
@@ -152,14 +290,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,
@@ -167,17 +305,31 @@ 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",'')
+    """
+    Generate quick input summary from retrieved information
+    
+    Performs fast retrieval and generates a quick summary response for user queries.
+    This function prioritizes speed by only searching summary nodes and provides
+    immediate feedback to users.
+    
+    Args:
+        state: ReadState containing user query, storage configuration, and context
+        
+    Returns:
+        ReadState: Dictionary containing summary results with status and metadata
+    """
+    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,
@@ -186,12 +338,14 @@ async def Input_Summary(state: ReadState) -> ReadState:
     }
 
     try:
-        retrieve_info, question, raw_results = await SearchService().execute_hybrid_search(**search_params, memory_config=memory_config)
+        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)
     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)
@@ -199,8 +353,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,
@@ -213,30 +367,44 @@ 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:
+    """
+    Generate comprehensive summary from retrieved expansion issues
+    
+    Processes retrieved expansion issues and generates a detailed summary using LLM.
+    This function handles complex retrieval results and provides comprehensive answers
+    based on expanded query results.
+    
+    Args:
+        state: ReadState containing retrieve data with expansion issues
+        
+    Returns:
+        ReadState: Dictionary containing comprehensive summary results
+    """
+    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 == '':
@@ -248,33 +416,46 @@ async def Retrieve_Summary(state: ReadState)-> ReadState:
     except Exception:
         duration = 0.0
     log_time('Retrieval summary', duration)
-    
-    # 修复协程调用 - 先await，然后访问返回值
+
+    # Fixed coroutine call - await first, then access return value
     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:
+    """
+    Generate final comprehensive summary from verified data
+    
+    Creates the final summary using verified expansion issues and conversation history.
+    This function processes verified data to generate the most comprehensive and
+    accurate response to user queries.
+    
+    Args:
+        state: ReadState containing verified data and query information
+        
+    Returns:
+        ReadState: Dictionary containing final summary results
+    """
+    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)
@@ -286,14 +467,28 @@ async def Summary(state: ReadState)-> ReadState:
         duration = 0.0
     log_time('Retrieval summary', duration)
 
-    # 修复协程调用 - 先await，然后访问返回值
+    # Fixed coroutine call - await first, then access return value
     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:
+    """
+    Generate fallback summary when normal summary process fails
+    
+    Provides a fallback summary generation mechanism when the standard summary
+    process encounters errors or fails to produce satisfactory results. Uses
+    a specialized failure template to handle edge cases.
+    
+    Args:
+        state: ReadState containing verified data and failure context
+        
+    Returns:
+        ReadState: Dictionary containing fallback summary results
+    """
+    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", '')
@@ -309,12 +504,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,8 +1,9 @@
+import asyncio
 import os
-from app.core.logging_config import get_agent_logger
-from app.db import get_db
 
+from app.core.logging_config import get_agent_logger
 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,
@@ -10,29 +11,53 @@ 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.memory.agent.services.optimized_llm_service import LLMServiceMixin
+from app.db import get_db_context
 
 template_root = os.path.join(PROJECT_ROOT_, 'memory', 'agent', 'utils', 'prompt')
-db_session = next(get_db())
 logger = get_agent_logger(__name__)
 
+
 class VerificationNodeService(LLMServiceMixin):
-    """验证节点服务类"""
+    """
+    Verification node service class
     
+    Handles data verification operations using LLM services. Inherits from 
+    LLMServiceMixin to provide structured LLM calling capabilities for 
+    verifying and validating retrieved information.
+    
+    Attributes:
+        template_service: Service for rendering Jinja2 templates
+    """
+
     def __init__(self):
         super().__init__()
         self.template_service = TemplateService(template_root)
 
-# 创建全局服务实例
+
+# Create global service instance
 verification_service = VerificationNodeService()
 
+
 async def Verify_prompt(state: ReadState, messages_deal: VerificationResult):
-    """处理验证结果并生成输出格式"""
+    """
+    Process verification results and generate output format
+    
+    Transforms VerificationResult objects into structured output format suitable
+    for frontend consumption. Handles conversion of VerificationItem objects to
+    dictionary format and adds metadata for tracking.
+    
+    Args:
+        state: ReadState containing storage and user configuration
+        messages_deal: VerificationResult containing verification outcomes
+        
+    Returns:
+        dict: Formatted verification result with status and metadata
+    """
     storage_type = state.get('storage_type', '')
     user_rag_memory_id = state.get('user_rag_memory_id', '')
     data = state.get('data', '')
-    
-    # 将 VerificationItem 对象转换为字典列表
+
+    # Convert VerificationItem objects to dictionary list
     verified_data = []
     if messages_deal.expansion_issue:
         for item in messages_deal.expansion_issue:
@@ -40,7 +65,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,
@@ -58,34 +83,37 @@ 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 输出正确格式
+
+        # Generate JSON schema to guide LLM output format
         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',
@@ -94,29 +122,30 @@ 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 秒稍长）
-            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秒超时
-            )
+            # Add asyncio.wait_for timeout wrapper to prevent infinite waiting
+            # Timeout set to 150 seconds (slightly longer than LLM config's 120 seconds)
+
+            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 second timeout
+                )
             logger.info(f"Verify: LLM 调用完成，result={structured}")
         except asyncio.TimeoutError:
             logger.error("Verify: LLM 调用超时（150秒），使用 fallback 值")
@@ -127,11 +156,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)
         # 返回失败的验证结果
@@ -152,4 +181,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,3 +1,4 @@
+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
@@ -40,6 +41,15 @@ async def write_node(state: WriteState) -> WriteState:
         )
         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,7 +5,6 @@ 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
 
@@ -32,10 +31,21 @@ from app.core.memory.agent.langgraph_graph.routing.routers import (
 )
 
 
-
 @asynccontextmanager
 async def make_read_graph():
-    """创建并返回 LangGraph 工作流"""
+    """
+    Create and return a LangGraph workflow for memory reading operations
+    
+    Builds a state graph workflow that handles memory retrieval, problem analysis,
+    verification, and summarization. The workflow includes nodes for content input,
+    problem splitting, retrieval, verification, and various summary operations.
+    
+    Yields:
+        StateGraph: Compiled LangGraph workflow for memory reading
+        
+    Raises:
+        Exception: If workflow creation fails
+    """
     try:
         # Build workflow graph
         workflow = StateGraph(ReadState)
@@ -49,8 +59,8 @@ async def make_read_graph():
         workflow.add_node("Retrieve_Summary", Retrieve_Summary)
         workflow.add_node("Summary", Summary)
         workflow.add_node("Summary_fails", Summary_fails)
-        
-        # 添加边
+
+        # Add edges to define workflow flow
         workflow.add_edge(START, "content_input")
         workflow.add_conditional_edges("content_input", Split_continue)
         workflow.add_edge("Input_Summary", END)
@@ -62,116 +72,15 @@ async def make_read_graph():
         workflow.add_edge("Summary_fails", END)
         workflow.add_edge("Summary", END)
 
-
         '''-----'''
         # workflow.add_edge("Retrieve", END)
-        
-        # 编译工作流
+
+        # Compile workflow
         graph = workflow.compile()
         yield graph
-        
+
     except Exception as e:
         print(f"创建工作流失败: {e}")
         raise
     finally:
         print("工作流创建完成")
-
-async def main():
-    """主函数 - 运行工作流"""
-    message = "昨天有什么好看的电影"
-    end_user_id = '88a459f5_text09'  # 组ID
-    storage_type = 'neo4j'  # 存储类型
-    search_switch = '1'  # 搜索开关
-    user_rag_memory_id = 'wwwwwwww'  # 用户RAG记忆ID
-
-    # 获取数据库会话
-    db_session = next(get_db())
-    config_service = MemoryConfigService(db_session)
-    memory_config = config_service.load_memory_config(
-        config_id=17,  # 改为整数
-        service_name="MemoryAgentService"
-    )
-    import 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}
-            # 获取节点更新信息
-            _intermediate_outputs = []
-            summary = ''
-            
-            async for update_event in graph.astream(
-                    initial_state,
-                    stream_mode="updates",
-                    config=config
-            ):
-                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']:
-                            summary = node_data['InputSummary']['summary_result']
-                        elif 'RetrieveSummary' in node_data and 'summary_result' in node_data['RetrieveSummary']:
-                            summary = node_data['RetrieveSummary']['summary_result']
-                        elif 'summary' in node_data and 'summary_result' in node_data['summary']:
-                            summary = node_data['summary']['summary_result']
-                        elif 'SummaryFails' in node_data and 'summary_result' in node_data['SummaryFails']:
-                            summary = node_data['SummaryFails']['summary_result']
-
-                    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 != {}:
-                        _intermediate_outputs.append(summary_n)
-
-            # # 过滤掉空值
-            # _intermediate_outputs = [item for item in _intermediate_outputs if item and item != [] and item != {}]
-            #
-            # # 优化搜索结果
-            # print("=== 开始优化搜索结果 ===")
-            # optimized_outputs = merge_multiple_search_results(_intermediate_outputs)
-            # result=reorder_output_results(optimized_outputs)
-            # # 保存优化后的结果到文件
-            # with open('_intermediate_outputs_optimized.json', 'w', encoding='utf-8') as f:
-            #     import json
-            #     f.write(json.dumps(result, indent=4, ensure_ascii=False))
-            #
-            print(f"=== 最终摘要 ===")
-            print(summary)
-                
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-
-    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/routers.py

@@ -1,13 +1,13 @@
-
 from typing import Literal
 
 from app.core.logging_config import get_agent_logger
 from app.core.memory.agent.utils.llm_tools import ReadState, COUNTState
 
-
 logger = get_agent_logger(__name__)
 counter = COUNTState(limit=3)
-def Split_continue(state:ReadState) -> Literal["Split_The_Problem", "Input_Summary"]:
+
+
+def Split_continue(state: ReadState) -> Literal["Split_The_Problem", "Input_Summary"]:
     """
     Determine routing based on search_switch value.
 
@@ -25,6 +25,7 @@ def Split_continue(state:ReadState) -> Literal["Split_The_Problem", "Input_Summa
             return 'Input_Summary'
     return 'Split_The_Problem'  # 默认情况
 
+
 def Retrieve_continue(state) -> Literal["Verify", "Retrieve_Summary"]:
     """
     Determine routing based on search_switch value.
@@ -43,8 +44,10 @@ def Retrieve_continue(state) -> Literal["Verify", "Retrieve_Summary"]:
         elif search_switch == '1':
             return 'Retrieve_Summary'
     return 'Retrieve_Summary'  # Default based on business logic
+
+
 def Verify_continue(state: ReadState) -> Literal["Summary", "Summary_fails", "content_input"]:
-    status=state.get('verify', '')['status']
+    status = state.get('verify', '')['status']
     # loop_count = counter.get_total()
     if "success" in status:
         # counter.reset()
@@ -53,7 +56,7 @@ def Verify_continue(state: ReadState) -> Literal["Summary", "Summary_fails", "co
         # if loop_count < 2:  # Maximum loop count is 3
         #     return "content_input"
         # else:
-            # counter.reset()
+        # counter.reset()
         return "Summary_fails"
     else:
         # Add default return value to avoid returning None

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

@@ -2,77 +2,104 @@ 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.langgraph_graph.tools.write_tool import format_parsing, messages_parse
 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.redis_tool import write_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.db import get_db_context
 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 模式：组合消息为字符串格式（保持原有逻辑）
+    """
+    Write messages to RAG storage system
+
+    Combines user and AI messages into a single string format and stores them
+    in the RAG (Retrieval-Augmented Generation) knowledge base for future retrieval.
+
+    Args:
+        end_user_id: User identifier for the conversation
+        user_message: User's input message content
+        ai_message: AI's response message content
+        user_rag_memory_id: RAG memory identifier for storage location
+    """
+    # RAG mode: combine messages into string format (maintain original logic)
     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=[]):
+
+
+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=None
+):
     """
-    写入记忆（支持结构化消息）
+    Write memory with structured message support
+
+    Handles memory writing operations for different storage types (Neo4j/RAG).
+    Supports both individual message pairs and batch long-term message processing.
 
     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
+        storage_type: Storage type identifier ("neo4j" or "rag")
+        end_user_id: Terminal user identifier
+        user_message: User message content
+        ai_message: AI response content
+        user_rag_memory_id: RAG memory identifier
+        actual_end_user_id: Actual user identifier for storage
+        actual_config_id: Configuration identifier
+        long_term_messages: Optional list of structured messages for batch processing
 
-    逻辑说明：
-    - RAG 模式：组合 user_message 和 ai_message 为字符串格式，保持原有逻辑不变
-    - Neo4j 模式：使用结构化消息列表
-      1. 如果 user_message 和 ai_message 都不为空：创建配对消息 [user, assistant]
-      2. 如果只有 user_message：创建单条用户消息 [user]（用于历史记忆场景）
-      3. 每条消息会被转换为独立的 Chunk，保留 speaker 字段
+    Logic explanation:
+    - RAG mode: Combines user_message and ai_message into string format, maintains original logic
+    - Neo4j mode: Uses structured message lists
+      1. If both user_message and ai_message are not empty: Creates paired messages [user, assistant]
+      2. If only user_message exists: Creates single user message [user] (for historical memory scenarios)
+      3. Each message is converted to independent Chunk, preserving speaker field
     """
 
-    db = next(get_db())
-    try:
+    if long_term_messages is None:
+        long_term_messages = []
+    with get_db_context() as db:
         actual_config_id = resolve_config_id(actual_config_id, db)
-        # Neo4j 模式：使用结构化消息列表
+        # Neo4j mode: Use structured message lists
         structured_messages = []
 
-        # 始终添加用户消息（如果不为空）
+        # Always add user message (if not empty)
         if isinstance(user_message, str) and user_message.strip() != "":
             structured_messages.append({"role": "user", "content": user_message})
 
-        # 只有当 AI 回复不为空时才添加 assistant 消息
+        # Only add assistant message when AI reply is not empty
         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 provided, use it to replace 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 字符串，先解析
+            # If it's a JSON string, parse it first
             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 no messages, return directly
         if not structured_messages:
             logger.warning(f"No messages to write for user {actual_end_user_id}")
             return
@@ -80,29 +107,41 @@ async def write(storage_type, end_user_id, user_message, ai_message, user_rag_me
         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字符串
+            actual_end_user_id,  # end_user_id: User ID
+            structured_messages,  # message: JSON string format message list
+            str(actual_config_id),  # config_id: Configuration ID string
             storage_type,  # storage_type: "neo4j"
-            user_rag_memory_id or ""  # user_rag_memory_id: RAG记忆ID（Neo4j模式下不使用）
+            user_rag_memory_id or ""  # user_rag_memory_id: RAG memory ID (not used in Neo4j mode)
         )
         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):
+
+async def term_memory_save(long_term_messages, actual_config_id, end_user_id, type, scope):
+    """
+    Save long-term memory data to database
+
+    Handles the storage of long-term memory data based on different strategies
+    (chunk-based or aggregate-based) and manages the transition from short-term
+    to long-term memory storage.
+
+    Args:
+        long_term_messages: Long-term message data to be saved
+        actual_config_id: Configuration identifier for memory settings
+        end_user_id: User identifier for memory association
+        type: Memory storage strategy type (STRATEGY_CHUNK or STRATEGY_AGGREGATE)
+        scope: Scope/window size for memory processing
+    """
     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:
+        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:
+            if len(chunk_data) == scope:
                 repo.upsert(end_user_id, chunk_data)
                 logger.info(f'---------写入短长期-----------')
         else:
@@ -112,18 +151,23 @@ async def term_memory_save(long_term_messages,actual_config_id,end_user_id,type,
             logger.info(f'写入短长期：')
 
 
+"""Window-based dialogue processing"""
 
-'''根据窗口'''
-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
+
+async def window_dialogue(end_user_id, langchain_messages, memory_config, scope):
+    """
+    Process dialogue based on window size and write to Neo4j
+
+    Manages conversation data based on a sliding window approach. When the window
+    reaches the specified scope size, it triggers long-term memory storage to Neo4j.
+
+    Args:
+        end_user_id: Terminal user identifier
+        memory_config: Memory configuration object containing settings
+        langchain_messages: Original message data list
+        scope: Window size determining when to trigger long-term storage
+    """
+    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]
@@ -135,50 +179,72 @@ async def window_dialogue(end_user_id,langchain_messages,memory_config,scope):
     elif int(is_end_user_id) == int(scope):
         logger.info('写入长期记忆NEO4J')
         formatted_messages = (redis_messages)
-        # 获取 config_id（如果 memory_config 是对象，提取 config_id；否则直接使用）
+        # Get config_id (if memory_config is an object, extract config_id; otherwise use directly)
         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)
+
+        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: 内存配置对象
-    '''
+"""Time-based memory processing"""
+
+
+async def memory_long_term_storage(end_user_id, memory_config, time):
+    """
+    Process memory storage based on time intervals and write to Neo4j
+
+    Retrieves Redis data based on time intervals and writes it to Neo4j for
+    long-term storage. This function handles time-based memory consolidation.
+
+    Args:
+        end_user_id: Terminal user identifier
+        memory_config: Memory configuration object containing settings
+        time: Time interval for data retrieval
+    """
     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
+    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!=[]:
+        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:
     """
-    聚合判断函数：判断输入句子和历史消息是否描述同一事件
+    Aggregation judgment function: determine if input sentence and historical messages describe the same event
+
+    Uses LLM-based analysis to determine whether new messages should be aggregated with existing
+    historical data or stored as separate events. This helps optimize memory storage and retrieval.
     
     Args:
-        end_user_id: 终端用户ID
-        ori_messages: 原始消息列表，格式如 [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]
-        memory_config: 内存配置对象
-    """
+        end_user_id: Terminal user identifier
+        ori_messages: Original message list, format like [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]
+        memory_config: Memory configuration object containing LLM settings
 
+    Returns:
+        dict: Aggregation judgment result containing is_same_event flag and processed output
+    """
+    history = None
     try:
-        # 1. 获取历史会话数据（使用新方法）
+        # 1. Get historical session data (using new method)
         result = write_store.get_all_sessions_by_end_user_id(end_user_id)
         history = await format_parsing(result)
         if not result:
@@ -210,7 +276,7 @@ async def aggregate_judgment(end_user_id: str, ori_messages: list, memory_config
         output_value = structured.output
         if isinstance(output_value, list):
             output_value = [
-                {"role": msg.role, "content": msg.content} 
+                {"role": msg.role, "content": msg.content}
                 for msg in output_value
             ]
 
@@ -223,16 +289,16 @@ async def aggregate_judgment(end_user_id: str, ori_messages: list, memory_config
             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

@@ -2,41 +2,53 @@ import asyncio
 import json
 from datetime import datetime, timedelta
 
-
 from langchain.tools import tool
 from pydantic import BaseModel, Field
 
-
 from app.core.memory.src.search import (
     search_by_temporal,
     search_by_keyword_temporal,
 )
 
+
 def extract_tool_message_content(response):
-    """从agent响应中提取ToolMessage内容和工具名称"""
+    """
+    Extract ToolMessage content and tool names from agent response
+
+    Parses agent response messages to extract tool execution results and metadata.
+    Handles JSON parsing and provides structured access to tool output data.
+
+    Args:
+        response: Agent response dictionary containing messages
+
+    Returns:
+        dict: Dictionary containing tool_name and parsed content, or None if no tool message found
+            - tool_name: Name of the executed tool
+            - content: Parsed tool execution result (JSON or raw text)
+    """
     messages = response.get('messages', [])
 
     for message in messages:
         if hasattr(message, 'tool_call_id') and hasattr(message, 'content'):
-            # 这是一个ToolMessage
+            # This is a ToolMessage
             tool_content = message.content
             tool_name = None
 
-            # 尝试获取工具名称
+            # Try to get tool name
             if hasattr(message, 'name'):
                 tool_name = message.name
             elif hasattr(message, 'tool_name'):
                 tool_name = message.tool_name
 
             try:
-                # 解析JSON内容
+                # Parse JSON content
                 parsed_content = json.loads(tool_content)
                 return {
                     'tool_name': tool_name,
                     'content': parsed_content
                 }
             except json.JSONDecodeError:
-                # 如果不是JSON格式，直接返回内容
+                # If not JSON format, return content directly
                 return {
                     'tool_name': tool_name,
                     'content': tool_content
@@ -46,38 +58,61 @@ def extract_tool_message_content(response):
 
 
 class TimeRetrievalInput(BaseModel):
-    """时间检索工具的输入模式"""
+    """
+    Input schema for time retrieval tool
+
+    Defines the expected input parameters for time-based retrieval operations.
+    Used for validation and documentation of tool parameters.
+
+    Attributes:
+        context: User input query content for search
+        end_user_id: Group ID for filtering search results, defaults to test user
+    """
     context: str = Field(description="用户输入的查询内容")
     end_user_id: str = Field(default="88a459f5_text09", description="组ID，用于过滤搜索结果")
 
+
 def create_time_retrieval_tool(end_user_id: str):
     """
-    创建一个带有特定end_user_id的TimeRetrieval工具（同步版本），用于按时间范围搜索语句(Statements)
+    Create a TimeRetrieval tool with specific end_user_id (synchronous version) for searching statements by time range
+
+    Creates a specialized time-based retrieval tool that searches for statements within
+    specified time ranges. Includes field cleaning functionality to remove unnecessary
+    metadata from search results.
+
+    Args:
+        end_user_id: User identifier for scoping search results
+
+    Returns:
+        function: Configured TimeRetrievalWithGroupId tool function
     """
-    
+
     def clean_temporal_result_fields(data):
         """
-        清理时间搜索结果中不需要的字段，并修改结构
+        Clean unnecessary fields from temporal search results and modify structure
+
+        Removes metadata fields that are not needed for end-user consumption and
+        restructures the response format for better usability.
         
         Args:
-            data: 要清理的数据
+            data: Data to be cleaned (dict, list, or other types)
             
         Returns:
-            清理后的数据
+            Cleaned data with unnecessary fields removed
         """
-        # 需要过滤的字段列表
+        # List of fields to filter out
         fields_to_remove = {
-            'id', 'apply_id', 'user_id', 'chunk_id', 'created_at', 
+            'id', 'apply_id', 'user_id', 'chunk_id', 'created_at',
             'valid_at', 'invalid_at', 'statement_ids'
         }
-        
+
         if isinstance(data, dict):
             cleaned = {}
             for key, value in data.items():
                 if key == 'statements' and isinstance(value, dict) and 'statements' in value:
-                    # 将 statements: {"statements": [...]} 改为 time_search: {"statements": [...]}
+                    # Change statements: {"statements": [...]} to time_search: {"statements": [...]}
                     cleaned_value = clean_temporal_result_fields(value)
-                    # 进一步将内部的 statements 改为 time_search
+                    # Further change internal statements to time_search
                     if 'statements' in cleaned_value:
                         cleaned['results'] = {
                             'time_search': cleaned_value['statements']
@@ -91,26 +126,35 @@ def create_time_retrieval_tool(end_user_id: str):
             return [clean_temporal_result_fields(item) for item in data]
         else:
             return data
-    
+
     @tool
-    def TimeRetrievalWithGroupId(context: str, start_date: str = None, end_date: str = None, end_user_id_param: str = None, clean_output: bool = True) -> str:
+    def TimeRetrievalWithGroupId(context: str, start_date: str = None, end_date: str = None,
+                                 end_user_id_param: str = None, clean_output: bool = True) -> str:
         """
-        优化的时间检索工具，只结合时间范围搜索（同步版本），自动过滤不需要的元数据字段
-        显式接收参数：
-        - context: 查询上下文内容
-        - start_date: 开始时间（可选，格式：YYYY-MM-DD）
-        - end_date: 结束时间（可选，格式：YYYY-MM-DD）
-        - end_user_id_param: 组ID（可选，用于覆盖默认组ID）
-        - clean_output: 是否清理输出中的元数据字段
-        -end_date 需要根据用户的描述获取结束的时间，输出格式用strftime("%Y-%m-%d")
+        Optimized time retrieval tool, combines time range search only (synchronous version), automatically filters unnecessary metadata fields
+
+        Performs time-based search operations with automatic metadata filtering. Supports
+        flexible date range specification and provides clean, user-friendly output.
+
+        Explicit parameters:
+        - context: Query context content
+        - start_date: Start time (optional, format: YYYY-MM-DD)
+        - end_date: End time (optional, format: YYYY-MM-DD)
+        - end_user_id_param: Group ID (optional, overrides default group ID)
+        - clean_output: Whether to clean metadata fields from output
+        - end_date needs to be obtained based on user description, output format uses strftime("%Y-%m-%d")
+
+        Returns:
+            str: JSON formatted search results with temporal data
         """
+
         async def _async_search():
-            # 使用传入的参数或默认值
+            # Use passed parameters or default values
             actual_end_user_id = end_user_id_param or end_user_id
             actual_end_date = end_date or datetime.now().strftime("%Y-%m-%d")
             actual_start_date = start_date or (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d")
             
-            # 基本时间搜索
+            # Basic time search
             results = await search_by_temporal(
                 end_user_id=actual_end_user_id,
                 start_date=actual_start_date,
@@ -118,33 +162,43 @@ def create_time_retrieval_tool(end_user_id: str):
                 limit=10
             )
             
-            # 清理结果中不需要的字段
+            # Clean unnecessary fields from results
             if clean_output:
                 cleaned_results = clean_temporal_result_fields(results)
             else:
                 cleaned_results = results
 
             return json.dumps(cleaned_results, ensure_ascii=False, indent=2)
-        
+
         return asyncio.run(_async_search())
 
     @tool
-    def KeywordTimeRetrieval(context: str, days_back: int = 7, start_date: str = None, end_date: str = None, clean_output: bool = True) -> str:
+    def KeywordTimeRetrieval(context: str, days_back: int = 7, start_date: str = None, end_date: str = None,
+                             clean_output: bool = True) -> str:
         """
-        优化的关键词时间检索工具，结合关键词和时间范围搜索（同步版本），自动过滤不需要的元数据字段
-        显式接收参数：
-        - context: 查询内容
-        - days_back: 向前搜索的天数，默认7天
-        - start_date: 开始时间（可选，格式：YYYY-MM-DD）
-        - end_date: 结束时间（可选，格式：YYYY-MM-DD）
-        - clean_output: 是否清理输出中的元数据字段
-        - end_date 需要根据用户的描述获取结束的时间，输出格式用strftime("%Y-%m-%d")
+        Optimized keyword time retrieval tool, combines keyword and time range search (synchronous version), automatically filters unnecessary metadata fields
+
+        Performs combined keyword and temporal search operations with automatic metadata
+        filtering. Provides more targeted search results by combining content relevance
+        with time-based filtering.
+
+        Explicit parameters:
+        - context: Query content for keyword matching
+        - days_back: Number of days to search backwards, default 7 days
+        - start_date: Start time (optional, format: YYYY-MM-DD)
+        - end_date: End time (optional, format: YYYY-MM-DD)
+        - clean_output: Whether to clean metadata fields from output
+        - end_date needs to be obtained based on user description, output format uses strftime("%Y-%m-%d")
+
+        Returns:
+            str: JSON formatted search results combining keyword and temporal data
         """
+
         async def _async_search():
             actual_end_date = end_date or datetime.now().strftime("%Y-%m-%d")
             actual_start_date = start_date or (datetime.now() - timedelta(days=days_back)).strftime("%Y-%m-%d")
 
-            # 关键词时间搜索
+            # Keyword time search
             results = await search_by_keyword_temporal(
                 query_text=context,
                 end_user_id=end_user_id,
@@ -153,7 +207,7 @@ def create_time_retrieval_tool(end_user_id: str):
                 limit=15
             )
             
-            # 清理结果中不需要的字段
+            # Clean unnecessary fields from results
             if clean_output:
                 cleaned_results = clean_temporal_result_fields(results)
             else:
@@ -162,51 +216,60 @@ def create_time_retrieval_tool(end_user_id: str):
             return json.dumps(cleaned_results, ensure_ascii=False, indent=2)
 
         return asyncio.run(_async_search())
-    
+
     return TimeRetrievalWithGroupId
 
 
 def create_hybrid_retrieval_tool_async(memory_config, **search_params):
     """
-    创建混合检索工具，使用run_hybrid_search进行混合检索，优化输出格式并过滤不需要的字段
+    Create hybrid retrieval tool using run_hybrid_search for hybrid retrieval, optimize output format and filter unnecessary fields
+
+    Creates an advanced hybrid search tool that combines multiple search strategies
+    (keyword, vector, hybrid) with automatic result cleaning and formatting.
     
     Args:
-        memory_config: 内存配置对象
-        **search_params: 搜索参数，包含end_user_id, limit, include等
+        memory_config: Memory configuration object containing LLM and search settings
+        **search_params: Search parameters including end_user_id, limit, include, etc.
+
+    Returns:
+        function: Configured HybridSearch tool function with async capabilities
     """
-    
+
     def clean_result_fields(data):
         """
-        递归清理结果中不需要的字段
+        Recursively clean unnecessary fields from results
+
+        Removes metadata fields that are not needed for end-user consumption,
+        improving readability and reducing response size.
         
         Args:
-            data: 要清理的数据（可能是字典、列表或其他类型）
+            data: Data to be cleaned (can be dict, list, or other types)
             
         Returns:
-            清理后的数据
+            Cleaned data with unnecessary fields removed
         """
-        # 需要过滤的字段列表
-        # TODO: fact_summary 功能暂时禁用，待后续开发完善后启用
+        # List of fields to filter out
+        # TODO: fact_summary functionality temporarily disabled, will be enabled after future development
         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"
+            '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"
         }
-        
+
         if isinstance(data, dict):
-            # 对字典进行清理
+            # Clean dictionary
             cleaned = {}
             for key, value in data.items():
                 if key not in fields_to_remove:
-                    cleaned[key] = clean_result_fields(value)  # 递归清理嵌套数据
+                    cleaned[key] = clean_result_fields(value)  # Recursively clean nested data
             return cleaned
         elif isinstance(data, list):
-            # 对列表中的每个元素进行清理
+            # Clean each element in list
             return [clean_result_fields(item) for item in data]
         else:
-            # 其他类型直接返回
+            # Return other types directly
             return data
-    
+
     @tool
     async def HybridSearch(
         context: str, 
@@ -216,57 +279,63 @@ def create_hybrid_retrieval_tool_async(memory_config, **search_params):
         rerank_alpha: float = 0.6,
         use_forgetting_rerank: bool = False,
         use_llm_rerank: bool = False,
-        clean_output: bool = True  # 新增：是否清理输出字段
+        clean_output: bool = True  # New: whether to clean output fields
     ) -> str:
         """
-        优化的混合检索工具，支持关键词、向量和混合搜索，自动过滤不需要的元数据字段
+        Optimized hybrid retrieval tool, supports keyword, vector and hybrid search, automatically filters unnecessary metadata fields
+
+        Provides comprehensive search capabilities combining multiple search strategies
+        with intelligent result ranking and automatic metadata filtering for clean output.
         
         Args:
-            context: 查询内容
-            search_type: 搜索类型 ('keyword', 'embedding', 'hybrid')
-            limit: 结果数量限制
-            end_user_id: 组ID，用于过滤搜索结果
-            rerank_alpha: 重排序权重参数
-            use_forgetting_rerank: 是否使用遗忘重排序
-            use_llm_rerank: 是否使用LLM重排序
-            clean_output: 是否清理输出中的元数据字段
+            context: Query content for search
+            search_type: Search type ('keyword', 'embedding', 'hybrid')
+            limit: Result quantity limit
+            end_user_id: Group ID for filtering search results
+            rerank_alpha: Reranking weight parameter for result scoring
+            use_forgetting_rerank: Whether to use forgetting-based reranking
+            use_llm_rerank: Whether to use LLM-based reranking
+            clean_output: Whether to clean metadata fields from output
+
+        Returns:
+            str: JSON formatted comprehensive search results
         """
         try:
-            # 导入run_hybrid_search函数
+            # Import run_hybrid_search function
             from app.core.memory.src.search import run_hybrid_search
             
-            # 合并参数，优先使用传入的参数
+            # Merge parameters, prioritize passed parameters
             final_params = {
                 "query_text": context,
                 "search_type": search_type,
                 "end_user_id": end_user_id or search_params.get("end_user_id"),
                 "limit": limit or search_params.get("limit", 10),
                 "include": search_params.get("include", ["summaries", "statements", "chunks", "entities"]),
-                "output_path": None,  # 不保存到文件
+                "output_path": None,  # Don't save to file
                 "memory_config": memory_config,
                 "rerank_alpha": rerank_alpha,
                 "use_forgetting_rerank": use_forgetting_rerank,
                 "use_llm_rerank": use_llm_rerank
             }
             
-            # 执行混合检索
+            # Execute hybrid retrieval
             raw_results = await run_hybrid_search(**final_params)
             
-            # 清理结果中不需要的字段
+            # Clean unnecessary fields from results
             if clean_output:
                 cleaned_results = clean_result_fields(raw_results)
             else:
                 cleaned_results = raw_results
             
-            # 格式化返回结果
+            # Format return results
             formatted_results = {
                 "search_query": context,
                 "search_type": search_type,
                 "results": cleaned_results
             }
-            
+
             return json.dumps(formatted_results, ensure_ascii=False, indent=2, default=str)
-            
+
         except Exception as e:
             error_result = {
                 "error": f"混合检索失败: {str(e)}",
@@ -275,38 +344,52 @@ def create_hybrid_retrieval_tool_async(memory_config, **search_params):
                 "timestamp": datetime.now().isoformat()
             }
             return json.dumps(error_result, ensure_ascii=False, indent=2)
-    
+
     return HybridSearch
 
 
 def create_hybrid_retrieval_tool_sync(memory_config, **search_params):
     """
-    创建同步版本的混合检索工具，优化输出格式并过滤不需要的字段
+    Create synchronous version of hybrid retrieval tool, optimize output format and filter unnecessary fields
+
+    Creates a synchronous wrapper around the async hybrid search functionality,
+    making it compatible with synchronous tool execution environments.
     
     Args:
-        memory_config: 内存配置对象
-        **search_params: 搜索参数
+        memory_config: Memory configuration object containing search settings
+        **search_params: Search parameters for configuration
+
+    Returns:
+        function: Configured HybridSearchSync tool function
     """
+
     @tool
     def HybridSearchSync(
-        context: str, 
-        search_type: str = "hybrid",
-        limit: int = 10,
-        end_user_id: str = None,
-        clean_output: bool = True
+            context: str,
+            search_type: str = "hybrid",
+            limit: int = 10,
+            end_user_id: str = None,
+            clean_output: bool = True
     ) -> str:
         """
-        优化的混合检索工具（同步版本），自动过滤不需要的元数据字段
+        Optimized hybrid retrieval tool (synchronous version), automatically filters unnecessary metadata fields
+
+        Provides the same hybrid search capabilities as the async version but in a
+        synchronous execution context. Automatically handles async-to-sync conversion.
         
         Args:
-            context: 查询内容
-            search_type: 搜索类型 ('keyword', 'embedding', 'hybrid')
-            limit: 结果数量限制
-            end_user_id: 组ID，用于过滤搜索结果
-            clean_output: 是否清理输出中的元数据字段
+            context: Query content for search
+            search_type: Search type ('keyword', 'embedding', 'hybrid')
+            limit: Result quantity limit
+            end_user_id: Group ID for filtering search results
+            clean_output: Whether to clean metadata fields from output
+
+        Returns:
+            str: JSON formatted search results
         """
+
         async def _async_search():
-            # 创建异步工具并执行
+            # Create async tool and execute
             async_tool = create_hybrid_retrieval_tool_async(memory_config, **search_params)
             return await async_tool.ainvoke({
                 "context": context,
@@ -315,7 +398,7 @@ def create_hybrid_retrieval_tool_sync(memory_config, **search_params):
                 "end_user_id": end_user_id,
                 "clean_output": clean_output
             })
-        
+
         return asyncio.run(_async_search())
-    
-    return HybridSearchSync
+
+    return HybridSearchSync

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

@@ -1,20 +1,28 @@
 import json
 
 from langchain_core.messages import HumanMessage, AIMessage
-async def format_parsing(messages: list,type:str='string'):
+
+
+async def format_parsing(messages: list, type: str = 'string'):
     """
-    格式化解析消息列表
+    Format and parse message lists into different output types
+
+    Processes message lists from storage and converts them into either string format
+    or dictionary format based on the specified type parameter. Handles JSON parsing
+    and role-based message organization.
     
     Args:
-        messages: 消息列表
-        type: 返回类型 ('string' 或 'dict')
+        messages: List of message objects from storage containing message data
+        type: Return type specification ('string' for text format, 'dict' for key-value pairs)
         
     Returns:
-        格式化后的消息列表
+        list: Formatted message list in the specified format
+            - 'string': List of formatted text messages with role prefixes
+            - 'dict': List of dictionaries mapping user messages to AI responses
     """
     result = []
-    user=[]
-    ai=[]
+    user = []
+    ai = []
 
     for message in messages:
         hstory_messages = message['messages']
@@ -24,25 +32,38 @@ async def format_parsing(messages: list,type:str='string'):
                 role = content['role']
                 content = content['content']
                 if type == "string":
-                    if role == 'human' or role=="user":
+                    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)
+                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})
+        for key, values in zip(user, ai):
+            result.append({key: values})
     return result
 
+
 async def messages_parse(messages: list | dict):
-    user=[]
-    ai=[]
-    database=[]
+    """
+    Parse messages from storage format into user-AI conversation pairs
+
+    Extracts and organizes conversation data from stored message format,
+    separating user and AI messages and pairing them for database storage.
+
+    Args:
+        messages: List or dictionary containing stored message data with Query fields
+
+    Returns:
+        list: List of dictionaries containing user-AI message pairs for database storage
+    """
+    user = []
+    ai = []
+    database = []
     for message in messages:
         Query = message['Query']
         Query = json.loads(Query)
@@ -54,10 +75,23 @@ async def messages_parse(messages: list | dict):
                 ai.append(data['content'])
     for key, values in zip(user, ai):
         database.append({key, values})
-    return  database
+    return database
 
 
-async def agent_chat_messages(user_content,ai_content):
+async def agent_chat_messages(user_content, ai_content):
+    """
+    Create structured chat message format for agent conversations
+
+    Formats user and AI content into a standardized message structure suitable
+    for agent processing and storage. Creates role-based message objects.
+
+    Args:
+        user_content: User's message content string
+        ai_content: AI's response content string
+
+    Returns:
+        list: List of structured message dictionaries with role and content fields
+    """
     messages = [
         {
             "role": "user",

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

@@ -13,7 +13,6 @@ 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.services.memory_config_service import MemoryConfigService
 
-
 warnings.filterwarnings("ignore", category=RuntimeWarning)
 logger = get_agent_logger(__name__)
 
@@ -42,10 +41,26 @@ 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
+
+async def long_term_storage(long_term_type: str = "chunk", langchain_messages: list = [], memory_config: str = '',
+                            end_user_id: str = '', scope: int = 6):
+    """
+    Handle long-term memory storage with different strategies
+
+    Supports multiple storage strategies including chunk-based, time-based,
+    and aggregate judgment approaches for long-term memory persistence.
+
+    Args:
+        long_term_type: Storage strategy type ('chunk', 'time', 'aggregate')
+        langchain_messages: List of messages to store
+        memory_config: Memory configuration identifier
+        end_user_id: User group identifier
+        scope: Scope parameter for chunk-based storage (default: 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))
+    write_store.save_session_write(end_user_id, langchain_messages)
     # 获取数据库会话
     with get_db_context() as db_session:
         config_service = MemoryConfigService(db_session)
@@ -53,26 +68,39 @@ async def long_term_storage(long_term_type:str="chunk",langchain_messages:list=[
             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':
-            """方案三：聚合判断"""
+        if long_term_type == AgentMemory_Long_Term.STRATEGY_CHUNK:
+            '''Strategy 1: Dialogue window with 6 rounds of conversation'''
+            await window_dialogue(end_user_id, langchain_messages, memory_config, scope)
+        if long_term_type == AgentMemory_Long_Term.STRATEGY_TIME:
+            """Time-based strategy"""
+            await memory_long_term_storage(end_user_id, memory_config, AgentMemory_Long_Term.TIME_SCOPE)
+        if long_term_type == AgentMemory_Long_Term.STRATEGY_AGGREGATE:
+            """Strategy 3: Aggregate judgment"""
             await aggregate_judgment(end_user_id, langchain_messages, memory_config)
 
 
+async def write_long_term(storage_type, end_user_id, message_chat, aimessages, user_rag_memory_id, actual_config_id):
+    """
+    Write long-term memory with different storage types
 
-async def write_long_term(storage_type,end_user_id,message_chat,aimessages,user_rag_memory_id,actual_config_id):
+    Handles both RAG-based storage and traditional memory storage approaches.
+    For traditional storage, uses chunk-based strategy with paired user-AI messages.
+
+    Args:
+        storage_type: Type of storage (RAG or traditional)
+        end_user_id: User group identifier
+        message_chat: User message content
+        aimessages: AI response messages
+        user_rag_memory_id: RAG memory identifier
+        actual_config_id: Actual configuration 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
+    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 回复配对，一次性写入完整对话）
+        # AI reply writing (user messages and AI replies paired, written as complete dialogue at once)
         CHUNK = AgentMemory_Long_Term.STRATEGY_CHUNK
         SCOPE = AgentMemory_Long_Term.DEFAULT_SCOPE
         long_term_messages = await agent_chat_messages(message_chat, aimessages)
@@ -101,4 +129,4 @@ async def write_long_term(storage_type,end_user_id,message_chat,aimessages,user_
 #
 # if __name__ == "__main__":
 #     import asyncio
-#     asyncio.run(main())
+#     asyncio.run(main())

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
+        config_id: Configuration ID for processing (used to load pruning config)
 
     Returns:
         List of DialogData objects with generated chunks
@@ -57,6 +57,63 @@ 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

@@ -1,56 +0,0 @@
-
-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

@@ -8,10 +8,11 @@ from langgraph.graph import add_messages
 
 PROJECT_ROOT_ = str(Path(__file__).resolve().parents[3])
 
+
 class WriteState(TypedDict):
-    '''
+    """
     Langgrapg Writing TypedDict
-    '''
+    """
     messages: Annotated[list[AnyMessage], add_messages]
     end_user_id: str
     errors: list[dict]  # Track errors: [{"tool": "tool_name", "error": "message"}]
@@ -20,6 +21,7 @@ class WriteState(TypedDict):
     data: str
     language: str  # 语言类型 ("zh" 中文, "en" 英文)
 
+
 class ReadState(TypedDict):
     """
     LangGraph 工作流状态定义
@@ -43,18 +45,20 @@ class ReadState(TypedDict):
     config_id: str
     data: str  # 新增字段用于传递内容
     spit_data: dict  # 新增字段用于传递问题分解结果
-    problem_extension:dict
+    problem_extension: dict
     storage_type: str
     user_rag_memory_id: str
     llm_id: str
     embedding_id: str
     memory_config: object  # 新增字段用于传递内存配置对象
-    retrieve:dict
+    retrieve: dict
     RetrieveSummary: dict
     InputSummary: dict
     verify: dict
     SummaryFails: dict
     summary: dict
+
+
 class COUNTState:
     """
     工作流对话检索内容计数器
@@ -99,6 +103,7 @@ class COUNTState:
         self.total = 0
         print("[COUNTState] 已重置为 0")
 
+
 def deduplicate_entries(entries):
     seen = set()
     deduped = []
@@ -109,6 +114,7 @@ def deduplicate_entries(entries):
             deduped.append(entry)
     return deduped
 
+
 def merge_to_key_value_pairs(data, query_key, result_key):
     grouped = defaultdict(list)
     for item in data:
@@ -142,4 +148,4 @@ def convert_extended_question_to_question(data):
         return [convert_extended_question_to_question(item) for item in data]
     else:
         # 其他类型直接返回
-        return data
+        return data

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

@@ -165,7 +165,9 @@ async def write(
                 statement_chunk_edges=all_statement_chunk_edges,
                 statement_entity_edges=all_statement_entity_edges,
                 entity_edges=all_entity_entity_edges,
-                connector=neo4j_connector
+                connector=neo4j_connector,
+                config_id=config_id,
+                llm_model_id=str(memory_config.llm_model_id) if memory_config.llm_model_id else None,
             )
             if success:
                 logger.info("Successfully saved all data to Neo4j")
@@ -225,5 +227,24 @@ 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")

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

@@ -1,9 +1,12 @@
 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
@@ -16,6 +19,10 @@ 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筛选标签列表，仅保留具有代表性的核心名词。
@@ -85,10 +92,74 @@ async def filter_tags_with_llm(tags: List[str], end_user_id: str) -> List[str]:
         return structured_response.meaningful_tags
 
     except Exception as e:
-        print(f"LLM筛选过程中发生错误: {e}")
+        logger.error(f"LLM筛选过程中发生错误: {e}", exc_info=True)
         # 在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,
@@ -139,14 +210,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 = 40, by_user: bool = False) -> List[Tuple[str, int]]:
+async def get_hot_memory_tags(end_user_id: str, limit: int = 10, by_user: bool = False) -> List[Tuple[str, int]]:
     """
     获取原始标签，然后使用LLM进行筛选，返回最终的热门标签列表。
-    查询更多的标签(limit=40)给LLM提供更丰富的上下文进行筛选。
+    查询更多的标签(40条)给LLM提供更丰富的上下文进行筛选，但最终返回数量由limit参数控制。
 
     Args:
         end_user_id: 必需参数。如果by_user=False，则为end_user_id；如果by_user=True，则为user_id
-        limit: 返回的标签数量限制
+        limit: 最终返回的标签数量限制（默认10）
         by_user: 是否按user_id查询（默认False，按end_user_id查询）
         
     Raises:
@@ -161,8 +232,9 @@ async def get_hot_memory_tags(end_user_id: str, limit: int = 40, by_user: bool =
     # 使用项目的Neo4jConnector
     connector = Neo4jConnector()
     try:
-        # 1. 从数据库获取原始排名靠前的标签
-        raw_tags_with_freq = await get_raw_tags_from_db(connector, end_user_id, limit, by_user=by_user)
+        # 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)
         if not raw_tags_with_freq:
             return []
 
@@ -177,7 +249,61 @@ async def get_hot_memory_tags(end_user_id: str, limit: int = 40, by_user: bool =
             if tag in meaningful_tag_names:
                 final_tags.append((tag, freq))
 
-        return final_tags
+        # 4. 限制返回的标签数量
+        return final_tags[:limit]
     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/models/config_models.py

@@ -10,7 +10,7 @@ Classes:
     TemporalSearchParams: Parameters for temporal search queries
 """
 
-from typing import Optional
+from typing import Optional, List
 from pydantic import BaseModel, Field
 
 
@@ -55,17 +55,26 @@ class PruningConfig(BaseModel):
 
     Attributes:
         pruning_switch: Enable or disable semantic pruning
-        pruning_scene: Scene type for pruning ('education', 'online_service', 'outbound')
+        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_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: one of 'education', 'online_service', 'outbound'.",
+        description="Scene for pruning: built-in key or custom scene_name from ontology_scene.",
     )
     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/storage_services/clustering_engine/__init__.py

@@ -0,0 +1,3 @@
+from app.core.memory.storage_services.clustering_engine.label_propagation import LabelPropagationEngine
+
+__all__ = ["LabelPropagationEngine"]

api/app/core/memory/storage_services/clustering_engine/label_propagation.py

@@ -0,0 +1,484 @@
+"""标签传播聚类引擎
+
+基于 ZEP 论文的动态标签传播算法，对 Neo4j 中的 ExtractedEntity 节点进行社区聚类。
+
+支持两种模式：
+- 全量初始化（full_clustering）：首次运行，对所有实体做完整 LPA 迭代
+- 增量更新（incremental_update）：新实体到达时，只处理新实体及其邻居
+"""
+
+import logging
+import uuid
+from math import sqrt
+from typing import Dict, List, Optional
+
+from app.repositories.neo4j.community_repository import CommunityRepository
+from app.repositories.neo4j.neo4j_connector import Neo4jConnector
+
+logger = logging.getLogger(__name__)
+
+# 全量迭代最大轮数，防止不收敛
+MAX_ITERATIONS = 10
+# 社区摘要核心实体数量
+CORE_ENTITY_LIMIT = 5
+
+
+def _cosine_similarity(v1: Optional[List[float]], v2: Optional[List[float]]) -> float:
+    """计算两个向量的余弦相似度，任一为空则返回 0。"""
+    if not v1 or not v2 or len(v1) != len(v2):
+        return 0.0
+    dot = sum(a * b for a, b in zip(v1, v2))
+    norm1 = sqrt(sum(a * a for a in v1))
+    norm2 = sqrt(sum(b * b for b in v2))
+    if norm1 == 0 or norm2 == 0:
+        return 0.0
+    return dot / (norm1 * norm2)
+
+
+def _weighted_vote(
+    neighbors: List[Dict],
+    self_embedding: Optional[List[float]],
+) -> Optional[str]:
+    """
+    加权多数投票，选出得票最高的社区。
+
+    权重 = 语义相似度（name_embedding 余弦）* activation_value 加成
+    没有 community_id 的邻居不参与投票。
+    """
+    votes: Dict[str, float] = {}
+    for nb in neighbors:
+        cid = nb.get("community_id")
+        if not cid:
+            continue
+        sem = _cosine_similarity(self_embedding, nb.get("name_embedding"))
+        act = nb.get("activation_value") or 0.5
+        # 语义相似度权重 0.6，激活值权重 0.4
+        weight = 0.6 * sem + 0.4 * act
+        votes[cid] = votes.get(cid, 0.0) + weight
+
+    if not votes:
+        return None
+    return max(votes, key=votes.__getitem__)
+
+
+class LabelPropagationEngine:
+    """标签传播聚类引擎"""
+
+    def __init__(
+        self,
+        connector: Neo4jConnector,
+        config_id: Optional[str] = None,
+        llm_model_id: Optional[str] = None,
+    ):
+        self.connector = connector
+        self.repo = CommunityRepository(connector)
+        self.config_id = config_id
+        self.llm_model_id = llm_model_id
+
+    # ──────────────────────────────────────────────────────────────────────────
+    # 公开接口
+    # ──────────────────────────────────────────────────────────────────────────
+
+    async def run(
+        self,
+        end_user_id: str,
+        new_entity_ids: Optional[List[str]] = None,
+    ) -> None:
+        """
+        统一入口：自动判断全量还是增量。
+
+        - 若该用户尚无 Community 节点 → 全量初始化
+        - 否则 → 增量更新（仅处理 new_entity_ids）
+        """
+        has_communities = await self.repo.has_communities(end_user_id)
+        if not has_communities:
+            logger.info(f"[Clustering] 用户 {end_user_id} 首次聚类，执行全量初始化")
+            await self.full_clustering(end_user_id)
+        else:
+            if new_entity_ids:
+                logger.info(
+                    f"[Clustering] 增量更新，新实体数: {len(new_entity_ids)}"
+                )
+                await self.incremental_update(new_entity_ids, end_user_id)
+
+    async def full_clustering(self, end_user_id: str) -> None:
+        """
+        全量标签传播初始化。
+
+        1. 拉取所有实体，初始化每个实体为独立社区
+        2. 迭代：每轮对所有实体做邻居投票，更新社区标签
+        3. 直到标签不再变化或达到 MAX_ITERATIONS
+        4. 将最终标签写入 Neo4j
+        """
+        entities = await self.repo.get_all_entities(end_user_id)
+        if not entities:
+            logger.info(f"[Clustering] 用户 {end_user_id} 无实体，跳过全量聚类")
+            return
+
+        # 初始化：每个实体持有自己 id 作为社区标签
+        labels: Dict[str, str] = {e["id"]: e["id"] for e in entities}
+        embeddings: Dict[str, Optional[List[float]]] = {
+            e["id"]: e.get("name_embedding") for e in entities
+        }
+
+        # 预加载所有实体的邻居，避免迭代内 O(iterations * |E|) 次 Neo4j 往返
+        logger.info(f"[Clustering] 预加载 {len(entities)} 个实体的邻居图...")
+        neighbors_cache: Dict[str, List[Dict]] = await self.repo.get_all_entity_neighbors_batch(end_user_id)
+        logger.info(f"[Clustering] 邻居预加载完成，覆盖实体数: {len(neighbors_cache)}")
+
+        for iteration in range(MAX_ITERATIONS):
+            changed = 0
+            # 随机顺序（Python dict 在 3.7+ 保持插入顺序，这里直接遍历）
+            for entity in entities:
+                eid = entity["id"]
+                # 直接从缓存取邻居，不再发起 Neo4j 查询
+                neighbors = neighbors_cache.get(eid, [])
+
+                # 将邻居的当前内存标签注入（覆盖 Neo4j 中的旧值）
+                enriched = []
+                for nb in neighbors:
+                    nb_copy = dict(nb)
+                    nb_copy["community_id"] = labels.get(nb["id"], nb.get("community_id"))
+                    enriched.append(nb_copy)
+
+                new_label = _weighted_vote(enriched, embeddings.get(eid))
+                if new_label and new_label != labels[eid]:
+                    labels[eid] = new_label
+                    changed += 1
+
+            logger.info(
+                f"[Clustering] 全量迭代 {iteration + 1}/{MAX_ITERATIONS}，"
+                f"标签变化数: {changed}"
+            )
+            if changed == 0:
+                logger.info("[Clustering] 标签已收敛，提前结束迭代")
+                break
+
+        # 将最终标签写入 Neo4j
+        await self._flush_labels(labels, end_user_id)
+        pre_merge_count = len(set(labels.values()))
+        logger.info(
+            f"[Clustering] 全量迭代完成，共 {pre_merge_count} 个社区，"
+            f"{len(labels)} 个实体，开始后处理合并"
+        )
+
+        # 全量初始化后做一轮社区合并（基于 name_embedding 余弦相似度）
+        all_community_ids = list(set(labels.values()))
+        await self._evaluate_merge(all_community_ids, end_user_id)
+
+        logger.info(
+            f"[Clustering] 全量聚类完成，合并前 {pre_merge_count} 个社区，"
+            f"{len(labels)} 个实体"
+        )
+        # 为所有社区生成元数据
+        # 注意：_evaluate_merge 后部分社区已被合并消解，需重新从 Neo4j 查询实际存活的社区
+        # 不能复用 labels.values()，那里包含已被 dissolve 的旧社区 ID
+        surviving_communities = await self.repo.get_all_entities(end_user_id)
+        surviving_community_ids = list({
+            e.get("community_id") for e in surviving_communities
+            if e.get("community_id")
+        })
+        logger.info(f"[Clustering] 合并后实际存活社区数: {len(surviving_community_ids)}")
+        for cid in surviving_community_ids:
+            await self._generate_community_metadata(cid, end_user_id)
+
+    async def incremental_update(
+        self, new_entity_ids: List[str], end_user_id: str
+    ) -> None:
+        """
+        增量更新：只处理新实体及其邻居，不重跑全图。
+
+        1. 对每个新实体查询邻居
+        2. 加权多数投票决定社区归属
+        3. 若邻居无社区 → 创建新社区
+        4. 若邻居分属多个社区 → 评估是否合并
+        """
+        for entity_id in new_entity_ids:
+            await self._process_single_entity(entity_id, end_user_id)
+
+    # ──────────────────────────────────────────────────────────────────────────
+    # 内部方法
+    # ──────────────────────────────────────────────────────────────────────────
+
+    async def _process_single_entity(
+        self, entity_id: str, end_user_id: str
+    ) -> None:
+        """处理单个新实体的社区分配。"""
+        neighbors = await self.repo.get_entity_neighbors(entity_id, end_user_id)
+
+        # 查询自身 embedding（从邻居查询结果中无法获取，需单独查）
+        self_embedding = await self._get_entity_embedding(entity_id, end_user_id)
+
+        if not neighbors:
+            # 孤立实体：创建单成员社区
+            new_cid = self._new_community_id()
+            await self.repo.upsert_community(new_cid, end_user_id, member_count=1)
+            await self.repo.assign_entity_to_community(entity_id, new_cid, end_user_id)
+            logger.debug(f"[Clustering] 孤立实体 {entity_id} → 新社区 {new_cid}")
+            return
+
+        # 统计邻居社区分布
+        community_ids_in_neighbors = set(
+            nb["community_id"] for nb in neighbors if nb.get("community_id")
+        )
+
+        target_cid = _weighted_vote(neighbors, self_embedding)
+
+        if target_cid is None:
+            # 邻居都没有社区，连同新实体一起创建新社区
+            new_cid = self._new_community_id()
+            await self.repo.upsert_community(new_cid, end_user_id)
+            await self.repo.assign_entity_to_community(entity_id, new_cid, end_user_id)
+            for nb in neighbors:
+                await self.repo.assign_entity_to_community(
+                    nb["id"], new_cid, end_user_id
+                )
+            await self.repo.refresh_member_count(new_cid, end_user_id)
+            logger.debug(
+                f"[Clustering] 新实体 {entity_id} 与 {len(neighbors)} 个无社区邻居 → 新社区 {new_cid}"
+            )
+            await self._generate_community_metadata(new_cid, end_user_id)
+        else:
+            # 加入得票最多的社区
+            await self.repo.assign_entity_to_community(entity_id, target_cid, end_user_id)
+            await self.repo.refresh_member_count(target_cid, end_user_id)
+            logger.debug(f"[Clustering] 新实体 {entity_id} → 社区 {target_cid}")
+
+            # 若邻居分属多个社区，评估合并
+            if len(community_ids_in_neighbors) > 1:
+                await self._evaluate_merge(
+                    list(community_ids_in_neighbors), end_user_id
+                )
+            await self._generate_community_metadata(target_cid, end_user_id)
+
+    async def _evaluate_merge(
+        self, community_ids: List[str], end_user_id: str
+    ) -> None:
+        """
+        评估多个社区是否应合并。
+
+        策略：计算各社区成员 embedding 的平均向量，若两两余弦相似度 > 0.75 则合并。
+        合并时保留成员数最多的社区，其余成员迁移过来。
+
+        全量场景（社区数 > 20）使用批量查询，避免 N 次数据库往返。
+        """
+        MERGE_THRESHOLD = 0.85
+        BATCH_THRESHOLD = 20  # 超过此数量走批量查询
+
+        community_embeddings: Dict[str, Optional[List[float]]] = {}
+        community_sizes: Dict[str, int] = {}
+
+        if len(community_ids) > BATCH_THRESHOLD:
+            # 批量查询：一次拉取所有社区成员
+            all_members = await self.repo.get_all_community_members_batch(
+                community_ids, end_user_id
+            )
+            for cid in community_ids:
+                members = all_members.get(cid, [])
+                community_sizes[cid] = len(members)
+                valid_embeddings = [
+                    m["name_embedding"] for m in members if m.get("name_embedding")
+                ]
+                if valid_embeddings:
+                    dim = len(valid_embeddings[0])
+                    community_embeddings[cid] = [
+                        sum(e[i] for e in valid_embeddings) / len(valid_embeddings)
+                        for i in range(dim)
+                    ]
+                else:
+                    community_embeddings[cid] = None
+        else:
+            # 增量场景：逐个查询
+            for cid in community_ids:
+                members = await self.repo.get_community_members(cid, end_user_id)
+                community_sizes[cid] = len(members)
+                valid_embeddings = [
+                    m["name_embedding"] for m in members if m.get("name_embedding")
+                ]
+                if valid_embeddings:
+                    dim = len(valid_embeddings[0])
+                    community_embeddings[cid] = [
+                        sum(e[i] for e in valid_embeddings) / len(valid_embeddings)
+                        for i in range(dim)
+                    ]
+                else:
+                    community_embeddings[cid] = None
+
+        # 找出应合并的社区对
+        to_merge: List[tuple] = []
+        cids = list(community_ids)
+        for i in range(len(cids)):
+            for j in range(i + 1, len(cids)):
+                sim = _cosine_similarity(
+                    community_embeddings[cids[i]],
+                    community_embeddings[cids[j]],
+                )
+                if sim > MERGE_THRESHOLD:
+                    to_merge.append((cids[i], cids[j]))
+
+        logger.info(f"[Clustering] 发现 {len(to_merge)} 对可合并社区")
+
+        # 执行合并：逐对处理，每次合并后重新计算合并社区的平均向量
+        # 避免 union-find 链式传递导致语义不相关的社区被间接合并
+        # （A≈B、B≈C 不代表 A≈C，不能因传递性把 A/B/C 全部合并）
+        merged_into: Dict[str, str] = {}  # dissolve → keep 的最终映射
+
+        def get_root(x: str) -> str:
+            """路径压缩，找到 x 当前所属的根社区。"""
+            while x in merged_into:
+                merged_into[x] = merged_into.get(merged_into[x], merged_into[x])
+                x = merged_into[x]
+            return x
+
+        for c1, c2 in to_merge:
+            root1, root2 = get_root(c1), get_root(c2)
+            if root1 == root2:
+                continue
+
+            # 用合并后的最新平均向量重新验证相似度
+            # 防止链式传递：A≈B 合并后 B 的向量已更新，C 必须和新 B 相似才能合并
+            current_sim = _cosine_similarity(
+                community_embeddings.get(root1),
+                community_embeddings.get(root2),
+            )
+            if current_sim <= MERGE_THRESHOLD:
+                # 合并后向量已漂移，不再满足阈值，跳过
+                logger.debug(
+                    f"[Clustering] 跳过合并 {root1} ↔ {root2}，"
+                    f"当前相似度 {current_sim:.3f} ≤ {MERGE_THRESHOLD}"
+                )
+                continue
+
+            keep = root1 if community_sizes.get(root1, 0) >= community_sizes.get(root2, 0) else root2
+            dissolve = root2 if keep == root1 else root1
+            merged_into[dissolve] = keep
+
+            members = await self.repo.get_community_members(dissolve, end_user_id)
+            for m in members:
+                await self.repo.assign_entity_to_community(m["id"], keep, end_user_id)
+
+            # 合并后重新计算 keep 的平均向量（加权平均）
+            keep_emb = community_embeddings.get(keep)
+            dissolve_emb = community_embeddings.get(dissolve)
+            keep_size = community_sizes.get(keep, 0)
+            dissolve_size = community_sizes.get(dissolve, 0)
+            total_size = keep_size + dissolve_size
+            if keep_emb and dissolve_emb and total_size > 0:
+                dim = len(keep_emb)
+                community_embeddings[keep] = [
+                    (keep_emb[i] * keep_size + dissolve_emb[i] * dissolve_size) / total_size
+                    for i in range(dim)
+                ]
+            community_embeddings[dissolve] = None
+
+            community_sizes[keep] = total_size
+            community_sizes[dissolve] = 0
+            await self.repo.refresh_member_count(keep, end_user_id)
+            logger.info(
+                f"[Clustering] 社区合并: {dissolve} → {keep}，"
+                f"相似度={current_sim:.3f}，迁移 {len(members)} 个成员"
+            )
+
+    async def _flush_labels(
+        self, labels: Dict[str, str], end_user_id: str
+    ) -> None:
+        """将内存中的标签批量写入 Neo4j。"""
+        # 先创建所有唯一社区节点
+        unique_communities = set(labels.values())
+        for cid in unique_communities:
+            await self.repo.upsert_community(cid, end_user_id)
+
+        # 再批量分配实体
+        for entity_id, community_id in labels.items():
+            await self.repo.assign_entity_to_community(
+                entity_id, community_id, end_user_id
+            )
+
+        # 刷新成员数
+        for cid in unique_communities:
+            await self.repo.refresh_member_count(cid, end_user_id)
+
+    async def _get_entity_embedding(
+        self, entity_id: str, end_user_id: str
+    ) -> Optional[List[float]]:
+        """查询单个实体的 name_embedding。"""
+        try:
+            result = await self.connector.execute_query(
+                "MATCH (e:ExtractedEntity {id: $eid, end_user_id: $uid}) "
+                "RETURN e.name_embedding AS name_embedding",
+                eid=entity_id,
+                uid=end_user_id,
+            )
+            return result[0]["name_embedding"] if result else None
+        except Exception:
+            return None
+
+    async def _generate_community_metadata(
+        self, community_id: str, end_user_id: str
+    ) -> None:
+        """
+        为社区生成并写入元数据：名称、摘要、核心实体。
+
+        - core_entities：按 activation_value 排序取 top-N 实体名称列表（无需 LLM）
+        - name / summary：若有 llm_model_id 则调用 LLM 生成，否则用实体名称拼接兜底
+        """
+        try:
+            members = await self.repo.get_community_members(community_id, end_user_id)
+            if not members:
+                return
+
+            # 核心实体：按 activation_value 降序取 top-N
+            sorted_members = sorted(
+                members,
+                key=lambda m: m.get("activation_value") or 0,
+                reverse=True,
+            )
+            core_entities = [m["name"] for m in sorted_members[:CORE_ENTITY_LIMIT] if m.get("name")]
+            all_names = [m["name"] for m in members if m.get("name")]
+
+            name = "、".join(core_entities[:3]) if core_entities else community_id[:8]
+            summary = f"包含实体：{', '.join(all_names)}"
+
+            # 若有 LLM 配置，调用 LLM 生成更好的名称和摘要
+            if self.llm_model_id:
+                try:
+                    from app.db import get_db_context
+                    from app.core.memory.utils.llm.llm_utils import MemoryClientFactory
+
+                    entity_list_str = "、".join(all_names)
+                    prompt = (
+                        f"以下是一组语义相关的实体：{entity_list_str}\n\n"
+                        f"请为这组实体所代表的主题：\n"
+                        f"1. 起一个简洁的中文名称（不超过10个字）\n"
+                        f"2. 写一句话摘要（不超过50个字）\n\n"
+                        f"严格按以下格式输出，不要有其他内容：\n"
+                        f"名称：<名称>\n摘要：<摘要>"
+                    )
+                    with get_db_context() as db:
+                        factory = MemoryClientFactory(db)
+                        llm_client = factory.get_llm_client(self.llm_model_id)
+                        response = await llm_client.chat([{"role": "user", "content": prompt}])
+                        text = response.content if hasattr(response, "content") else str(response)
+
+                    for line in text.strip().splitlines():
+                        if line.startswith("名称："):
+                            name = line[3:].strip()
+                        elif line.startswith("摘要："):
+                            summary = line[3:].strip()
+                except Exception as e:
+                    logger.warning(f"[Clustering] LLM 生成社区元数据失败，使用兜底值: {e}")
+
+            await self.repo.update_community_metadata(
+                community_id=community_id,
+                end_user_id=end_user_id,
+                name=name,
+                summary=summary,
+                core_entities=core_entities,
+            )
+            logger.debug(f"[Clustering] 社区 {community_id} 元数据已更新: name={name}")
+        except Exception as e:
+            logger.error(f"[Clustering] _generate_community_metadata failed for {community_id}: {e}")
+
+    @staticmethod
+    def _new_community_id() -> str:
+        return str(uuid.uuid4())

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

@@ -5,20 +5,27 @@
 - 对话级一次性抽取判定相关性
 - 仅对"不相关对话"的消息按比例删除
 - 重要信息（时间、编号、金额、联系方式、地址等）优先保留
+- 改进版：增强重要性判断、智能填充消息识别、问答对保护、并发优化
 """
 
+import asyncio
 import os
 import hashlib
 import json
 import re
+from collections import OrderedDict
 from datetime import datetime
-from typing import List, Optional
+from typing import List, Optional, Dict, Tuple, Set
 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):
@@ -26,6 +33,7 @@ class DialogExtractionResponse(BaseModel):
 
     - is_related：对话与场景的相关性判定。
     - times / ids / amounts / contacts / addresses / keywords：重要信息片段，用来在不相关对话中保留关键消息。
+    - preserve_keywords：情绪/兴趣/爱好/个人观点相关词，包含这些词的消息必须强制保留。
     """
     is_related: bool = Field(...)
     times: List[str] = Field(default_factory=list)
@@ -34,6 +42,24 @@ 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:
@@ -43,109 +69,280 @@ class SemanticPruner:
     重要信息（时间、编号、金额、联系方式、地址等）优先保留。
     """
 
-    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)
+    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
         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")
-        # 对话抽取缓存：避免同一对话重复调用 LLM / 重复渲染
-        self._dialog_extract_cache: dict[str, DialogExtractionResponse] = {}
+        
+        # 对话抽取缓存：使用 OrderedDict 实现 LRU 缓存
+        self._dialog_extract_cache: OrderedDict[str, DialogExtractionResponse] = OrderedDict()
+        self._cache_max_size = 1000  # 缓存大小限制
+        
         # 运行日志：收集关键终端输出，便于写入 JSON
         self.run_logs: List[str] = []
-        # 采用顺序处理，移除并发配置以简化与稳定执行
 
-    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
+    # _is_important_message 和 _importance_score 已移除：
+    # 重要性判断完全由 extracat_Pruning.jinja2 提示词 + LLM 的 preserve_tokens 机制承担。
+    # LLM 根据注入的本体工程类型语义识别需要保护的内容，无需硬编码正则规则。
 
     def _is_filler_message(self, message: ConversationMessage) -> bool:
-        """检测典型寒暄/口头禅/确认类短消息，用于跳过LLM分类以加速。
+        """检测典型寒暄/口头禅/确认类短消息。
 
-        满足以下之一视为填充消息：
-        - 纯标点或长度很短（<= 4 个汉字或 <= 8 个字符）且不包含数字或关键实体；
-        - 常见词：你好/您好/在吗/嗯/嗯嗯/哦/好的/好/行/可以/不可以/谢谢/拜拜/再见/哈哈/呵呵/哈哈哈/。。。/？？。
+        判断顺序：
+        1. 空消息
+        2. 场景特定填充词库精确匹配
+        3. 常见寒暄精确匹配
+        4. 纯表情/标点
         """
-        import re
         t = message.msg.strip()
         if not t:
             return True
-        # 常见填充语
-        fillers = [
-            "你好", "您好", "在吗", "嗯", "嗯嗯", "哦", "好的", "好", "行", "可以", "不可以", "谢谢",
-            "拜拜", "再见", "哈哈", "呵呵", "哈哈哈", "。。。", "??", "？？"
-        ]
-        if t in fillers:
+
+        # 检查是否在场景特定填充词库中（精确匹配）
+        if t in self.scene_config.filler_phrases:
             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
+
+        # 常见寒暄和问候（精确匹配，避免误删）
+        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
+        
         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:
         """对话级一次性抽取：从整段对话中提取重要信息并判定相关性。
 
-        - 仅使用 LLM 结构化输出；
+        改进版：
+        - LRU缓存管理
+        - 重试机制
+        - 降级策略
         """
         # 缓存命中则直接返回（场景+内容作为键）
         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]
 
-        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})
+        # 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
+        })
         log_prompt_rendering("pruning-extract", rendered)
 
-        # 强制使用 LLM；移除正则回退
+        # 强制使用 LLM
         if not self.llm_client:
             raise RuntimeError("llm_client 未配置；请配置 LLM 以进行结构化抽取。")
 
@@ -153,12 +350,32 @@ class SemanticPruner:
             {"role": "system", "content": "你是一个严谨的场景抽取助手，只输出严格 JSON。"},
             {"role": "user", "content": rendered},
         ]
-        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
+        
+        # 重试机制
+        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
 
     def _msg_matches_tokens(self, message: ConversationMessage, tokens: List[str]) -> bool:
         """判断消息是否包含任意抽取到的重要片段。"""
@@ -184,62 +401,56 @@ class SemanticPruner:
             # 相关对话不剪枝
             return dialog
 
-        # 在不相关对话中，识别重要/不重要消息
-        tokens = extraction.times + extraction.ids + extraction.amounts + extraction.contacts + extraction.addresses + extraction.keywords
+        # 在不相关对话中，LLM 已通过 preserve_tokens 标记需要保护的内容
+        preserve_tokens = (
+            extraction.times + extraction.ids + extraction.amounts +
+            extraction.contacts + extraction.addresses + extraction.keywords +
+            extraction.preserve_keywords
+        )
         msgs = dialog.context.msgs
-        imp_unrel_msgs: List[ConversationMessage] = []
-        unimp_unrel_msgs: List[ConversationMessage] = []
+
+        # 分类：填充 / 其他可删（LLM保护消息通过不加入任何桶来隐式保护）
+        filler_ids: set = set()
+        deletable: List[ConversationMessage] = []
+
         for m in msgs:
-            if self._msg_matches_tokens(m, tokens) or self._is_important_message(m):
-                imp_unrel_msgs.append(m)
+            if self._msg_matches_tokens(m, preserve_tokens):
+                pass  # 保护消息：不加入任何桶，不会被删除
+            elif self._is_filler_message(m):
+                filler_ids.add(id(m))
             else:
-                unimp_unrel_msgs.append(m)
-        # 计算总删除目标数量
+                deletable.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
-        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)
+        max_deletable = min(len(filler_ids) + len(deletable), max(0, total_unrel - 1))
         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)
 
-        # 选取删除集合
-        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)
+        # 优先删填充，再删其他可删消息（按出现顺序）
+        to_delete_ids: set = set()
         for m in msgs:
-            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 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]
         if not kept_msgs and msgs:
             kept_msgs = [msgs[0]]
 
-        deleted_total = actual_unimp_deleted + actual_imp_deleted
+        deleted_total = len(msgs) - len(kept_msgs)
+        protected_count = len(msgs) - len(filler_ids) - len(deletable)
         self._log(
-            f"[剪枝-对话] 对话ID={dialog.id} 总消息={len(msgs)} 删除目标={delete_target} 实删={deleted_total} 保留={len(kept_msgs)}"
+            f"[剪枝-对话] 对话ID={dialog.id} 总消息={len(msgs)} "
+            f"(保护={protected_count} 填充={len(filler_ids)} 可删={len(deletable)}) "
+            f"删除目标={delete_target} 实删={deleted_total} 保留={len(kept_msgs)}"
         )
 
         dialog.context = ConversationContext(msgs=kept_msgs)
@@ -248,12 +459,14 @@ class SemanticPruner:
     async def prune_dataset(self, dialogs: List[DialogData]) -> List[DialogData]:
         """数据集层面：全局消息级剪枝，保留所有对话。
 
-        - 仅在"不相关对话"的范围内执行消息剪枝；相关对话不动。
-        - 只删除"不重要的不相关消息"，重要信息（时间、编号等）强制保留。
-        - 删除总量 = 阈值 * 全部不相关可删消息数，按可删容量比例分配；顺序删除。
-        - 保证每段对话至少保留1条消息，不会删除整段对话。
+        改进版：
+        - 消息级独立判断，每条消息根据场景规则独立评估
+        - 问答对保护已注释（暂不启用，留作观察）
+        - 优化删除策略：填充消息 → 不重要消息 → 低分重要消息
+        - 只删除"不重要的不相关消息"，重要信息（时间、编号等）强制保留
+        - 保证每段对话至少保留1条消息，不会删除整段对话
         """
-        # 如果剪枝功能关闭，直接返回原始数据集。
+        # 如果剪枝功能关闭，直接返回原始数据集
         if not self.config.pruning_switch:
             return dialogs
 
@@ -264,179 +477,139 @@ 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] = []
-        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
+        total_original_msgs = 0
+        total_deleted_msgs = 0
 
-            # 配额分配：按不相关消息占比分配到各对话，但不超过各自容量
-            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:
+        # 并发执行所有对话的 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:
                     break
-                turn += 1
+                to_delete_indices.add(idx)
+                deleted_details.append(f"[{idx}] 填充: '{msg.msg[:50]}'")
 
-            # 应用删除：相关对话不动；不相关按分配先删不重要，再删重要（低分优先）
-            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]
+            # 第二步：如果还需要删除，按出现顺序删可删消息
+            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)
+        
         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:
@@ -448,6 +621,7 @@ 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

@@ -0,0 +1,66 @@
+"""
+场景特定配置 - 统一填充词库
+
+重要性判断已完全交由 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/extraction_orchestrator.py

@@ -1932,17 +1932,17 @@ def preprocess_data(
     Returns:
         经过清洗转换后的 DialogData 列表
     """
-    print("\n=== 数据预处理 ===")
+    logger.debug("=== 数据预处理 ===")
     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)
-        print(f"数据预处理完成！共处理了 {len(cleaned_data)} 条对话数据")
+        logger.debug(f"数据预处理完成！共处理了 {len(cleaned_data)} 条对话数据")
         return cleaned_data
     except Exception as e:
-        print(f"数据预处理过程中出现错误: {e}")
+        logger.error(f"数据预处理过程中出现错误: {e}")
         raise
 
 
@@ -1961,7 +1961,7 @@ async def get_chunked_dialogs_from_preprocessed(
     Returns:
         带 chunks 的 DialogData 列表
     """
-    print(f"\n=== 批量对话分块处理 (使用 {chunker_strategy}) ===")
+    logger.debug(f"=== 批量对话分块处理 (使用 {chunker_strategy}) ===")
     if not data:
         raise ValueError("预处理数据为空，无法进行分块")
         
@@ -1988,6 +1988,7 @@ 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]:
     """包含数据预处理步骤的完整分块流程
     
@@ -2000,11 +2001,12 @@ 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 列表
     """
-    print("\n=== 完整数据处理流程（包含预处理）===")
+    logger.debug("=== 完整数据处理流程（包含预处理）===")
 
     if input_data_path is None:
         input_data_path = os.path.join(
@@ -2030,7 +2032,19 @@ async def get_chunked_dialogs_with_preprocessing(
         from app.core.memory.storage_services.extraction_engine.data_preprocessing.data_pruning import (
             SemanticPruner,
         )
-        pruner = SemanticPruner(llm_client=llm_client)
+        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)
         
         # 记录单对话场景下剪枝前的消息数量
         single_dialog_original_msgs = None
@@ -2043,12 +2057,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)
-            print(
+            logger.debug(
                 f"语义剪枝完成！剩余 1 条对话！原始消息数：{single_dialog_original_msgs}，"
                 f"保留消息数：{remaining_msgs}，删除 {deleted_msgs} 条。"
             )
         else:
-            print(f"语义剪枝完成！剩余 {len(preprocessed_data)} 条对话")
+            logger.debug(f"语义剪枝完成！剩余 {len(preprocessed_data)} 条对话")
             
         # 保存剪枝后的数据
         try:
@@ -2059,9 +2073,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:
-            print(f"保存剪枝结果失败：{se}")
+            logger.error(f"保存剪枝结果失败：{se}")
     except Exception as e:
-        print(f"语义剪枝过程中出现错误，跳过剪枝: {e}")
+        logger.error(f"语义剪枝过程中出现错误，跳过剪枝: {e}")
         
     # 步骤3: 对话分块
     return await get_chunked_dialogs_from_preprocessed(

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

@@ -1,5 +1,7 @@
 import os
-from typing import Optional
+from typing import Optional, List, Any
+from enum import Enum
+from pathlib import Path
 
 from app.core.logging_config import get_memory_logger
 from app.core.memory.models.message_models import DialogData, Chunk
@@ -10,6 +12,20 @@ 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.
 
@@ -17,23 +33,51 @@ class DialogueChunker:
     of different chunking strategies to dialogue data.
     """
 
-    def __init__(self, chunker_strategy: str = "RecursiveChunker", llm_client=None):
+    def __init__(self, chunker_strategy: str = "RecursiveChunker", llm_client: Optional[Any] = None):
         """Initialize the DialogueChunker with a specific chunking strategy.
 
         Args:
             chunker_strategy: The chunking strategy to use (default: RecursiveChunker)
-                             Options: SemanticChunker, RecursiveChunker, LateChunker, NeuralChunker
+                             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
         """
-        self.chunker_strategy = chunker_strategy
-        chunker_config_dict = get_chunker_config(chunker_strategy)
-        self.chunker_config = ChunkerConfig.model_validate(chunker_config_dict)
+        # 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}"
+            )
         
-        if self.chunker_config.chunker_strategy == "LLMChunker":
-            self.chunker_client = ChunkerClient(self.chunker_config, llm_client)
-        else:
-            self.chunker_client = ChunkerClient(self.chunker_config)
+        self.chunker_strategy = chunker_strategy
+        logger.info(f"Initializing DialogueChunker with strategy: {chunker_strategy}")
+        
+        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
 
-    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:
@@ -43,54 +87,125 @@ class DialogueChunker:
             A list of Chunk objects
 
         Raises:
-            ValueError: If chunking fails or returns empty chunks
+            ValueError: If dialogue is invalid or chunking fails
+            Exception: If chunking process encounters an error
         """
-        result_dialogue = await self.chunker_client.generate_chunks(dialogue)
-        chunks = result_dialogue.chunks
-
-        if not chunks or len(chunks) == 0:
+        # Validate input
+        if not dialogue:
+            raise ValueError("dialogue cannot be None")
+        
+        if not dialogue.context or not dialogue.context.msgs:
             raise ValueError(
-                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}"
+                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}"
             )
+        
+        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
 
-        return 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}"
+                )
 
-    def save_chunking_results(self, dialogue: DialogData, output_path: Optional[str] = None) -> str:
+            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:
         """Save the chunking results to a file and return the output path.
 
         Args:
-            dialogue: The processed DialogData object with chunks
-            output_path: Optional path to save the output
+            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)
 
         Returns:
             The path where the output was saved
+            
+        Raises:
+            ValueError: If chunks or dialogue is invalid
+            IOError: If file writing fails
         """
-        if not output_path:
-            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:"
-        ]
+        # Validate input
+        if not chunks:
+            raise ValueError("chunks list cannot be empty")
+        if not dialogue:
+            raise ValueError("dialogue cannot be None")
         
-        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}")
+        # 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")
+        
+        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("")
 
-        with open(output_path, "w", encoding="utf-8") as f:
-            f.write("\n".join(output_lines))
+            # Write to file
+            with open(output_path, "w", encoding="utf-8") as f:
+                f.write("\n".join(output_lines))
 
-        logger.info(f"Chunking results saved to: {output_path}")
-        return output_path
+            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
 
 

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

@@ -5,7 +5,7 @@ from typing import List, Dict, Optional
 from app.core.logging_config import get_memory_logger
 from app.core.memory.llm_tools.openai_client import OpenAIClient
 from app.core.memory.utils.prompt.prompt_utils import render_triplet_extraction_prompt
-from app.core.memory.utils.data.ontology import PREDICATE_DEFINITIONS, Predicate # 引入枚举 Predicate 白名单过滤
+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
@@ -14,15 +14,15 @@ from app.core.memory.utils.log.logging_utils import prompt_logger
 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"):
+            self,
+            llm_client: OpenAIClient,
+            ontology_types: Optional[OntologyTypeList] = None,
+            language: str = "zh"
+    ):
         """Initialize the TripletExtractor with an LLM client
 
         Args:
@@ -65,7 +65,8 @@ class TripletExtractor:
 
         # Create messages for LLM
         messages = [
-            {"role": "system", "content": "You are an expert at extracting knowledge triplets and entities from text. Follow the provided instructions carefully and return valid JSON."},
+            {"role": "system",
+             "content": "You are an expert at extracting knowledge triplets and entities from text. Follow the provided instructions carefully and return valid JSON."},
             {"role": "user", "content": prompt_content}
         ]
 
@@ -116,7 +117,8 @@ class TripletExtractor:
             logger.error(f"Error processing statement: {e}", exc_info=True)
             return TripletExtractionResponse(triplets=[], entities=[])
 
-    async def extract_triplets_from_statements(self, dialog_data: DialogData, limit_chunks: int = None) -> Dict[str, TripletExtractionResponse]:
+    async def extract_triplets_from_statements(self, dialog_data: DialogData, limit_chunks: int = None) -> Dict[
+        str, TripletExtractionResponse]:
         """Extract triplets and entities from statements
 
         Args:

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

@@ -1,11 +1,11 @@
 """
-自我反思引擎实现
+Self-Reflection Engine Implementation
 
-该模块实现了记忆系统的自我反思功能，包括：
-1. 基于时间的反思 - 根据时间周期触发反思
-2. 基于事实的反思 - 检测记忆冲突并解决
-3. 综合反思 - 整合多种反思策略
-4. 反思结果应用 - 更新记忆库
+This module implements the self-reflection functionality of the memory system, including:
+1. Time-based reflection - Triggers reflection based on time cycles
+2. Fact-based reflection - Detects and resolves memory conflicts
+3. Comprehensive reflection - Integrates multiple reflection strategies
+4. Reflection result application - Updates memory database
 """
 
 import asyncio
@@ -38,7 +38,7 @@ from app.schemas.memory_storage_schema import (
 )
 from pydantic import BaseModel
 
-# 配置日志
+# Configure logging
 _root_logger = logging.getLogger()
 if not _root_logger.handlers:
     logging.basicConfig(
@@ -49,35 +49,62 @@ else:
     _root_logger.setLevel(logging.INFO)
 
 class TranslationResponse(BaseModel):
-    """翻译响应模型"""
+    """Translation response model for language conversion"""
     data: str
+    
 class ReflectionRange(str, Enum):
-    """反思范围枚举"""
-    PARTIAL = "partial"  # 从检索结果中反思
-    ALL = "all"  # 从整个数据库中反思
+    """
+    Reflection range enumeration
+    
+    Defines the scope of data to be included in reflection operations.
+    """
+    PARTIAL = "partial"  # Reflect from retrieval results
+    ALL = "all"  # Reflect from entire database
 
 
 class ReflectionBaseline(str, Enum):
-    """反思基线枚举"""
-    TIME = "TIME"  # 基于时间的反思
-    FACT = "FACT"  # 基于事实的反思
-    HYBRID = "HYBRID"  # 混合反思
+    """
+    Reflection baseline enumeration
+    
+    Defines the strategy or approach used for reflection operations.
+    """
+    TIME = "TIME"  # Time-based reflection
+    FACT = "FACT"  # Fact-based reflection
+    HYBRID = "HYBRID"  # Hybrid reflection combining multiple strategies
 
 
 class ReflectionConfig(BaseModel):
-    """反思引擎配置"""
+    """
+    Reflection engine configuration
+    
+    Defines all configuration parameters for the reflection engine including
+    operation modes, model settings, and evaluation criteria.
+    
+    Attributes:
+        enabled: Whether reflection engine is enabled
+        iteration_period: Reflection cycle period (e.g., "3" hours)
+        reflexion_range: Scope of reflection (PARTIAL or ALL)
+        baseline: Reflection strategy (TIME, FACT, or HYBRID)
+        model_id: LLM model identifier for reflection operations
+        end_user_id: User identifier for scoped operations
+        output_example: Example output format for guidance
+        memory_verify: Enable memory verification checks
+        quality_assessment: Enable quality assessment evaluation
+        violation_handling_strategy: Strategy for handling violations
+        language_type: Language type for output ("zh" or "en")
+    """
     enabled: bool = False
-    iteration_period: str = "3"  # 反思周期
+    iteration_period: str = "3"  # Reflection cycle period
     reflexion_range: ReflectionRange = ReflectionRange.PARTIAL
     baseline: ReflectionBaseline = ReflectionBaseline.TIME
-    model_id: Optional[str] = None  # 模型ID
+    model_id: Optional[str] = None  # Model ID
     end_user_id: Optional[str] = None
-    output_example: Optional[str] = None  # 输出示例
+    output_example: Optional[str] = None  # Output example
 
-    # 评估相关字段
-    memory_verify: bool = True  # 记忆验证
-    quality_assessment: bool = True  # 质量评估
-    violation_handling_strategy: str = "warn"  # 违规处理策略
+    # Evaluation related fields
+    memory_verify: bool = True  # Memory verification
+    quality_assessment: bool = True  # Quality assessment
+    violation_handling_strategy: str = "warn"  # Violation handling strategy
     language_type: str = "zh"
 
     class Config:
@@ -85,7 +112,21 @@ class ReflectionConfig(BaseModel):
 
 
 class ReflectionResult(BaseModel):
-    """反思结果"""
+    """
+    Reflection operation result
+    
+    Contains comprehensive information about the outcome of a reflection operation
+    including success status, metrics, and execution details.
+    
+    Attributes:
+        success: Whether the reflection operation succeeded
+        message: Descriptive message about the operation result
+        conflicts_found: Number of conflicts detected during reflection
+        conflicts_resolved: Number of conflicts successfully resolved
+        memories_updated: Number of memory entries updated in database
+        execution_time: Total time taken for the reflection operation
+        details: Additional details about the operation (optional)
+    """
     success: bool
     message: str
     conflicts_found: int = 0
@@ -97,9 +138,22 @@ class ReflectionResult(BaseModel):
 
 class ReflectionEngine:
     """
-    自我反思引擎
-
-    负责执行记忆系统的自我反思，包括冲突检测、冲突解决和记忆更新。
+    Self-Reflection Engine
+    
+    Responsible for executing memory system self-reflection operations including
+    conflict detection, conflict resolution, and memory updates. Supports multiple
+    reflection strategies and provides comprehensive result tracking.
+    
+    The engine can operate in different modes:
+    - Time-based: Reflects on memories within specific time periods
+    - Fact-based: Detects and resolves factual conflicts in memories
+    - Hybrid: Combines multiple reflection strategies
+    
+    Attributes:
+        config: Reflection engine configuration
+        neo4j_connector: Neo4j database connector
+        llm_client: Language model client for analysis
+        Various function handlers for data processing and prompt rendering
     """
 
     def __init__(
@@ -115,18 +169,21 @@ class ReflectionEngine:
             update_query: Optional[str] = None
     ):
         """
-        初始化反思引擎
+        Initialize reflection engine
+        
+        Sets up the reflection engine with configuration and optional dependencies.
+        Uses lazy initialization to avoid circular imports and optimize startup time.
 
         Args:
-            config: 反思引擎配置
-            neo4j_connector: Neo4j 连接器（可选）
-            llm_client: LLM 客户端（可选）
-            get_data_func: 获取数据的函数（可选）
-            render_evaluate_prompt_func: 渲染评估提示词的函数（可选）
-            render_reflexion_prompt_func: 渲染反思提示词的函数（可选）
-            conflict_schema: 冲突结果 Schema（可选）
-            reflexion_schema: 反思结果 Schema（可选）
-            update_query: 更新查询语句（可选）
+            config: Reflection engine configuration object
+            neo4j_connector: Neo4j connector instance (optional, will be created if not provided)
+            llm_client: LLM client instance (optional, will be created if not provided)
+            get_data_func: Function for retrieving data (optional, uses default if not provided)
+            render_evaluate_prompt_func: Function for rendering evaluation prompts (optional)
+            render_reflexion_prompt_func: Function for rendering reflection prompts (optional)
+            conflict_schema: Schema for conflict result validation (optional)
+            reflexion_schema: Schema for reflection result validation (optional)
+            update_query: Query string for database updates (optional)
         """
         self.config = config
         self.neo4j_connector = neo4j_connector
@@ -137,14 +194,20 @@ class ReflectionEngine:
         self.conflict_schema = conflict_schema
         self.reflexion_schema = reflexion_schema
         self.update_query = update_query
-        self._semaphore = asyncio.Semaphore(5)  # 默认并发数为5
+        self._semaphore = asyncio.Semaphore(5)  # Default concurrency limit of 5
 
 
-        # 延迟导入以避免循环依赖
+        # Lazy import to avoid circular dependencies
         self._lazy_init_done = False
 
     def _lazy_init(self):
-        """延迟初始化，避免循环导入"""
+        """
+        Lazy initialization to avoid circular imports
+        
+        Initializes dependencies only when needed, preventing circular import issues
+        and optimizing startup performance. Sets up default implementations for
+        any components not provided during construction.
+        """
         if self._lazy_init_done:
             return
 
@@ -158,7 +221,7 @@ class ReflectionEngine:
                 factory = MemoryClientFactory(db)
                 self.llm_client = factory.get_llm_client(self.config.model_id)
         elif isinstance(self.llm_client, str):
-            # 如果 llm_client 是字符串（model_id），则用它初始化客户端
+            # If llm_client is a string (model_id), use it to initialize the client
             from app.core.memory.utils.llm.llm_utils import MemoryClientFactory
             from app.db import get_db_context
             from app.services.memory_config_service import MemoryConfigService
@@ -172,10 +235,10 @@ class ReflectionEngine:
                 model_config = config_service.get_model_config(model_id)
                 
             extra_params={
-                    "temperature": 0.2,  # 降低温度提高响应速度和一致性
-                    "max_tokens": 600,  # 限制最大token数
-                    "top_p": 0.8,  # 优化采样参数
-                    "stream": False,  # 确保非流式输出以获得最快响应
+                    "temperature": 0.2,  # Lower temperature for faster response and consistency
+                    "max_tokens": 600,  # Limit maximum token count
+                    "top_p": 0.8,  # Optimize sampling parameters
+                    "stream": False,  # Ensure non-streaming output for fastest response
                 }
 
             self.llm_client  = OpenAIClient(RedBearModelConfig(
@@ -191,7 +254,7 @@ class ReflectionEngine:
         if self.get_data_func is None:
             self.get_data_func = get_data
 
-        # 导入get_data_statement函数
+        # Import get_data_statement function
         if not hasattr(self, 'get_data_statement'):
             self.get_data_statement = get_data_statement
 
@@ -223,13 +286,20 @@ class ReflectionEngine:
 
     async def execute_reflection(self, host_id) -> ReflectionResult:
         """
-        执行完整的反思流程
+        Execute complete reflection workflow
+        
+        Performs the full reflection process including data retrieval, conflict detection,
+        conflict resolution, and memory updates. This is the main entry point for
+        reflection operations.
+        
         Args:
-            host_id: 主机ID
+            host_id: Host identifier for scoping reflection operations
+            
         Returns:
-            ReflectionResult: 反思结果
+            ReflectionResult: Comprehensive result of the reflection operation including
+                            success status, conflict metrics, and execution time
         """
-        # 延迟初始化
+        # Lazy initialization
         self._lazy_init()
 
         if not self.config.enabled:
@@ -243,7 +313,7 @@ class ReflectionEngine:
 
         print(self.config.baseline, self.config.memory_verify, self.config.quality_assessment)
         try:
-            # 1. 获取反思数据
+            # 1. Get reflection data
             reflexion_data, statement_databasets = await self._get_reflexion_data(host_id)
             if not reflexion_data:
                 return ReflectionResult(
@@ -252,7 +322,7 @@ class ReflectionEngine:
                     execution_time=asyncio.get_event_loop().time() - start_time
                 )
 
-            # 2. 检测冲突（基于事实的反思）
+            # 2. Detect conflicts (fact-based reflection)
             conflict_data = await self._detect_conflicts(reflexion_data, statement_databasets)
             conflict_list=[]
             for i  in conflict_data:
@@ -261,7 +331,7 @@ class ReflectionEngine:
 
 
             conflicts_found=0
-            # 3. 解决冲突
+            # 3. Resolve conflicts
             solved_data = await self._resolve_conflicts(conflict_list, statement_databasets)
 
             if not solved_data:
@@ -276,7 +346,7 @@ class ReflectionEngine:
             logging.info(f"解决了 {conflicts_resolved} 个冲突")
 
 
-            # 4. 应用反思结果（更新记忆库）
+            # 4. Apply reflection results (update memory database)
             memories_updated=await self._apply_reflection_results(solved_data)
 
             execution_time = asyncio.get_event_loop().time() - start_time
@@ -302,7 +372,19 @@ class ReflectionEngine:
             )
 
     async def Translate(self, text):
-        # 翻译中文为英文
+        """
+        Translate Chinese text to English
+        
+        Uses the configured LLM to translate Chinese text to English with structured output.
+        Provides consistent translation format for reflection results.
+        
+        Args:
+            text: Chinese text to be translated
+            
+        Returns:
+            str: Translated English text
+        """
+        # Translate Chinese to English
         translation_messages = [
             {
                 "role": "user",
@@ -316,6 +398,19 @@ class ReflectionEngine:
         )
         return response.data
     async def extract_translation(self,data):
+        """
+        Extract and translate reflection data to English
+        
+        Processes reflection data structure and translates all Chinese content to English.
+        Handles nested data structures including memory verifications, quality assessments,
+        and reflection data while preserving the original structure.
+        
+        Args:
+            data: Dictionary containing reflection data with Chinese content
+            
+        Returns:
+            dict: Translated data structure with English content
+        """
         end_datas={}
         end_datas['source_data']=await self.Translate(data['source_data'])
         quality_assessments = []
@@ -350,6 +445,18 @@ class ReflectionEngine:
         return end_datas
 
     async def reflection_run(self):
+        """
+        Execute reflection workflow with comprehensive data processing
+        
+        Performs a complete reflection operation including conflict detection, resolution,
+        and result formatting. Supports both Chinese and English output based on
+        configuration settings.
+        
+        Returns:
+            dict: Comprehensive reflection results including source data, memory verifications,
+                 quality assessments, and reflection data. Results are translated to English
+                 if language_type is set to 'en'.
+        """
         self._lazy_init()
         start_time = time.time()
         memory_verifies_flag = self.config.memory_verify
@@ -367,7 +474,7 @@ class ReflectionEngine:
         result_data['source_data'] = "我是 2023 年春天去北京工作的，后来基本一直都在北京上班，也没怎么换过城市。不过后来公司调整，2024 年上半年我被调到上海待了差不多半年，那段时间每天都是在上海办公室打卡。当时入职资料用的还是我之前的身份信息，身份证号是 11010119950308123X，银行卡是 6222023847595898，这些一直没变。对了，其实我 从 2023 年开始就一直在北京生活，从来没有长期离开过北京，上海那段更多算是远程配合"
         # 2. 检测冲突（基于事实的反思）
         conflict_data = await self._detect_conflicts(databasets, source_data)
-        # 遍历数据提取字段
+        # Traverse data to extract fields
         quality_assessments = []
         memory_verifies = []
         for item in conflict_data:
@@ -375,9 +482,9 @@ class ReflectionEngine:
             memory_verifies.append(item['memory_verify'])
         result_data['memory_verifies'] = memory_verifies
         result_data['quality_assessments'] = quality_assessments
-        conflicts_found = 0  # 初始化为整数0而不是空字符串
+        conflicts_found = 0  # Initialize as integer 0 instead of empty string
         REMOVE_KEYS = {"created_at", "expired_at","relationship","predicate","statement_id","id","statement_id","relationship_statement_id"}
-        # Clearn conflict_data，And memory_verify和quality_assessment
+        # Clean conflict_data, and memory_verify and quality_assessment
         cleaned_conflict_data = []
         for item in conflict_data:
             cleaned_item = {
@@ -389,7 +496,7 @@ class ReflectionEngine:
         for item in conflict_data:
             cleaned_data = []
             for row in item.get("data", []):
-                # 删除 created_at / expired_at
+                # Remove created_at / expired_at
                 cleaned_row = {
                     k: v
                     for k, v in row.items()
@@ -402,7 +509,7 @@ class ReflectionEngine:
             }
             cleaned_conflict_data_.append(cleaned_item)
         print(cleaned_conflict_data_)
-        # 3. 解决冲突
+        # 3. Resolve conflicts
         solved_data = await self._resolve_conflicts(cleaned_conflict_data_, source_data)
         if not solved_data:
             return ReflectionResult(
@@ -413,7 +520,7 @@ class ReflectionEngine:
             )
         reflexion_data = []
 
-        # 遍历数据提取reflexion字段
+        # Traverse data to extract reflexion fields
         for item in solved_data:
             if 'results' in item:
                 for result in item['results']:
@@ -431,15 +538,24 @@ class ReflectionEngine:
 
 
     async def extract_fields_from_json(self):
-        """从example.json中提取source_data和databasets字段"""
+        """
+        Extract source_data and databasets fields from example.json
+        
+        Reads reflection example data from the example.json file and extracts
+        the source data and database statements for testing and demonstration purposes.
+        
+        Returns:
+            tuple: (source_data, databasets) extracted from the example file
+                  Returns empty lists if file reading fails
+        """
 
         prompt_dir = os.path.join(os.path.dirname(__file__), "example")
         try:
-            # 读取JSON文件
+            # Read JSON file
             with open(prompt_dir + '/example.json', 'r', encoding='utf-8') as f:
                 data = json.loads(f.read())
 
-            # 提取memory_verify下的字段
+            # Extract fields under memory_verify
             memory_verify = data.get("memory_verify", {})
             source_data = memory_verify.get("source_data", [])
             databasets = memory_verify.get("databasets", [])
@@ -451,15 +567,17 @@ class ReflectionEngine:
 
     async def _get_reflexion_data(self, host_id: uuid.UUID) -> List[Any]:
         """
-        获取反思数据
-
-        根据配置的反思范围获取需要反思的记忆数据。
+        Get reflection data from database
+        
+        Retrieves memory data for reflection based on the configured reflection range.
+        Supports both partial (from retrieval results) and full (entire database) modes.
 
         Args:
-            host_id: 主机ID
+            host_id: Host UUID identifier for scoping data retrieval
 
         Returns:
-            List[Any]: 反思数据列表
+            tuple: (reflexion_data, statement_data) containing memory data for reflection
+                  Returns empty lists if query fails
         """
 
         print("=== 获取反思数据 ===")
@@ -484,26 +602,29 @@ class ReflectionEngine:
 
     async def _detect_conflicts(self, data: List[Any], statement_databasets: List[Any]) -> List[Any]:
         """
-        检测冲突（基于事实的反思）
-
-        使用 LLM 分析记忆数据，检测其中的冲突。
+        Detect conflicts (fact-based reflection)
+        
+        Uses LLM to analyze memory data and detect conflicts within the memories.
+        Performs comprehensive conflict detection including memory verification and
+        quality assessment based on configuration settings.
 
         Args:
-            data: 待检测的记忆数据
+            data: Memory data to be analyzed for conflicts
+            statement_databasets: Statement database records for context
 
         Returns:
-            List[Any]: 冲突记忆列表
+            List[Any]: List of detected conflicts with detailed analysis
         """
         if not data:
             return []
 
-        # 数据预处理：如果数据量太少，直接返回无冲突
+        # Data preprocessing: if data is too small, return no conflicts directly
         if len(data) < 2:
             logging.info("数据量不足，无需检测冲突")
             return []
 
-        # 使用转换后的数据
-        # print("转换后的数据:", data[:2] if len(data) > 2 else data)  # 只打印前2条避免日志过长
+        # Use converted data
+        # print("Converted data:", data[:2] if len(data) > 2 else data)  # Only print first 2 to avoid long logs
         memory_verify = self.config.memory_verify
 
         logging.info("====== 冲突检测开始 ======")
@@ -512,7 +633,7 @@ class ReflectionEngine:
         language_type=self.config.language_type
 
         try:
-            # 渲染冲突检测提示词
+            # Render conflict detection prompt
             rendered_prompt = await self.render_evaluate_prompt_func(
                 data,
                 self.conflict_schema,
@@ -526,7 +647,7 @@ class ReflectionEngine:
             messages = [{"role": "user", "content": rendered_prompt}]
             logging.info(f"提示词长度: {len(rendered_prompt)}")
 
-            # 调用 LLM 进行冲突检测
+            # Call LLM for conflict detection
             response = await self.llm_client.response_structured(
                 messages,
                 self.conflict_schema
@@ -539,7 +660,7 @@ class ReflectionEngine:
                 logging.error("LLM 冲突检测输出解析失败")
                 return []
 
-            # 标准化返回格式
+            # Standardize return format
             if isinstance(response, BaseModel):
                 return [response.model_dump()]
             elif hasattr(response, 'dict'):
@@ -553,15 +674,17 @@ class ReflectionEngine:
 
     async def _resolve_conflicts(self, conflicts: List[Any], statement_databasets: List[Any]) -> List[Any]:
         """
-        解决冲突
-
-        使用 LLM 对检测到的冲突进行反思和解决。
+        Resolve detected conflicts
+        
+        Uses LLM to perform reflection and resolution on detected conflicts.
+        Processes conflicts in parallel for efficiency while respecting concurrency limits.
 
         Args:
-            conflicts: 冲突列表
+            conflicts: List of conflicts to be resolved
+            statement_databasets: Statement database records for context
 
         Returns:
-            List[Any]: 解决方案列表
+            List[Any]: List of resolution solutions with reflection results
         """
         if not conflicts:
             return []
@@ -570,12 +693,12 @@ class ReflectionEngine:
         baseline = self.config.baseline
         memory_verify = self.config.memory_verify
 
-        # 并行处理每个冲突
+        # Process each conflict in parallel
         async def _resolve_one(conflict: Any) -> Optional[Dict[str, Any]]:
-            """解决单个冲突"""
+            """Resolve a single conflict"""
             async with self._semaphore:
                 try:
-                    # 渲染反思提示词
+                    # Render reflection prompt
                     rendered_prompt = await self.render_reflexion_prompt_func(
                         [conflict],
                         self.reflexion_schema,
@@ -587,7 +710,7 @@ class ReflectionEngine:
 
                     messages = [{"role": "user", "content": rendered_prompt}]
 
-                    # 调用 LLM 进行反思
+                    # Call LLM for reflection
                     response = await self.llm_client.response_structured(
                         messages,
                         self.reflexion_schema
@@ -596,7 +719,7 @@ class ReflectionEngine:
                     if not response:
                         return None
 
-                    # 标准化返回格式
+                    # Standardize return format
                     if isinstance(response, BaseModel):
                         return response.model_dump()
                     elif hasattr(response, 'dict'):
@@ -610,11 +733,11 @@ class ReflectionEngine:
                     logging.warning(f"解决单个冲突失败: {e}")
                     return None
 
-        # 并发执行所有冲突解决任务
+        # Execute all conflict resolution tasks concurrently
         tasks = [_resolve_one(conflict) for conflict in conflicts]
         results = await asyncio.gather(*tasks, return_exceptions=False)
 
-        # 过滤掉失败的结果
+        # Filter out failed results
         solved = [r for r in results if r is not None]
 
         logging.info(f"成功解决 {len(solved)}/{len(conflicts)} 个冲突")
@@ -626,15 +749,16 @@ class ReflectionEngine:
             solved_data: List[Dict[str, Any]]
     ) -> int:
         """
-        应用反思结果（更新记忆库）
-
-        将解决冲突后的记忆更新到 Neo4j 数据库中。
+        Apply reflection results (update memory database)
+        
+        Updates the Neo4j database with resolved conflicts and reflection results.
+        Processes the solved data and applies changes to the memory storage system.
 
         Args:
-            solved_data: 解决方案列表
+            solved_data: List of resolved conflict solutions with reflection data
 
         Returns:
-            int: 成功更新的记忆数量
+            int: Number of successfully updated memory entries
         """
         changes = extract_and_process_changes(solved_data)
         success_count = await neo4j_data(changes)
@@ -642,80 +766,86 @@ class ReflectionEngine:
 
 
 
-    # 基于时间的反思方法
+    # Time-based reflection methods
     async def time_based_reflection(
             self,
             host_id: uuid.UUID,
             time_period: Optional[str] = None
     ) -> ReflectionResult:
         """
-        基于时间的反思
-
-        根据时间周期触发反思，检查在指定时间段内的记忆。
+        Time-based reflection
+        
+        Triggers reflection based on time cycles, checking memories within
+        specified time periods. Uses the configured iteration period if
+        no specific time period is provided.
 
         Args:
-            host_id: 主机ID
-            time_period: 时间周期（如"三小时"），如果不提供则使用配置中的值
+            host_id: Host UUID identifier for scoping reflection
+            time_period: Time period (e.g., "three hours"), uses config value if not provided
 
         Returns:
-            ReflectionResult: 反思结果
+            ReflectionResult: Comprehensive reflection operation result
         """
         period = time_period or self.config.iteration_period
         logging.info(f"执行基于时间的反思，周期: {period}")
 
-        # 使用标准反思流程
+        # Use standard reflection workflow
         return await self.execute_reflection(host_id)
 
-    # 基于事实的反思方法
+    # Fact-based reflection methods
     async def fact_based_reflection(
             self,
             host_id: uuid.UUID
     ) -> ReflectionResult:
         """
-        基于事实的反思
-
-        检测记忆中的事实冲突并解决。
+        Fact-based reflection
+        
+        Detects and resolves factual conflicts within memories. Analyzes
+        memory data for inconsistencies and contradictions that need resolution.
 
         Args:
-            host_id: 主机ID
+            host_id: Host UUID identifier for scoping reflection
 
         Returns:
-            ReflectionResult: 反思结果
+            ReflectionResult: Comprehensive reflection operation result
         """
         logging.info("执行基于事实的反思")
 
-        # 使用标准反思流程
+        # Use standard reflection workflow
         return await self.execute_reflection(host_id)
 
-    # 综合反思方法
+    # Comprehensive reflection methods
     async def comprehensive_reflection(
             self,
             host_id: uuid.UUID
     ) -> ReflectionResult:
         """
-        综合反思
-
-        整合基于时间和基于事实的反思策略。
+        Comprehensive reflection
+        
+        Integrates time-based and fact-based reflection strategies based on
+        the configured baseline. Supports hybrid approaches that combine
+        multiple reflection methodologies.
 
         Args:
-            host_id: 主机ID
+            host_id: Host UUID identifier for scoping reflection
 
         Returns:
-            ReflectionResult: 反思结果
+            ReflectionResult: Comprehensive reflection operation result combining
+                            multiple strategies if using hybrid baseline
         """
         logging.info("执行综合反思")
 
-        # 根据配置的基线选择反思策略
+        # Choose reflection strategy based on configured baseline
         if self.config.baseline == ReflectionBaseline.TIME:
             return await self.time_based_reflection(host_id)
         elif self.config.baseline == ReflectionBaseline.FACT:
             return await self.fact_based_reflection(host_id)
         elif self.config.baseline == ReflectionBaseline.HYBRID:
-            # 混合策略：先执行基于时间的反思，再执行基于事实的反思
+            # Hybrid strategy: execute time-based reflection first, then fact-based reflection
             time_result = await self.time_based_reflection(host_id)
             fact_result = await self.fact_based_reflection(host_id)
 
-            # 合并结果
+            # Merge results
             return ReflectionResult(
                 success=time_result.success and fact_result.success,
                 message=f"时间反思: {time_result.message}; 事实反思: {fact_result.message}",

api/app/core/memory/utils/data/text_utils.py

@@ -2,9 +2,17 @@ import json
 
 
 def escape_lucene_query(query: str) -> str:
-    """Escape Lucene special characters in a free-text query.
-
-    This prevents ParseException when using Neo4j full-text procedures.
+    """
+    Escape special characters in Lucene queries
+    
+    Prevents ParseException when using Neo4j full-text search procedures.
+    Escapes all Lucene reserved special characters and operators.
+    
+    Args:
+        query: Original query string
+        
+    Returns:
+        str: Escaped query string safe for Lucene search
     """
     if query is None:
         return ""
@@ -22,11 +30,21 @@ def escape_lucene_query(query: str) -> str:
     return s
 
 def extract_plain_query(query_input: str) -> str:
-    """Extract clean, plain-text query from various input forms.
-
+    """
+    Extract clean plain-text query from various input forms
+    
+    Handles the following cases:
     - Strips surrounding quotes and whitespace
     - If input looks like JSON, prefers the 'original' field
-    - Fallbacks to the raw string when parsing fails
+    - Falls back to raw string when parsing fails
+    - Handles dictionary-type input
+    - Best-effort unescape common escape characters
+    
+    Args:
+        query_input: Query input in various forms (string, dict, etc.)
+        
+    Returns:
+        str: Extracted plain-text query string
     """
     if query_input is None:
         return ""

api/app/core/memory/utils/data/time_utils.py

@@ -4,7 +4,13 @@ from datetime import datetime
 
 def validate_date_format(date_str: str) -> bool:
     """
-    Validate if the date string is in the format YYYY-MM-DD.
+    Validate if date string conforms to YYYY-MM-DD format
+    
+    Args:
+        date_str: Date string to validate
+        
+    Returns:
+        bool: True if format is correct, False otherwise
     """
     pattern = r"^\d{4}-\d{1,2}-\d{1,2}$"
     return bool(re.match(pattern, date_str))
@@ -41,7 +47,20 @@ def normalize_date(date_str: str) -> str:
 
 
 def preprocess_date_string(date_str: str) -> str:
-    """预处理日期字符串，处理特殊格式"""
+    """
+    预处理日期字符串，处理特殊格式
+    
+    处理以下特殊格式：
+    - 年份后直接跟月份没有分隔符的格式（如 "20259/28"）
+    - 无分隔符的纯数字格式（如 "20251028", "251028"）
+    - 混合分隔符，统一为 "-"
+    
+    Args:
+        date_str: 原始日期字符串
+        
+    Returns:
+        str: 预处理后的日期字符串，格式为 "YYYY-MM-DD" 或 "YYYY-MM"
+    """
 
     # 处理类似 "20259/28" 的格式（年份后直接跟月份没有分隔）
     match = re.match(r'^(\d{4,5})[/\.\-_]?(\d{1,2})[/\.\-_]?(\d{1,2})$', date_str)
@@ -78,7 +97,23 @@ def preprocess_date_string(date_str: str) -> str:
 
 
 def fallback_parse(date_str: str) -> str:
-    """备选解析方案"""
+    """
+    备选日期解析方案
+    
+    当智能解析失败时，尝试使用预定义的日期格式进行解析。
+    支持多种常见的日期格式，包括：
+    - YYYY-MM-DD, YYYY/MM/DD, YYYY.MM.DD
+    - YYYYMMDD, YYMMDD
+    - MM-DD-YYYY, MM/DD/YYYY, MM.DD.YYYY
+    - DD-MM-YYYY, DD/MM/YYYY, DD.MM.YYYY
+    - YYYY-MM, YYYY/MM, YYYY.MM
+    
+    Args:
+        date_str: 待解析的日期字符串
+        
+    Returns:
+        str: 标准化后的日期字符串（YYYY-MM-DD格式），解析失败时返回原字符串
+    """
 
     # 尝试常见的日期格式[citation:4][citation:5]
     formats_to_try = [

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

@@ -327,7 +327,7 @@ class MultiOntologyParser:
     
     Example:
         >>> parser = MultiOntologyParser([
-        ...     "General_purpose_entity.ttl",
+        ...     "app/core/memory/ontology_services/General_purpose_entity.ttl",
         ...     "domain_specific.owl"
         ... ])
         >>> registry = parser.parse_all()

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

@@ -400,7 +400,8 @@ async def render_user_summary_prompt(
     user_id: str,
     entities: str,
     statements: str,
-    language: str = "zh"
+    language: str = "zh",
+    user_display_name: str = None
 ) -> str:
     """
     Renders the user summary prompt using the user_summary.jinja2 template.
@@ -410,16 +411,22 @@ async def render_user_summary_prompt(
         entities: Core entities with frequency information
         statements: Representative statement samples
         language: The language to use for summary generation ("zh" for Chinese, "en" for English)
+        user_display_name: Display name for the user (e.g., other_name or "该用户"/"the user")
 
     Returns:
         Rendered prompt content as string
     """
+    # 如果没有提供 user_display_name，使用默认值
+    if user_display_name is None:
+        user_display_name = "该用户" if language == "zh" else "the user"
+    
     template = prompt_env.get_template("user_summary.jinja2")
     rendered_prompt = template.render(
         user_id=user_id,
         entities=entities,
         statements=statements,
-        language=language
+        language=language,
+        user_display_name=user_display_name
     )
     
     # 记录渲染结果到提示日志
@@ -429,7 +436,8 @@ async def render_user_summary_prompt(
         'user_id': user_id,
         'entities_len': len(entities),
         'statements_len': len(statements),
-        'language': language
+        'language': language,
+        'user_display_name': user_display_name
     })
     
     return rendered_prompt
@@ -540,3 +548,20 @@ async def render_ontology_extraction_prompt(
     })
     
     return rendered_prompt
+
+
+def render_interest_filter_prompt(tag_list: str, language: str = "zh") -> str:
+    """
+    Renders the interest filter prompt using the interest_filter.jinja2 template.
+
+    Args:
+        tag_list: Comma-separated string of raw tags to filter
+        language: Output language ("zh" for Chinese, "en" for English)
+
+    Returns:
+        Rendered prompt content as string
+    """
+    template = prompt_env.get_template("interest_filter.jinja2")
+    rendered_prompt = template.render(tag_list=tag_list, language=language)
+    log_prompt_rendering('interest filter', rendered_prompt)
+    return rendered_prompt

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

@@ -1,6 +1,6 @@
 {#
   对话级抽取与相关性判定模板（用于剪枝加速）
-  输入：pruning_scene, dialog_text
+  输入：pruning_scene, ontology_classes, dialog_text, language
   输出：严格 JSON（不要包含任何多余文本），字段：
     - is_related: bool，是否与所选场景相关
     - times: [string]，从对话中抽取的时间相关文本（日期、时间、时间段、有效期等）
@@ -9,39 +9,71 @@
     - contacts: [string]，联系方式（电话/手机号/邮箱/微信/QQ等）
     - addresses: [string]，地址/地点相关文本
     - keywords: [string]，其它有助于保留的重要关键词（与场景强相关的术语）
+    - preserve_keywords: [string]，必须保留的情绪/兴趣/爱好/个人偏好相关词或短语片段
 
   要求：
   - 必须只输出上述 JSON，且键名一致；不得输出解释、前后缀；不得包含注释。
-  - times/ids/amounts/contacts/addresses/keywords 仅抽取原文片段或规范化后的简单字符串。
+  - times/ids/amounts/contacts/addresses/keywords/preserve_keywords 仅抽取原文片段或规范化后的简单字符串。
   - 仅输出上述键；避免多余解释或字段。
 #}
 
-{% set scene_instructions = {
-  'education': {
-    'zh': '教育场景：教学、课程、考试、作业、老师/学生互动、学习资源、学校管理等。',
-    'en': 'Education Scenario: Teaching, courses, exams, homework, teacher/student interaction, learning resources, school management, etc.'
-  },
-  'online_service': {
-    'zh': '在线客服场景：客户咨询、问题排查、服务工单、售后支持、订单/退款、工单升级等。',
-    'en': 'Online Service Scenario: Customer inquiries, troubleshooting, service tickets, after-sales support, orders/refunds, ticket escalation, etc.'
-  },
-  'outbound': {
-    'zh': '外呼场景：电话外呼、邀约、调研问卷、线索跟进、对话脚本、回访记录等。',
-    'en': 'Outbound Scenario: Outbound calls, invitations, survey questionnaires, lead follow-up, call scripts, follow-up records, etc.'
-  }
-} %}
-
-{% set scene_key = pruning_scene %}
-{% if scene_key not in scene_instructions %}
-{% set scene_key = 'education' %}
+{# ── 确定场景说明 ── #}
+{% if ontology_classes and ontology_classes | length > 0 %}
+  {% if language == 'en' %}
+    {% set custom_types_str = ontology_classes | join(', ') %}
+    {% set instruction = 'Scene "' ~ pruning_scene ~ '": The dialogue is related to this scene if it involves any of the following entity types: ' ~ custom_types_str ~ '.' %}
+  {% else %}
+    {% set custom_types_str = ontology_classes | join('、') %}
+    {% set instruction = '场景「' ~ pruning_scene ~ '」：对话涉及以下任意实体类型时视为相关：' ~ custom_types_str ~ '。' %}
+  {% endif %}
+{% else %}
+  {% if language == 'en' %}
+    {% set custom_types_str = '' %}
+    {% set instruction = 'Scene "' ~ pruning_scene ~ '": Determine whether the dialogue content is relevant to this scene based on overall context.' %}
+  {% else %}
+    {% set custom_types_str = '' %}
+    {% set instruction = '场景「' ~ pruning_scene ~ '」：根据对话整体内容判断是否与该场景相关。' %}
+  {% endif %}
 {% endif %}
 
-{% set instruction = scene_instructions[scene_key][language] if language in ['zh', 'en'] else scene_instructions[scene_key]['zh'] %}
-
 {% if language == "zh" %}
-请在下方对话全文基础上，按该场景进行一次性抽取并判定相关性：
-场景说明：{{ instruction }}
+你是一个对话内容分析助手。请对下方对话全文进行一次性分析，完成两项任务：
+1. 判断对话是否与指定场景相关；
+2. 从对话中抽取所有需要保留的重要信息片段。
 
+场景说明：{{ instruction }}
+{% if custom_types_str %}
+重要提示：只要对话中出现与上述实体类型（{{ custom_types_str }}）相关的内容，即判定为相关（is_related=true）。
+{% endif %}
+
+---
+【必须保留的内容（不可删除）】
+以下类型的内容无论是否与场景直接相关，都必须保留，请将其关键词/短语抽取到对应字段：
+- 时间信息：日期、时间点、时间段、有效期 → times 字段
+- 编号信息：学号、工号、订单号、申请号、账号、ID → ids 字段
+- 金额信息：价格、费用、金额（含货币符号或单位） → amounts 字段
+- 联系方式：电话、手机号、邮箱、微信、QQ → contacts 字段
+- 地址信息：地点、地址、位置 → addresses 字段
+- 场景关键词：与场景强相关的专业术语、事件名称 → keywords 字段
+- **情绪与情感**：喜悦、悲伤、愤怒、焦虑、开心、难过、委屈、兴奋、害怕、担心、压力、感动等情绪表达 → preserve_keywords 字段
+- **兴趣与爱好**：喜欢、热爱、爱好、擅长、享受、沉迷、着迷、讨厌某事物等个人偏好表达 → preserve_keywords 字段
+- **个人观点与态度**：对某事物的明确看法、评价、立场 → preserve_keywords 字段
+
+【可以删除的内容】
+以下类型的内容属于低价值信息，可以在剪枝时删除：
+- 纯寒暄问候：如"你好"、"在吗"、"拜拜"、"嗯"、"好的"、"哦"等无实质内容的短语
+- 纯表情/符号：如"[微笑]"、"😊"、"哈哈"等
+- 重复确认：如"对对对"、"是的是的"、"嗯嗯嗯"等无新增信息的重复
+- 无意义填充：如"啊"、"呢"、"嘛"等语气词单独成句
+
+**注意：即使消息很短，只要包含情绪、兴趣、爱好、个人观点等有价值信息，就必须保留，不得删除。**
+例如：
+- "我好开心呀" → 包含情绪（开心），必须保留，preserve_keywords 中加入"开心"
+- "好喜欢打羽毛球呀" → 包含兴趣爱好（喜欢打羽毛球），必须保留，preserve_keywords 中加入"喜欢打羽毛球"
+- "我好难过" → 包含情绪（难过），必须保留，preserve_keywords 中加入"难过"
+- "太好啦！看到你开心，我也跟着心情亮起来" → 包含情绪，必须保留，preserve_keywords 中加入"开心"
+
+---
 对话全文：
 """
 {{ dialog_text }}
@@ -55,12 +87,46 @@
   "amounts": [<string>...],
   "contacts": [<string>...],
   "addresses": [<string>...],
-  "keywords": [<string>...]
+  "keywords": [<string>...],
+  "preserve_keywords": [<string>...]
 }
 {% else %}
-Based on the full dialogue below, perform one-time extraction and relevance determination according to this scenario:
-Scenario Description: {{ instruction }}
+You are a dialogue content analysis assistant. Please analyze the full dialogue below in one pass and complete two tasks:
+1. Determine whether the dialogue is relevant to the specified scene;
+2. Extract all important information fragments that must be preserved.
 
+Scenario Description: {{ instruction }}
+{% if custom_types_str %}
+Important: If the dialogue contains content related to any of the entity types above ({{ custom_types_str }}), mark it as relevant (is_related=true).
+{% endif %}
+
+---
+[MUST PRESERVE (cannot be deleted)]
+The following types of content must always be preserved regardless of scene relevance. Extract their keywords/phrases into the corresponding fields:
+- Time information: dates, time points, durations, expiry dates → times field
+- ID information: student IDs, employee IDs, order numbers, application numbers, account IDs → ids field
+- Amount information: prices, fees, amounts (with currency symbols or units) → amounts field
+- Contact information: phone numbers, emails, WeChat, QQ → contacts field
+- Address information: locations, addresses, places → addresses field
+- Scene keywords: professional terms and event names strongly related to the scene → keywords field
+- **Emotions and feelings**: joy, sadness, anger, anxiety, happiness, sadness, excitement, fear, worry, stress, being moved, etc. → preserve_keywords field
+- **Interests and hobbies**: likes, loves, hobbies, good at, enjoys, obsessed with, hates something, personal preferences → preserve_keywords field
+- **Personal opinions and attitudes**: clear views, evaluations, or stances on something → preserve_keywords field
+
+[CAN BE DELETED]
+The following types of content are low-value and can be removed during pruning:
+- Pure greetings: e.g., "hello", "are you there", "bye", "ok", "yeah" — short phrases with no substantive content
+- Pure emojis/symbols: e.g., "[smile]", "😊", "haha"
+- Repetitive confirmations: e.g., "yes yes yes", "right right", "uh huh" — repetitions with no new information
+- Meaningless fillers: standalone interjections like "ah", "well", "hmm"
+
+**Note: Even if a message is short, if it contains emotions, interests, hobbies, or personal opinions, it MUST be preserved.**
+Examples:
+- "I'm so happy!" → contains emotion (happy), must preserve; add "happy" to preserve_keywords
+- "I love playing badminton!" → contains interest (love playing badminton), must preserve; add "love playing badminton" to preserve_keywords
+- "I feel so sad" → contains emotion (sad), must preserve; add "sad" to preserve_keywords
+
+---
 Full Dialogue:
 """
 {{ dialog_text }}
@@ -74,6 +140,7 @@ Output strict JSON only (fixed keys, order doesn't matter):
   "amounts": [<string>...],
   "contacts": [<string>...],
   "addresses": [<string>...],
-  "keywords": [<string>...]
+  "keywords": [<string>...],
+  "preserve_keywords": [<string>...]
 }
 {% endif %}

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

@@ -0,0 +1,67 @@
+{% if language == "zh" %}
+You are a user interest analysis expert. Your task is to infer and extract the user's core hobby/interest activities from a tag list. The tags may be specific project names, tool names, or compound nouns — your job is to identify the underlying interest they represent.
+
+**Step 1 - Infer the underlying interest from each tag**:
+Look at each tag and ask: "What hobby or interest does this tag suggest the user has?"
+
+Examples of inference:
+- '攀岩', '室内攀岩馆', '攀岩者数据仪表盘', '路线解锁地图', '指力', '路线等级', '当日攀岩流畅度' → '攀岩'
+- '风光摄影元数据增强器', 'EXIF数据', '.CR2文件', '.NEF文件', '日出拍摄点', '曝光补偿', '光圈', '太阳高度角', '云量预测图层' → '摄影'
+- '晨间冥想坚持天数', '身心协同峰值' → '冥想'
+- '川味可视化', '川菜' → '烹饪'
+- '开源项目命名建议', 'climbviz', '可视化', '力量增长雷达图' → '编程' 或 '数据可视化'
+- '吉他', '指弹', '琴谱' → '吉他'
+- '跑步', '5公里', '跑鞋' → '跑步'
+- '瑜伽垫', '瑜伽课' → '瑜伽'
+
+**Step 2 - Consolidate and deduplicate**:
+- Merge tags that point to the same interest into one representative label
+- Use concise, standard hobby names (e.g., '攀岩', '摄影', '编程', '烹饪', '冥想', '吉他', '跑步')
+- If multiple tags all point to '攀岩', output '攀岩' only once
+
+**Step 3 - Filter out non-interest tags**:
+Remove tags that do NOT suggest any hobby or interest:
+- Generic system/assistant terms (e.g., '助手', '用户', 'AI')
+- Pure abstract metrics with no clear hobby link (e.g., '完成时间', '日期', '自我评分')
+- Location names with no clear hobby link (e.g., '青城山后山' alone — but if combined with photography context, infer '摄影')
+
+**Output format**: Return a list of concise interest activity names in Chinese.
+
+**Example**:
+Input: ['攀岩', '攀岩者数据仪表盘', '路线解锁地图', '指力', '风光摄影元数据增强器', 'EXIF数据', '晨间冥想坚持天数', '川味可视化', '可视化', '助手', '完成时间']
+Output: ['攀岩', '摄影', '冥想', '烹饪', '编程']
+
+Now process the following tag list and return the inferred interest activities in Chinese: {{ tag_list }}
+{% else %}
+You are a user interest analysis expert. Your task is to infer and extract the user's core hobby/interest activities from a tag list. The tags may be specific project names, tool names, or compound nouns — your job is to identify the underlying interest they represent.
+
+**Step 1 - Infer the underlying interest from each tag**:
+Look at each tag and ask: "What hobby or interest does this tag suggest the user has?"
+
+Examples of inference:
+- 'rock climbing', 'indoor climbing gym', 'climber dashboard', 'route map', 'finger strength' → 'rock climbing'
+- 'landscape photography metadata enhancer', 'EXIF data', 'sunrise shooting spot', 'exposure compensation' → 'photography'
+- 'morning meditation streak', 'mind-body peak' → 'meditation'
+- 'Sichuan cuisine visualization', 'Sichuan food' → 'cooking'
+- 'open source project', 'data visualization tool', 'Python' → 'programming'
+- 'guitar', 'fingerpicking', 'sheet music' → 'guitar'
+- 'running', '5km', 'running shoes' → 'running'
+
+**Step 2 - Consolidate and deduplicate**:
+- Merge tags that point to the same interest into one representative label
+- Use concise, standard hobby names (e.g., 'rock climbing', 'photography', 'programming', 'cooking', 'meditation')
+- If multiple tags all point to 'rock climbing', output 'rock climbing' only once
+
+**Step 3 - Filter out non-interest tags**:
+Remove tags that do NOT suggest any hobby or interest:
+- Generic system/assistant terms (e.g., 'assistant', 'user', 'AI')
+- Pure abstract metrics with no clear hobby link (e.g., 'completion time', 'date', 'self-rating')
+
+**Output format**: Return a list of concise interest activity names in English.
+
+**Example**:
+Input: ['rock climbing', 'climber dashboard', 'route map', 'finger strength', 'landscape photography metadata enhancer', 'EXIF data', 'morning meditation streak', 'Sichuan cuisine visualization', 'visualization', 'assistant', 'completion time']
+Output: ['rock climbing', 'photography', 'meditation', 'cooking', 'programming']
+
+Now process the following tag list and return the inferred interest activities in English: {{ tag_list }}
+{% endif %}

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

@@ -14,8 +14,8 @@ Your task is to generate a comprehensive user profile based on the provided enti
 {% endif %}
 
 ===Inputs===
-{% if user_id %}
-- User ID: {{ user_id }}
+{% if user_display_name %}
+- User Display Name: {{ user_display_name }}
 {% endif %}
 {% if entities %}
 - Core Entities & Frequency: {{ entities }}
@@ -33,6 +33,20 @@ Your task is to generate a comprehensive user profile based on the provided enti
 3. Avoid excessive adjectives and empty phrases
 4. Strictly follow the output format specified below
 
+{% if language == "zh" %}
+**【严格人称规定】**
+- 在描述用户时，必须使用"{{ user_display_name }}"作为人称
+- 绝对禁止使用用户ID（如 {{ user_id }}）来称呼用户
+- 绝对禁止在摘要中出现任何形式的UUID或ID字符串
+- 如果需要指代用户，只能使用"{{ user_display_name }}"或相应的代词（他/她/TA）
+{% else %}
+**【STRICT PRONOUN RULES】**
+- When describing the user, you MUST use "{{ user_display_name }}" as the reference
+- It is ABSOLUTELY FORBIDDEN to use the user ID (such as {{ user_id }}) to refer to the user
+- It is ABSOLUTELY FORBIDDEN to include any form of UUID or ID string in the summary
+- If you need to refer to the user, you can ONLY use "{{ user_display_name }}" or appropriate pronouns (he/she/they)
+{% endif %}
+
 **Section-Specific Requirements:**
 
 {% if language == "zh" %}
@@ -103,13 +117,13 @@ Your task is to generate a comprehensive user profile based on the provided enti
 
 {% if language == "zh" %}
 Example Input:
-- User ID: user_12345
+- User Display Name: 张三
 - Core Entities & Frequency: 产品经理 (15), AI (12), 深圳 (10), 数据分析 (8), 团队协作 (7)
 - Representative Statement Samples: 我在深圳从事产品经理工作已经5年了 | 我相信好的产品源于对用户需求的深刻理解 | 我喜欢在团队中起到协调作用 | 数据驱动决策是我的工作原则
 
 Example Output:
 【基本介绍】
-我是张三，一名充满热情的高级产品经理。在过去的5年里，我专注于AI和数据驱动的产品设计，致力于创造能够真正改善用户生活的产品。我相信好的产品源于对用户需求的深刻理解和对技术可能性的不断探索。
+张三是一名充满热情的高级产品经理，在深圳工作。在过去的5年里，张三专注于AI和数据驱动的产品设计，致力于创造能够真正改善用户生活的产品。张三相信好的产品源于对用户需求的深刻理解和对技术可能性的不断探索。
 
 【性格特点】
 性格开朗，善于沟通，注重细节。喜欢在团队中起到协调作用，帮助大家达成共识。面对挑战时保持乐观，相信每个问题都有解决方案。
@@ -121,13 +135,13 @@ Example Output:
 "让每一个产品决策都充满温度。"
 {% else %}
 Example Input:
-- User ID: user_12345
+- User Display Name: John
 - Core Entities & Frequency: Product Manager (15), AI (12), San Francisco (10), Data Analysis (8), Team Collaboration (7)
 - Representative Statement Samples: I have been working as a product manager in San Francisco for 5 years | I believe good products come from deep understanding of user needs | I enjoy playing a coordinating role in teams | Data-driven decision making is my work principle
 
 Example Output:
 【Basic Introduction】
-This is a passionate senior product manager based in San Francisco. Over the past 5 years, they have focused on AI and data-driven product design, dedicated to creating products that truly improve users' lives. They believe good products stem from deep understanding of user needs and continuous exploration of technological possibilities.
+John is a passionate senior product manager based in San Francisco. Over the past 5 years, John has focused on AI and data-driven product design, dedicated to creating products that truly improve users' lives. John believes good products stem from deep understanding of user needs and continuous exploration of technological possibilities.
 
 【Personality Traits】
 Outgoing personality with excellent communication skills and attention to detail. Enjoys playing a coordinating role in teams, helping everyone reach consensus. Maintains optimism when facing challenges, believing every problem has a solution.

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

@@ -2,15 +2,15 @@ import os
 from jinja2 import Environment, FileSystemLoader
 from typing import List, Dict, Any
 
-
 # Setup Jinja2 environment
 prompt_dir = os.path.join(os.path.dirname(__file__), "prompts")
 prompt_env = Environment(loader=FileSystemLoader(prompt_dir))
 
+
 async def render_evaluate_prompt(evaluate_data: List[Any], schema: Any,
                                  baseline: str = "TIME",
-                                 memory_verify: bool = False,quality_assessment:bool = False,
-                                 statement_databasets: List[str] = [],language_type:str = "zh") -> str:
+                                 memory_verify: bool = False, quality_assessment: bool = False,
+                                 statement_databasets=None, language_type: str = "zh") -> str:
     """
     Renders the evaluate prompt using the evaluate_optimized.jinja2 template.
 
@@ -23,6 +23,8 @@ async def render_evaluate_prompt(evaluate_data: List[Any], schema: Any,
     Returns:
         Rendered prompt content as string
     """
+    if statement_databasets is None:
+        statement_databasets = []
     template = prompt_env.get_template("evaluate.jinja2")
 
     # Convert Pydantic model to JSON schema if needed
@@ -46,7 +48,7 @@ async def render_evaluate_prompt(evaluate_data: List[Any], schema: Any,
 
 
 async def render_reflexion_prompt(data: Dict[str, Any], schema: Any, baseline: str, memory_verify: bool = False,
-                                  statement_databasets: List[str] = [],language_type:str = "zh") -> str:
+                                  statement_databasets=None, language_type: str = "zh") -> str:
     """
     Renders the reflexion prompt using the reflexion_optimized.jinja2 template.
 
@@ -58,6 +60,8 @@ async def render_reflexion_prompt(data: Dict[str, Any], schema: Any, baseline: s
     Returns:
         Rendered prompt content as a string.
     """
+    if statement_databasets is None:
+        statement_databasets = []
     template = prompt_env.get_template("reflexion.jinja2")
 
     # Convert Pydantic model to JSON schema if needed
@@ -69,7 +73,7 @@ async def render_reflexion_prompt(data: Dict[str, Any], schema: Any, baseline: s
         json_schema = schema
 
     rendered_prompt = template.render(data=data, json_schema=json_schema,
-                                      baseline=baseline,memory_verify=memory_verify,
-                                      statement_databasets=statement_databasets,language_type=language_type)
+                                      baseline=baseline, memory_verify=memory_verify,
+                                      statement_databasets=statement_databasets, language_type=language_type)
 
     return rendered_prompt

api/app/core/models/base.py

@@ -1,51 +1,71 @@
 from __future__ import annotations
 
-import asyncio
 import os
-import time
-from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, List, Optional, TypeVar
+from typing import Any, Dict, Optional, TypeVar
+
+from langchain_aws import ChatBedrock
+from langchain_community.chat_models import ChatTongyi
+from langchain_core.embeddings import Embeddings
+from langchain_core.language_models import BaseLLM
+from langchain_ollama import OllamaLLM
+from langchain_openai import ChatOpenAI, OpenAI
+from pydantic import BaseModel, Field
 
-import httpx
 from app.core.error_codes import BizCode
 from app.core.exceptions import BusinessException
 from app.models.models_model import ModelProvider, ModelType
-from langchain_community.document_compressors import JinaRerank
-from langchain_core.callbacks import CallbackManagerForLLMRun
-from langchain_core.embeddings import Embeddings
-from langchain_core.language_models import BaseLanguageModel, BaseLLM
-from langchain_core.outputs import Generation, LLMResult
-from langchain_core.retrievers import BaseRetriever
-from langchain_core.runnables import RunnableSerializable
-from pydantic import BaseModel, Field
 
 T = TypeVar("T")
 
+
 class RedBearModelConfig(BaseModel):
     """模型配置基类"""
     model_name: str
     provider: str
     api_key: str
     base_url: Optional[str] = None
+    is_omni: bool = False  # 是否为 Omni 模型
     # 请求超时时间（秒）- 默认120秒以支持复杂的LLM调用，可通过环境变量 LLM_TIMEOUT 配置
     timeout: float = Field(default_factory=lambda: float(os.getenv("LLM_TIMEOUT", "120.0")))
     # 最大重试次数 - 默认2次以避免过长等待，可通过环境变量 LLM_MAX_RETRIES 配置
     max_retries: int = Field(default_factory=lambda: int(os.getenv("LLM_MAX_RETRIES", "2")))
-    concurrency: int = 5         # 并发限流
+    concurrency: int = 5  # 并发限流
     extra_params: Dict[str, Any] = {}
 
+
 class RedBearModelFactory:
     """模型工厂类"""
-    
+
     @classmethod
     def get_model_params(cls, config: RedBearModelConfig) -> Dict[str, Any]:
         """根据提供商获取模型参数"""
         provider = config.provider.lower()
-        
+
         # 打印供应商信息用于调试
         from app.core.logging_config import get_business_logger
         logger = get_business_logger()
-        logger.debug(f"获取模型参数 - Provider: {provider}, Model: {config.model_name}")
+        logger.debug(f"获取模型参数 - Provider: {provider}, Model: {config.model_name}, is_omni: {config.is_omni}")
+
+        # dashscope 的 omni 模型使用 OpenAI 兼容模式
+        if provider == ModelProvider.DASHSCOPE and config.is_omni:
+            import httpx
+            if not config.base_url:
+                config.base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
+            timeout_config = httpx.Timeout(
+                timeout=config.timeout,
+                connect=60.0,
+                read=config.timeout,
+                write=60.0,
+                pool=10.0,
+            )
+            return {
+                "model": config.model_name,
+                "base_url": config.base_url,
+                "api_key": config.api_key,
+                "timeout": timeout_config,
+                "max_retries": config.max_retries,
+                **config.extra_params
+            }
 
         if provider in [ModelProvider.OPENAI, ModelProvider.XINFERENCE, ModelProvider.GPUSTACK, ModelProvider.OLLAMA]:
             # 使用 httpx.Timeout 对象来设置详细的超时配置
@@ -65,7 +85,7 @@ class RedBearModelFactory:
                 "timeout": timeout_config,
                 "max_retries": config.max_retries,
                 **config.extra_params
-                }
+            }
         elif provider == ModelProvider.DASHSCOPE:
             # DashScope (通义千问) 使用自己的参数格式
             # 注意: DashScopeEmbeddings 不支持 timeout 和 base_url 参数
@@ -82,7 +102,7 @@ class RedBearModelFactory:
             # region 从 base_url 或 extra_params 获取
             from botocore.config import Config as BotoConfig
             from app.core.models.bedrock_model_mapper import normalize_bedrock_model_id
-            
+
             max_pool_connections = int(os.getenv("BEDROCK_MAX_POOL_CONNECTIONS", "50"))
             max_retries = int(os.getenv("BEDROCK_MAX_RETRIES", "2"))
             # Configure with increased connection pool
@@ -90,16 +110,16 @@ class RedBearModelFactory:
                 max_pool_connections=max_pool_connections,
                 retries={'max_attempts': max_retries, 'mode': 'adaptive'}
             )
-            
+
             # 标准化模型 ID（自动转换简化名称为完整 Bedrock Model ID）
             model_id = normalize_bedrock_model_id(config.model_name)
-            
+
             params = {
                 "model_id": model_id,
                 "config": boto_config,
                 **config.extra_params
             }
-            
+
             # 解析 API key (格式: access_key_id:secret_access_key)
             if config.api_key and ":" in config.api_key:
                 access_key_id, secret_access_key = config.api_key.split(":", 1)
@@ -107,63 +127,63 @@ class RedBearModelFactory:
                 params["aws_secret_access_key"] = secret_access_key
             elif config.api_key:
                 params["aws_access_key_id"] = config.api_key
-            
+
             # 设置 region
             if config.base_url:
                 params["region_name"] = config.base_url
             elif "region_name" not in params:
                 params["region_name"] = "us-east-1"  # 默认区域
-            
+
             return params
         else:
             raise BusinessException(f"不支持的提供商: {provider}", code=BizCode.PROVIDER_NOT_SUPPORTED)
-    
+
     @classmethod
     def get_rerank_model_params(cls, config: RedBearModelConfig) -> Dict[str, Any]:
         """根据提供商获取模型参数"""
         provider = config.provider.lower()
         if provider in [ModelProvider.XINFERENCE, ModelProvider.GPUSTACK]:
-                return {
+            return {
                 "model": config.model_name,
                 # "base_url": config.base_url,
                 "jina_api_key": config.api_key,
                 **config.extra_params
-                }
+            }
         else:
             raise BusinessException(f"不支持的提供商: {provider}", code=BizCode.PROVIDER_NOT_SUPPORTED)
 
-def get_provider_llm_class(config:RedBearModelConfig, type: ModelType=ModelType.LLM) -> type[BaseLLM]:
+
+def get_provider_llm_class(config: RedBearModelConfig, type: ModelType = ModelType.LLM) -> type[BaseLLM]:
     """根据模型提供商获取对应的模型类"""
     provider = config.provider.lower()
-    if provider in [ModelProvider.OPENAI, ModelProvider.XINFERENCE, ModelProvider.GPUSTACK] : 
+
+    # dashscope 的 omni 模型使用 OpenAI 兼容模式
+    if provider == ModelProvider.DASHSCOPE and config.is_omni:
+        return ChatOpenAI
+    if provider in [ModelProvider.OPENAI, ModelProvider.XINFERENCE, ModelProvider.GPUSTACK]:
         if type == ModelType.LLM:
-            from langchain_openai import OpenAI
-            return OpenAI 
+            return OpenAI
         elif type == ModelType.CHAT:
-            from langchain_openai import ChatOpenAI
             return ChatOpenAI
     elif provider == ModelProvider.DASHSCOPE:
-        from langchain_community.chat_models import ChatTongyi
         return ChatTongyi
-    elif provider == ModelProvider.OLLAMA: 
-        from langchain_ollama import OllamaLLM
+    elif provider == ModelProvider.OLLAMA:
         return OllamaLLM
     elif provider == ModelProvider.BEDROCK:
-        from langchain_aws import ChatBedrock, ChatBedrockConverse
-
         return ChatBedrock
     else:
         raise BusinessException(f"不支持的模型提供商: {provider}", code=BizCode.PROVIDER_NOT_SUPPORTED)
 
+
 def get_provider_embedding_class(provider: str) -> type[Embeddings]:
     """根据模型提供商获取对应的模型类"""
     provider = provider.lower()
-    if provider in [ModelProvider.OPENAI, ModelProvider.XINFERENCE, ModelProvider.GPUSTACK] :
+    if provider in [ModelProvider.OPENAI, ModelProvider.XINFERENCE, ModelProvider.GPUSTACK]:
         from langchain_openai import OpenAIEmbeddings
-        return OpenAIEmbeddings     
+        return OpenAIEmbeddings
     elif provider == ModelProvider.DASHSCOPE:
         from langchain_community.embeddings import DashScopeEmbeddings
-        return DashScopeEmbeddings        
+        return DashScopeEmbeddings
     elif provider == ModelProvider.OLLAMA:
         from langchain_ollama import OllamaEmbeddings
         return OllamaEmbeddings
@@ -173,14 +193,15 @@ def get_provider_embedding_class(provider: str) -> type[Embeddings]:
     else:
         raise BusinessException(f"不支持的模型提供商: {provider}", code=BizCode.PROVIDER_NOT_SUPPORTED)
 
+
 def get_provider_rerank_class(provider: str):
     """根据模型提供商获取对应的模型类"""
-    provider = provider.lower()      
-    if provider in [ModelProvider.XINFERENCE, ModelProvider.GPUSTACK] :
+    provider = provider.lower()
+    if provider in [ModelProvider.XINFERENCE, ModelProvider.GPUSTACK]:
         from langchain_community.document_compressors import JinaRerank
-        return JinaRerank        
-    # elif provider == ModelProvider.OLLAMA:
+        return JinaRerank
+        # elif provider == ModelProvider.OLLAMA:
     #     from langchain_ollama import OllamaEmbeddings
     #     return OllamaEmbeddings
     else:
-        raise BusinessException(f"不支持的模型提供商: {provider}", code=BizCode.PROVIDER_NOT_SUPPORTED)
+        raise BusinessException(f"不支持的模型提供商: {provider}", code=BizCode.PROVIDER_NOT_SUPPORTED)

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

@@ -6,6 +6,8 @@ models:
   description: AI21 Labs大语言模型，completion生成模式，256000上下文窗口
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   logo: bedrock
@@ -15,6 +17,9 @@ models:
   description: Amazon Nova大语言模型，支持智能体思考、工具调用、流式工具调用、视觉能力，300000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -28,6 +33,9 @@ models:
   description: Anthropic Claude大语言模型，支持智能体思考、视觉能力、工具调用、流式工具调用、文档处理，200000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -42,6 +50,8 @@ models:
   description: Cohere大语言模型，支持智能体思考、工具调用、流式工具调用，128000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -54,6 +64,9 @@ models:
   description: DeepSeek大语言模型，支持智能体思考、视觉能力、工具调用、流式工具调用，32768上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -67,6 +80,8 @@ models:
   description: Meta Llama大语言模型，支持智能体思考、工具调用，128000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -78,6 +93,8 @@ models:
   description: Mistral AI大语言模型，支持智能体思考、工具调用，32000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -89,6 +106,8 @@ models:
   description: OpenAI大语言模型，支持智能体思考、工具调用、流式工具调用，32768上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -101,6 +120,8 @@ models:
   description: Qwen大语言模型，支持智能体思考、工具调用、流式工具调用，32768上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -113,6 +134,8 @@ models:
   description: amazon.rerank-v1:0重排序模型，5120上下文窗口
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 重排序模型
   logo: bedrock
@@ -122,6 +145,8 @@ models:
   description: cohere.rerank-v3-5:0重排序模型，5120上下文窗口
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 重排序模型
   logo: bedrock
@@ -131,6 +156,9 @@ models:
   description: amazon.nova-2-multimodal-embeddings-v1:0文本嵌入模型，支持视觉能力，8192上下文窗口
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 文本嵌入模型
   - vision
@@ -141,6 +169,8 @@ models:
   description: amazon.titan-embed-text-v1文本嵌入模型，8192上下文窗口
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 文本嵌入模型
   logo: bedrock
@@ -150,6 +180,8 @@ models:
   description: amazon.titan-embed-text-v2:0文本嵌入模型，8192上下文窗口
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 文本嵌入模型
   logo: bedrock
@@ -159,6 +191,8 @@ models:
   description: Cohere Embed 3 English文本嵌入模型，512上下文窗口
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 文本嵌入模型
   logo: bedrock
@@ -168,6 +202,8 @@ models:
   description: Cohere Embed 3 Multilingual文本嵌入模型，512上下文窗口
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 文本嵌入模型
-  logo: bedrock
+  logo: bedrock

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

@@ -6,6 +6,8 @@ models:
   description: DeepSeek-R1-Distill-Qwen-14B大语言模型，支持智能体思考，32000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -16,6 +18,8 @@ models:
   description: DeepSeek-R1-Distill-Qwen-32B大语言模型，支持智能体思考，32000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -26,6 +30,8 @@ models:
   description: DeepSeek-R1大语言模型，支持智能体思考，131072超大上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -36,6 +42,8 @@ models:
   description: DeepSeek-V3.1大语言模型，支持智能体思考，131072超大上下文窗口，对话模式，支持丰富生成参数调节
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -46,6 +54,8 @@ models:
   description: DeepSeek-V3.2-exp实验版大语言模型，支持智能体思考，131072超大上下文窗口，对话模式，支持丰富生成参数调节
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -56,6 +66,8 @@ models:
   description: DeepSeek-V3.2大语言模型，支持智能体思考，131072超大上下文窗口，对话模式，支持丰富生成参数调节
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -66,6 +78,8 @@ models:
   description: DeepSeek-V3大语言模型，支持智能体思考，64000上下文窗口，对话模式，支持文本与JSON格式输出
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -76,6 +90,8 @@ models:
   description: farui-plus大语言模型，支持多工具调用、智能体思考、流式工具调用，12288上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -88,6 +104,8 @@ models:
   description: GLM-4.7大语言模型，支持多工具调用、智能体思考、流式工具调用，202752超大上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -100,6 +118,9 @@ models:
   description: qvq-max-latest大语言模型，支持视觉、智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - vision
@@ -112,6 +133,9 @@ models:
   description: qvq-max大语言模型，支持视觉、智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - vision
@@ -124,6 +148,8 @@ models:
   description: qwen-coder-turbo-0919代码专用大语言模型，支持智能体思考，131072上下文窗口，对话模式，已废弃
   is_deprecated: true
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - 代码模型
@@ -135,6 +161,8 @@ models:
   description: qwen-max-latest大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式，支持联网搜索
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -147,6 +175,8 @@ models:
   description: qwen-max-longcontext长上下文大语言模型，支持多工具调用、智能体思考、流式工具调用，32000上下文窗口，对话模式，已废弃
   is_deprecated: true
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -159,6 +189,8 @@ models:
   description: qwen-max大语言模型，支持多工具调用、智能体思考、流式工具调用，32768上下文窗口，对话模式，支持联网搜索
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -171,6 +203,8 @@ models:
   description: qwen-mt-plus多语言翻译大语言模型，支持智能体思考，16384上下文窗口，对话模式，支持多语种互译与领域翻译适配
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - 翻译模型
@@ -182,6 +216,8 @@ models:
   description: qwen-mt-turbo轻量化多语言翻译大语言模型，支持智能体思考，16384上下文窗口，对话模式，支持多语种互译与领域翻译适配
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - 翻译模型
@@ -193,6 +229,8 @@ models:
   description: qwen-plus-0112大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式，支持联网搜索，已废弃
   is_deprecated: true
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -205,6 +243,8 @@ models:
   description: qwen-plus-0125大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式，支持联网搜索，已废弃
   is_deprecated: true
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -217,6 +257,8 @@ models:
   description: qwen-plus-0723大语言模型，支持多工具调用、智能体思考、流式工具调用，32000上下文窗口，对话模式，支持联网搜索，已废弃
   is_deprecated: true
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -229,6 +271,8 @@ models:
   description: qwen-plus-0806大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式，支持联网搜索，已废弃
   is_deprecated: true
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -241,6 +285,8 @@ models:
   description: qwen-plus-0919大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式，支持联网搜索，已废弃
   is_deprecated: true
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -253,6 +299,8 @@ models:
   description: qwen-plus-1125大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式，支持联网搜索，已废弃
   is_deprecated: true
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -265,6 +313,8 @@ models:
   description: qwen-plus-1127大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式，支持联网搜索，已废弃
   is_deprecated: true
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -277,6 +327,8 @@ models:
   description: qwen-plus-1220大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式，已废弃
   is_deprecated: true
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -289,6 +341,10 @@ models:
   description: qwen-vl-max多模态大模型，支持视觉理解、智能体思考、视频理解，131072上下文窗口，对话模式，未废弃
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - video
+  is_omni: false
   tags:
   - 大语言模型
   - 多模态模型
@@ -302,6 +358,10 @@ models:
   description: qwen-vl-plus-0809多模态大模型，支持视觉理解、智能体思考、视频理解，32768上下文窗口，对话模式，已废弃
   is_deprecated: true
   is_official: true
+  capability:
+    - vision
+    - video
+  is_omni: false
   tags:
   - 大语言模型
   - 多模态模型
@@ -315,6 +375,10 @@ models:
   description: qwen-vl-plus-2025-01-02多模态大模型，支持视觉理解、智能体思考、视频理解，32768上下文窗口，对话模式，未废弃
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - video
+  is_omni: false
   tags:
   - 大语言模型
   - 多模态模型
@@ -328,6 +392,10 @@ models:
   description: qwen-vl-plus-2025-01-25多模态大模型，支持视觉理解、智能体思考、视频理解，131072上下文窗口，对话模式，未废弃
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - video
+  is_omni: false
   tags:
   - 大语言模型
   - 多模态模型
@@ -341,6 +409,10 @@ models:
   description: qwen-vl-plus-latest多模态大模型，支持视觉理解、智能体思考、视频理解，131072上下文窗口，对话模式，未废弃
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - video
+  is_omni: false
   tags:
   - 大语言模型
   - 多模态模型
@@ -354,6 +426,10 @@ models:
   description: qwen-vl-plus多模态大模型，支持视觉理解、智能体思考、视频理解，131072上下文窗口，对话模式，未废弃
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - video
+  is_omni: false
   tags:
   - 大语言模型
   - 多模态模型
@@ -367,6 +443,8 @@ models:
   description: qwen2.5-0.5b-instruct大语言模型，支持多工具调用、智能体思考、流式工具调用，32768上下文窗口，对话模式，未废弃
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -379,6 +457,8 @@ models:
   description: qwen3-14b大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -391,6 +471,8 @@ models:
   description: qwen3-235b-a22b-instruct-2507大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -403,6 +485,8 @@ models:
   description: qwen3-235b-a22b-thinking-2507大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -415,6 +499,8 @@ models:
   description: qwen3-235b-a22b大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -427,6 +513,8 @@ models:
   description: qwen3-30b-a3b-instruct-2507大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -439,6 +527,8 @@ models:
   description: qwen3-30b-a3b大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -451,6 +541,8 @@ models:
   description: qwen3-32b大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -463,6 +555,8 @@ models:
   description: qwen3-4b大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -475,6 +569,8 @@ models:
   description: qwen3-8b大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -487,6 +583,8 @@ models:
   description: qwen3-coder-30b-a3b-instruct大语言模型，支持智能体思考，262144上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - 代码模型
@@ -498,6 +596,8 @@ models:
   description: qwen3-coder-480b-a35b-instruct大语言模型，支持智能体思考，262144上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - 代码模型
@@ -509,6 +609,8 @@ models:
   description: qwen3-coder-plus-2025-09-23大语言模型，支持智能体思考，1000000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - 代码模型
@@ -520,6 +622,8 @@ models:
   description: qwen3-coder-plus大语言模型，支持智能体思考，1000000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - 代码模型
@@ -531,6 +635,8 @@ models:
   description: qwen3-max-2025-09-23大语言模型，支持多工具调用、智能体思考、流式工具调用，262144上下文窗口，对话模式，支持联网搜索
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -544,6 +650,8 @@ models:
   description: qwen3-max-2026-01-23大语言模型，支持多工具调用、智能体思考、流式工具调用，262144上下文窗口，对话模式，支持联网搜索
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -557,6 +665,8 @@ models:
   description: qwen3-max-preview大语言模型，支持多工具调用、智能体思考、流式工具调用，262144上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -569,6 +679,8 @@ models:
   description: qwen3-max大语言模型，支持多工具调用、智能体思考、流式工具调用，262144上下文窗口，对话模式，支持联网搜索
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -582,6 +694,8 @@ models:
   description: qwen3-next-80b-a3b-instruct大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -594,6 +708,8 @@ models:
   description: qwen3-next-80b-a3b-thinking大语言模型，支持多工具调用、智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -606,6 +722,11 @@ models:
   description: qwen3-omni-flash-2025-12-01多模态大语言模型，支持视觉、智能体思考、视频、音频能力，65536上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - video
+    - audio
+  is_omni: true
   tags:
   - 大语言模型
   - 多模态模型
@@ -620,6 +741,10 @@ models:
   description: qwen3-vl-235b-a22b-instruct多模态大语言模型，支持多工具调用、智能体思考、流式工具调用、视觉、视频能力，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - video
+  is_omni: false
   tags:
   - 大语言模型
   - 多模态模型
@@ -635,6 +760,10 @@ models:
   description: qwen3-vl-235b-a22b-thinking多模态大语言模型，支持多工具调用、智能体思考、流式工具调用、视觉、视频能力，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - video
+  is_omni: false
   tags:
   - 大语言模型
   - 多模态模型
@@ -650,6 +779,10 @@ models:
   description: qwen3-vl-30b-a3b-instruct多模态大语言模型，支持多工具调用、智能体思考、流式工具调用、视觉、视频能力，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - video
+  is_omni: false
   tags:
   - 大语言模型
   - 多模态模型
@@ -665,6 +798,10 @@ models:
   description: qwen3-vl-30b-a3b-thinking多模态大语言模型，支持多工具调用、智能体思考、流式工具调用、视觉、视频能力，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - video
+  is_omni: false
   tags:
   - 大语言模型
   - 多模态模型
@@ -680,6 +817,10 @@ models:
   description: qwen3-vl-flash多模态大语言模型，支持多工具调用、智能体思考、流式工具调用、视觉、视频能力，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - video
+  is_omni: false
   tags:
   - 大语言模型
   - 多模态模型
@@ -695,6 +836,10 @@ models:
   description: qwen3-vl-plus-2025-09-23多模态大语言模型，支持视觉、智能体思考、视频能力，262144上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - video
+  is_omni: false
   tags:
   - 大语言模型
   - 多模态模型
@@ -708,6 +853,10 @@ models:
   description: qwen3-vl-plus多模态大语言模型，支持视觉、智能体思考、视频能力，262144上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - video
+  is_omni: false
   tags:
   - 大语言模型
   - 多模态模型
@@ -721,6 +870,8 @@ models:
   description: qwq-32b大语言模型，支持智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -732,6 +883,8 @@ models:
   description: qwq-plus-0305大语言模型，支持智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -743,6 +896,8 @@ models:
   description: qwq-plus大语言模型，支持智能体思考、流式工具调用，131072上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -754,6 +909,8 @@ models:
   description: gte-rerank-v2重排序模型，4000上下文窗口
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 重排序模型
   logo: dashscope
@@ -763,6 +920,8 @@ models:
   description: gte-rerank重排序模型，4000上下文窗口
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 重排序模型
   logo: dashscope
@@ -772,6 +931,9 @@ models:
   description: multimodal-embedding-v1多模态嵌入模型，支持视觉能力，8192上下文窗口，最大分块数10
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 嵌入模型
   - 多模态模型
@@ -783,6 +945,8 @@ models:
   description: text-embedding-v1文本嵌入模型，2048上下文窗口，最大分块数25
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 嵌入模型
   - 文本嵌入
@@ -793,6 +957,8 @@ models:
   description: text-embedding-v2文本嵌入模型，2048上下文窗口，最大分块数25
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 嵌入模型
   - 文本嵌入
@@ -803,6 +969,8 @@ models:
   description: text-embedding-v3文本嵌入模型，8192上下文窗口，最大分块数10
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 嵌入模型
   - 文本嵌入
@@ -813,7 +981,9 @@ models:
   description: text-embedding-v4文本嵌入模型，8192上下文窗口，最大分块数10
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 嵌入模型
   - 文本嵌入
-  logo: dashscope
+  logo: dashscope

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

@@ -6,7 +6,7 @@ from typing import Callable
 import yaml
 from sqlalchemy.orm import Session
 
-from app.models.models_model import ModelBase, ModelProvider
+from app.models.models_model import ModelBase, ModelProvider, ModelConfig
 
 
 def _load_yaml_config(provider: ModelProvider) -> list[dict]:
@@ -55,6 +55,15 @@ def load_models(db: Session, providers: list[str] = None, silent: bool = False)
             print(f"\n正在加载 {provider.value} 的 {len(models)} 个模型...")
 
         for model_data in models:
+            config_sync_fields = {
+                "logo": None,
+                "capability": None,
+                "is_omni": None,
+                "name": None,
+                "provider": None,
+                "type": None,
+                "description": None
+            }
             try:
                 # 检查模型是否已存在
                 existing = db.query(ModelBase).filter(
@@ -66,6 +75,40 @@ def load_models(db: Session, providers: list[str] = None, silent: bool = False)
                     # 更新现有模型配置
                     for key, value in model_data.items():
                         setattr(existing, key, value)
+                    
+                    # 更新绑定了该 model_id 的 ModelConfig 和 ModelApiKey
+                    sync_fields = [k for k in config_sync_fields.keys() if k in model_data]
+                    if sync_fields:
+                        # 批量更新 ModelConfig
+                        update_kwargs = {k: model_data[k] for k in sync_fields}
+                        db.query(ModelConfig).filter(ModelConfig.model_id == existing.id).update(
+                            update_kwargs,
+                            synchronize_session=False
+                        )
+                        
+                        # 更新 ModelApiKey 的 capability 和 is_omni
+                        if 'capability' in model_data or 'is_omni' in model_data:
+                            from app.models.models_model import ModelApiKey, model_config_api_key_association
+                            api_key_update = {}
+                            if 'capability' in model_data:
+                                api_key_update['capability'] = model_data['capability']
+                            if 'is_omni' in model_data:
+                                api_key_update['is_omni'] = model_data['is_omni']
+                            
+                            if api_key_update:
+                                # 查找所有关联的 API Key
+                                api_key_ids = db.query(model_config_api_key_association.c.api_key_id).join(
+                                    ModelConfig,
+                                    ModelConfig.id == model_config_api_key_association.c.model_config_id
+                                ).filter(ModelConfig.model_id == existing.id).distinct().all()
+                                
+                                if api_key_ids:
+                                    api_key_ids = [aid[0] for aid in api_key_ids]
+                                    db.query(ModelApiKey).filter(ModelApiKey.id.in_(api_key_ids)).update(
+                                        api_key_update,
+                                        synchronize_session=False
+                                    )
+                    
                     db.commit()
                     if not silent:
                         print(f"更新成功: {model_data['name']}")

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

@@ -6,12 +6,19 @@ models:
   description: chatgpt-4o-latest大语言模型，支持多工具调用、智能体思考、流式工具调用、视觉能力，128000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+    - audio
+    - video
+  is_omni: true
   tags:
   - 大语言模型
   - multi-tool-call
   - agent-thought
   - stream-tool-call
   - vision
+  - audio
+  - video
   logo: openai
 - name: gpt-3.5-turbo-0125
   type: llm
@@ -19,6 +26,8 @@ models:
   description: gpt-3.5-turbo-0125大语言模型，支持多工具调用、智能体思考、流式工具调用，16385上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -31,6 +40,8 @@ models:
   description: gpt-3.5-turbo-1106大语言模型，支持多工具调用、智能体思考、流式工具调用，16385上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -43,6 +54,8 @@ models:
   description: gpt-3.5-turbo-16k大语言模型，支持多工具调用、智能体思考、流式工具调用，16385上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -55,6 +68,8 @@ models:
   description: gpt-3.5-turbo-instruct大语言模型，4096上下文窗口，文本补全模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   logo: openai
@@ -64,6 +79,8 @@ models:
   description: gpt-3.5-turbo大语言模型，支持多工具调用、智能体思考、流式工具调用，16385上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -76,6 +93,8 @@ models:
   description: gpt-4-0125-preview大语言模型，支持多工具调用、智能体思考、流式工具调用，128000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -88,6 +107,8 @@ models:
   description: gpt-4-1106-preview大语言模型，支持多工具调用、智能体思考、流式工具调用，128000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -100,6 +121,9 @@ models:
   description: gpt-4-turbo-2024-04-09大语言模型，支持多工具调用、智能体思考、流式工具调用、视觉能力，128000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -113,6 +137,8 @@ models:
   description: gpt-4-turbo-preview大语言模型，支持多工具调用、智能体思考、流式工具调用，128000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -125,6 +151,9 @@ models:
   description: gpt-4-turbo大语言模型，支持多工具调用、智能体思考、流式工具调用、视觉能力，128000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -138,6 +167,8 @@ models:
   description: o1-preview大语言模型，支持智能体思考，128000上下文窗口，对话模式，已废弃
   is_deprecated: true
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -148,6 +179,9 @@ models:
   description: o1大语言模型，支持多工具调用、智能体思考、流式工具调用、视觉能力、结构化输出，200000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - multi-tool-call
@@ -162,6 +196,9 @@ models:
   description: o3-2025-04-16大语言模型，支持智能体思考、工具调用、视觉能力、流式工具调用、结构化输出，200000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -176,6 +213,8 @@ models:
   description: o3-mini-2025-01-31大语言模型，支持智能体思考、工具调用、流式工具调用、结构化输出，200000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -189,6 +228,8 @@ models:
   description: o3-mini大语言模型，支持智能体思考、工具调用、流式工具调用、结构化输出，200000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -202,6 +243,9 @@ models:
   description: o3-pro-2025-06-10大语言模型，支持智能体思考、工具调用、视觉能力、结构化输出，200000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -215,6 +259,9 @@ models:
   description: o3-pro大语言模型，支持智能体思考、工具调用、视觉能力、结构化输出，200000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -228,6 +275,9 @@ models:
   description: o3大语言模型，支持智能体思考、视觉能力、工具调用、流式工具调用、结构化输出，200000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -242,6 +292,9 @@ models:
   description: o4-mini-2025-04-16大语言模型，支持智能体思考、工具调用、视觉能力、流式工具调用、结构化输出，200000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -256,6 +309,9 @@ models:
   description: o4-mini大语言模型，支持智能体思考、工具调用、视觉能力、流式工具调用、结构化输出，200000上下文窗口，对话模式
   is_deprecated: false
   is_official: true
+  capability:
+    - vision
+  is_omni: false
   tags:
   - 大语言模型
   - agent-thought
@@ -270,6 +326,8 @@ models:
   description: text-embedding-3-large文本向量模型，8191上下文窗口，最大分块数32
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 文本向量模型
   logo: openai
@@ -279,6 +337,8 @@ models:
   description: text-embedding-3-small文本向量模型，8191上下文窗口，最大分块数32
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 文本向量模型
   logo: openai
@@ -288,6 +348,8 @@ models:
   description: text-embedding-ada-002文本向量模型，8097上下文窗口，最大分块数32
   is_deprecated: false
   is_official: true
+  capability: []
+  is_omni: false
   tags:
   - 文本向量模型
-  logo: openai
+  logo: openai

api/app/core/rag_utils/__init__.py

@@ -4,11 +4,12 @@ RAG chunk analysis utilities.
 
 from .chunk_summary import generate_chunk_summary
 from .chunk_tags import extract_chunk_tags, extract_chunk_persona
-from .chunk_insight import generate_chunk_insight
+from .chunk_insight import generate_chunk_insight, generate_chunk_insight_sections
 
 __all__ = [
     "generate_chunk_summary",
     "extract_chunk_tags",
     "extract_chunk_persona",
     "generate_chunk_insight",
+    "generate_chunk_insight_sections",
 ]

api/app/core/rag_utils/chunk_insight.py

@@ -1,213 +1,207 @@
 """
-Generate insights from RAG chunks.
+Generate memory insight report for RAG chunks using memory_insight.jinja2 prompt template.
 
-This module provides functionality to analyze chunk content and generate insights using LLM.
+The memory_insight.jinja2 template produces a four-section report:
+  【总体概述】 → memory_insight
+  【行为模式】 → behavior_pattern
+  【关键发现】 → key_findings
+  【成长轨迹】 → growth_trajectory
+
+generate_chunk_insight() returns the full raw text (stored in end_user.memory_insight).
+generate_chunk_insight_sections() returns a dict with all four fields for richer storage.
 """
 
 import asyncio
+import os
+import re
 from collections import Counter
-from typing import Any, Dict, List
+from typing import Dict, List, Optional
 
 from app.core.logging_config import get_business_logger
 from app.core.memory.utils.llm.llm_utils import MemoryClientFactory
 from app.db import get_db_context
-from pydantic import BaseModel, Field
 
 business_logger = get_business_logger()
 
+DEFAULT_LLM_ID = os.getenv("SELECTED_LLM_ID", "openai/qwen-plus")
 
-def _get_llm_client():
-    """Get LLM client using db context."""
+
+# ── LLM client helper ────────────────────────────────────────────────────────
+
+def _get_llm_client(end_user_id: Optional[str] = None):
+    """Get LLM client, preferring user-connected config with fallback to default."""
     with get_db_context() as db:
+        try:
+            if end_user_id:
+                from app.services.memory_agent_service import get_end_user_connected_config
+                from app.services.memory_config_service import MemoryConfigService
+                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 config_id or workspace_id:
+                    config_service = MemoryConfigService(db)
+                    memory_config = config_service.load_memory_config(
+                        config_id=config_id,
+                        workspace_id=workspace_id
+                    )
+                    factory = MemoryClientFactory(db)
+                    return factory.get_llm_client(memory_config.llm_model_id)
+        except Exception as e:
+            business_logger.warning(f"Failed to get user connected config, using default LLM: {e}")
         factory = MemoryClientFactory(db)
-        return factory.get_llm_client(None)  # Uses default LLM
+        return factory.get_llm_client(DEFAULT_LLM_ID)
 
 
-class ChunkInsight(BaseModel):
-    """Pydantic model for chunk insight."""
-    insight: str = Field(..., description="对chunk内容的深度洞察分析")
+# ── Domain analysis helpers (kept for building prompt inputs) ─────────────────
 
+async def _classify_domain(chunk: str, llm_client) -> str:
+    """Classify a single chunk into a domain category."""
+    from pydantic import BaseModel, Field
 
-class DomainClassification(BaseModel):
-    """Pydantic model for domain classification."""
-    domain: str = Field(
-        ...,
-        description="内容所属的领域分类",
-        examples=["技术", "商业", "教育", "生活", "娱乐", "健康", "其他"]
-    )
+    class _Domain(BaseModel):
+        domain: str = Field(..., description="领域分类")
 
-
-async def classify_chunk_domain(chunk: str) -> str:
-    """
-    Classify a chunk into a specific domain.
-    
-    Args:
-        chunk: Chunk content string
-    
-    Returns:
-        Domain name
-    """
     try:
-        llm_client = _get_llm_client()
-        
-        prompt = f"""请将以下文本内容归类到最合适的领域中。
-
-可选领域及其关键词：
-- 技术：编程、软件、硬件、算法、数据、网络、系统、开发、工程等
-- 商业：市场、销售、管理、财务、投资、创业、营销、战略等
-- 教育：学习、课程、培训、教学、知识、技能、考试、研究等
-- 生活：日常、家庭、饮食、购物、旅行、休闲、娱乐等
-- 娱乐：游戏、电影、音乐、体育、艺术、文化等
-- 健康：医疗、养生、运动、心理、保健、疾病等
-- 其他：无法归入以上类别的内容
-
-文本内容: {chunk[:500]}...
-
-请直接返回最合适的领域名称。"""
-        
-        messages = [
-            {"role": "system", "content": "你是一个专业的文本分类助手。请仔细分析文本内容，选择最合适的领域分类。"},
-            {"role": "user", "content": prompt}
-        ]
-        
-        classification = await llm_client.response_structured(
-            messages=messages,
-            response_model=DomainClassification
+        prompt = (
+            "请将以下文本归类到最合适的领域（技术/商业/教育/生活/娱乐/健康/其他）。\n\n"
+            f"文本: {chunk[:500]}\n\n直接返回领域名称。"
         )
-        
-        return classification.domain if classification else "其他"
-        
-    except Exception as e:
-        business_logger.error(f"分类chunk领域失败: {str(e)}")
+        result = await llm_client.response_structured(
+            messages=[{"role": "user", "content": prompt}],
+            response_model=_Domain,
+        )
+        return result.domain if result else "其他"
+    except Exception:
         return "其他"
 
 
-async def analyze_domain_distribution(chunks: List[str], max_chunks: int = 20) -> Dict[str, float]:
+async def _build_insight_inputs(
+    chunks: List[str],
+    max_chunks: int,
+    end_user_id: Optional[str],
+) -> Dict[str, Optional[str]]:
     """
-    Analyze the domain distribution of chunks.
-    
-    Args:
-        chunks: List of chunk content strings
-        max_chunks: Maximum number of chunks to analyze
-    
-    Returns:
-        Dictionary of domain -> percentage
+    Derive domain_distribution, active_periods, social_connections strings
+    to feed into the memory_insight.jinja2 template.
     """
-    if not chunks:
-        return {}
-    
-    try:
-        # 限制分析的chunk数量
-        chunks_to_analyze = chunks[:max_chunks]
-        
-        # 为每个chunk分类
-        domain_counts = Counter()
-        for chunk in chunks_to_analyze:
-            domain = await classify_chunk_domain(chunk)
-            domain_counts[domain] += 1
-        
-        # 计算百分比
-        total = sum(domain_counts.values())
-        domain_distribution = {
-            domain: count / total
-            for domain, count in domain_counts.items()
-        }
-        
-        # 按百分比降序排序
-        return dict(sorted(domain_distribution.items(), key=lambda x: x[1], reverse=True))
-        
-    except Exception as e:
-        business_logger.error(f"分析领域分布失败: {str(e)}")
-        return {}
+    llm_client = _get_llm_client(end_user_id)
+    chunks_sample = chunks[:max_chunks]
+
+    # Domain distribution
+    domain_counts: Counter = Counter()
+    for chunk in chunks_sample:
+        domain = await _classify_domain(chunk, llm_client)
+        domain_counts[domain] += 1
+
+    total = sum(domain_counts.values()) or 1
+    domain_distribution = ", ".join(
+        f"{d}({c / total:.0%})" for d, c in domain_counts.most_common(3)
+    )
+
+    return {
+        "domain_distribution": domain_distribution,
+        "active_periods": None,      # RAG模式暂无时间维度数据
+        "social_connections": None,  # RAG模式暂无社交关联数据
+    }
 
 
-async def generate_chunk_insight(chunks: List[str], max_chunks: int = 15) -> str:
+# ── Section parser ────────────────────────────────────────────────────────────
+
+_ZH_SECTIONS = {
+    "memory_insight": r"【总体概述】(.*?)(?=【|$)",
+    "behavior_pattern": r"【行为模式】(.*?)(?=【|$)",
+    "key_findings": r"【关键发现】(.*?)(?=【|$)",
+    "growth_trajectory": r"【成长轨迹】(.*?)(?=【|$)",
+}
+
+_EN_SECTIONS = {
+    "memory_insight": r"【Overview】(.*?)(?=【|$)",
+    "behavior_pattern": r"【Behavior Pattern】(.*?)(?=【|$)",
+    "key_findings": r"【Key Findings】(.*?)(?=【|$)",
+    "growth_trajectory": r"【Growth Trajectory】(.*?)(?=【|$)",
+}
+
+
+def _parse_sections(text: str, language: str = "zh") -> Dict[str, str]:
+    """Extract the four sections from the LLM output."""
+    patterns = _ZH_SECTIONS if language == "zh" else _EN_SECTIONS
+    result = {}
+    for key, pattern in patterns.items():
+        match = re.search(pattern, text, re.DOTALL)
+        result[key] = match.group(1).strip() if match else ""
+    return result
+
+
+# ── Public API ────────────────────────────────────────────────────────────────
+
+async def generate_chunk_insight(
+    chunks: List[str],
+    max_chunks: int = 15,
+    end_user_id: Optional[str] = None,
+    language: str = "zh",
+) -> str:
     """
-    Generate insights from the given chunks.
-    
-    Args:
-        chunks: List of chunk content strings
-        max_chunks: Maximum number of chunks to analyze
-    
-    Returns:
-        A comprehensive insight report
+    Generate a memory insight report from RAG chunks.
+
+    Returns the full raw report text (suitable for end_user.memory_insight).
+    Use generate_chunk_insight_sections() when you need all four dimensions.
+    """
+    sections = await generate_chunk_insight_sections(
+        chunks=chunks,
+        max_chunks=max_chunks,
+        end_user_id=end_user_id,
+        language=language,
+    )
+    return sections.get("memory_insight") or sections.get("_raw", "洞察生成失败")
+
+
+async def generate_chunk_insight_sections(
+    chunks: List[str],
+    max_chunks: int = 15,
+    end_user_id: Optional[str] = None,
+    language: str = "zh",
+) -> Dict[str, str]:
+    """
+    Generate a four-section memory insight report from RAG chunks.
+
+    Returns a dict with keys:
+        memory_insight, behavior_pattern, key_findings, growth_trajectory
+    (plus '_raw' containing the full LLM output for debugging)
     """
     if not chunks:
         business_logger.warning("没有提供chunk内容用于生成洞察")
-        return "暂无足够数据生成洞察报告"
-    
+        empty = {k: "" for k in ("memory_insight", "behavior_pattern", "key_findings", "growth_trajectory")}
+        empty["_raw"] = "暂无足够数据生成洞察报告"
+        return empty
+
     try:
-        # 1. 分析领域分布
-        domain_dist = await analyze_domain_distribution(chunks, max_chunks=max_chunks)
-        
-        # 2. 统计基本信息
-        total_chunks = len(chunks)
-        avg_length = sum(len(chunk) for chunk in chunks) / total_chunks if total_chunks > 0 else 0
-        
-        # 3. 构建洞察prompt
-        prompt_parts = []
-        
-        if domain_dist:
-            top_domains = ", ".join([f"{k}({v:.0%})" for k, v in list(domain_dist.items())[:3]])
-            prompt_parts.append(f"- 内容领域分布: {top_domains}")
-        
-        prompt_parts.append(f"- 内容规模: 共{total_chunks}个知识片段，平均长度{avg_length:.0f}字")
-        
-        # 添加部分chunk内容作为参考
-        sample_chunks = chunks[:5]
-        sample_content = "\n".join([f"示例{i+1}: {chunk[:200]}..." for i, chunk in enumerate(sample_chunks)])
-        prompt_parts.append(f"\n内容示例:\n{sample_content}")
-        
-        system_prompt = """你是一位专业的知识内容分析师。你的任务是根据提供的信息，生成一段简洁、有洞察力的分析报告。
+        from app.core.memory.utils.prompt.prompt_utils import render_memory_insight_prompt
 
-重要规则：
-1. 报告需要将所有要点流畅地串联成一个段落
-2. 语言风格要专业、客观，同时易于理解
-3. 不要添加任何额外的解释或标题，直接输出报告内容
-4. 基于提供的数据和示例内容进行分析，不要编造信息
-5. 重点关注内容的主题、特点和价值
-6. 报告长度控制在150-200字
+        # Build template inputs from chunk analysis
+        inputs = await _build_insight_inputs(chunks, max_chunks, end_user_id)
 
-例如，如果输入是：
-- 内容领域分布: 技术(60%), 商业(25%), 教育(15%)
-- 内容规模: 共50个知识片段，平均长度320字
-内容示例: [示例内容...]
+        rendered_prompt = await render_memory_insight_prompt(
+            domain_distribution=inputs["domain_distribution"],
+            active_periods=inputs["active_periods"],
+            social_connections=inputs["social_connections"],
+            language=language,
+        )
 
-你的输出应该类似：
-"该知识库主要聚焦于技术领域(60%)，涵盖商业(25%)和教育(15%)相关内容。共包含50个知识片段，平均每个片段约320字，内容详实。从示例来看，内容涉及[具体主题]，体现了[特点]，对[目标用户]具有较高的参考价值。"
-"""
-        
-        user_prompt = "\n".join(prompt_parts)
-        
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_prompt}
-        ]
-        
-        # 调用LLM生成洞察
-        llm_client = _get_llm_client()
+        messages = [{"role": "user", "content": rendered_prompt}]
+        llm_client = _get_llm_client(end_user_id)
         response = await llm_client.chat(messages=messages)
-        
-        insight = response.content.strip()
-        business_logger.info(f"成功生成chunk洞察，分析了 {min(len(chunks), max_chunks)} 个片段")
-        
-        return insight
-        
+        raw_text = response.content.strip() if response and response.content else ""
+
+        sections = _parse_sections(raw_text, language=language)
+        sections["_raw"] = raw_text
+
+        business_logger.info(
+            f"成功生成chunk洞察四维度，分析了 {min(len(chunks), max_chunks)} 个片段"
+        )
+        return sections
+
     except Exception as e:
         business_logger.error(f"生成chunk洞察失败: {str(e)}")
-        return "洞察生成失败"
-
-
-if __name__ == "__main__":
-    # 测试代码
-    test_chunks = [
-        "Python是一种高级编程语言，以其简洁的语法和强大的功能而闻名。它广泛应用于Web开发、数据分析、人工智能等领域。",
-        "机器学习算法可以从数据中自动学习模式，无需显式编程。常见的算法包括决策树、随机森林、神经网络等。",
-        "深度学习是机器学习的一个分支，使用多层神经网络来学习数据的层次化表示。它在图像识别、语音识别等任务中表现出色。",
-        "自然语言处理技术使计算机能够理解和生成人类语言。应用包括机器翻译、情感分析、文本摘要等。",
-        "数据科学结合了统计学、计算机科学和领域知识，用于从数据中提取有价值的洞察。"
-    ]
-    
-    print("开始生成chunk洞察...")
-    insight = asyncio.run(generate_chunk_insight(test_chunks))
-    print(f"\n生成的洞察：\n{insight}")
+        empty = {k: "" for k in ("memory_insight", "behavior_pattern", "key_findings", "growth_trajectory")}
+        empty["_raw"] = "洞察生成失败"
+        return empty

api/app/core/rag_utils/chunk_summary.py

@@ -1,11 +1,10 @@
 """
-Generate summary for RAG chunks.
-
-This module provides functionality to summarize chunk content using LLM.
+Generate summary for RAG chunks using memory_summary.jinja2 prompt template.
 """
 
 import asyncio
-from typing import Any, Dict, List
+import os
+from typing import List, Optional
 
 from app.core.logging_config import get_business_logger
 from app.core.memory.utils.llm.llm_utils import MemoryClientFactory
@@ -14,94 +13,135 @@ from pydantic import BaseModel, Field
 
 business_logger = get_business_logger()
 
-
-def _get_llm_client():
-    """Get LLM client using db context."""
-    with get_db_context() as db:
-        factory = MemoryClientFactory(db)
-        return factory.get_llm_client(None)  # Uses default LLM
+DEFAULT_LLM_ID = os.getenv("SELECTED_LLM_ID", "openai/qwen-plus")
 
 
-class ChunkSummary(BaseModel):
-    """Pydantic model for chunk summary."""
-    summary: str = Field(..., description="简洁的chunk内容摘要")
+# ── Schema ──────────────────────────────────────────────────────────────────
+
+class MemorySummaryStatement(BaseModel):
+    """Single labelled statement extracted by memory_summary.jinja2."""
+    statement: str = Field(..., description="提取的陈述内容")
+    label: Optional[str] = Field(None, description="陈述标签")
 
 
-async def generate_chunk_summary(chunks: List[str], max_chunks: int = 10) -> str:
+class MemorySummaryResponse(BaseModel):
     """
-    Generate a summary for the given chunks.
-    
+    Structured output expected from memory_summary.jinja2.
+    The template asks for a JSON array of labelled statements;
+    we wrap it in an object so response_structured can parse it.
+    """
+    statements: List[MemorySummaryStatement] = Field(
+        default_factory=list,
+        description="从chunk中提取的陈述列表"
+    )
+    summary: Optional[str] = Field(None, description="整体摘要文本（可选）")
+
+
+# ── LLM client helper ────────────────────────────────────────────────────────
+
+def _get_llm_client(end_user_id: Optional[str] = None):
+    """Get LLM client, preferring user-connected config with fallback to default."""
+    with get_db_context() as db:
+        try:
+            if end_user_id:
+                from app.services.memory_agent_service import get_end_user_connected_config
+                from app.services.memory_config_service import MemoryConfigService
+                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 config_id or workspace_id:
+                    config_service = MemoryConfigService(db)
+                    memory_config = config_service.load_memory_config(
+                        config_id=config_id,
+                        workspace_id=workspace_id
+                    )
+                    factory = MemoryClientFactory(db)
+                    return factory.get_llm_client(memory_config.llm_model_id)
+        except Exception as e:
+            business_logger.warning(f"Failed to get user connected config, using default LLM: {e}")
+        factory = MemoryClientFactory(db)
+        return factory.get_llm_client(DEFAULT_LLM_ID)
+
+
+# ── Core function ─────────────────────────────────────────────────────────────
+
+async def generate_chunk_summary(
+    chunks: List[str],
+    max_chunks: int = 10,
+    end_user_id: Optional[str] = None,
+    language: str = "zh",
+) -> str:
+    """
+    Generate a user summary from RAG chunks using the memory_summary.jinja2 template.
+
+    The template extracts labelled statements from the chunks; we then join them
+    into a coherent summary string that can be stored in end_user.user_summary.
+
     Args:
         chunks: List of chunk content strings
-        max_chunks: Maximum number of chunks to process (default: 10)
-    
+        max_chunks: Maximum number of chunks to process
+        end_user_id: Optional end-user ID for model selection
+        language: Output language ("zh" or "en")
+
     Returns:
-        A concise summary of the chunks
+        Summary string (joined statements or fallback text)
     """
     if not chunks:
         business_logger.warning("没有提供chunk内容用于生成摘要")
         return "暂无内容"
-    
+
     try:
-        # 限制处理的chunk数量，避免token过多
+        from app.core.memory.utils.prompt.prompt_utils import render_memory_summary_prompt
+
         chunks_to_process = chunks[:max_chunks]
-        
-        # 合并chunk内容
-        combined_content = "\n\n".join([f"片段{i+1}: {chunk}" for i, chunk in enumerate(chunks_to_process)])
-        
-        # 构建prompt
-        system_prompt = (
-            "你是一位专业的文本摘要助手。请基于提供的文本片段，生成简洁的摘要。要求：\n"
-            "- 摘要长度控制在100-150字；\n"
-            "- 提取核心信息和关键要点；\n"
-            "- 使用客观、清晰的语言；\n"
-            "- 避免冗余和重复；\n"
-            "- 如果内容涉及多个主题，按重要性排序呈现。"
+        chunk_texts = "\n\n".join(
+            [f"片段{i + 1}: {chunk}" for i, chunk in enumerate(chunks_to_process)]
+        )
+
+        json_schema = MemorySummaryResponse.model_json_schema()
+
+        rendered_prompt = await render_memory_summary_prompt(
+            chunk_texts=chunk_texts,
+            json_schema=json_schema,
+            max_words=200,
+            language=language,
+        )
+
+        messages = [{"role": "user", "content": rendered_prompt}]
+
+        llm_client = _get_llm_client(end_user_id)
+
+        # Try structured output; fall back to plain chat only for LLMClientException
+        # (indicates the model/provider doesn't support structured output).
+        # All other exceptions are re-raised so config/schema errors stay visible.
+        try:
+            response: MemorySummaryResponse = await llm_client.response_structured(
+                messages=messages,
+                response_model=MemorySummaryResponse,
+            )
+            if response.summary:
+                summary = response.summary.strip()
+            elif response.statements:
+                summary = "；".join(s.statement for s in response.statements)
+            else:
+                summary = "暂无内容"
+        except Exception as e:
+            from app.core.memory.llm_tools.llm_client import LLMClientException
+            if isinstance(e, LLMClientException):
+                business_logger.warning(
+                    f"结构化输出不可用，降级为普通对话: end_user_id={end_user_id}, reason={e}"
+                )
+                raw = await llm_client.chat(messages=messages)
+                summary = raw.content.strip() if raw and raw.content else "暂无内容"
+            else:
+                business_logger.error(f"生成摘要时发生非预期异常: {e}")
+                raise
+
+        business_logger.info(
+            f"成功生成chunk摘要，处理了 {len(chunks_to_process)} 个片段"
         )
-        
-        user_prompt = f"请为以下文本片段生成摘要：\n\n{combined_content}"
-        
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_prompt},
-        ]
-        
-        # 调用LLM生成摘要
-        llm_client = _get_llm_client()
-        response = await llm_client.chat(messages=messages)
-        
-        summary = response.content.strip()
-        business_logger.info(f"成功生成chunk摘要，处理了 {len(chunks_to_process)} 个片段")
-        
         return summary
-        
+
     except Exception as e:
         business_logger.error(f"生成chunk摘要失败: {str(e)}")
         return "摘要生成失败"
-
-
-async def generate_chunk_summary_batch(chunks_list: List[List[str]]) -> List[str]:
-    """
-    Generate summaries for multiple chunk lists in batch.
-    
-    Args:
-        chunks_list: List of chunk lists
-    
-    Returns:
-        List of summaries
-    """
-    tasks = [generate_chunk_summary(chunks) for chunks in chunks_list]
-    return await asyncio.gather(*tasks)
-
-
-if __name__ == "__main__":
-    # 测试代码
-    test_chunks = [
-        "这是第一段测试内容，讲述了关于机器学习的基础知识。",
-        "第二段内容介绍了深度学习的应用场景和发展历史。",
-        "第三段讨论了自然语言处理技术的最新进展。"
-    ]
-    
-    print("开始生成chunk摘要...")
-    summary = asyncio.run(generate_chunk_summary(test_chunks))
-    print(f"\n生成的摘要：\n{summary}")

api/app/core/rag_utils/chunk_tags.py

@@ -5,8 +5,9 @@ This module provides functionality to extract meaningful tags from chunk content
 """
 
 import asyncio
+import os
 from collections import Counter
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 from app.core.logging_config import get_business_logger
 from app.core.memory.utils.llm.llm_utils import MemoryClientFactory
@@ -15,12 +16,31 @@ from pydantic import BaseModel, Field
 
 business_logger = get_business_logger()
 
+DEFAULT_LLM_ID = os.getenv("SELECTED_LLM_ID", "openai/qwen-plus")
 
-def _get_llm_client():
-    """Get LLM client using db context."""
+
+def _get_llm_client(end_user_id: Optional[str] = None):
+    """Get LLM client, preferring user-connected config with fallback to default."""
     with get_db_context() as db:
+        try:
+            if end_user_id:
+                from app.services.memory_agent_service import get_end_user_connected_config
+                from app.services.memory_config_service import MemoryConfigService
+                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 config_id or workspace_id:
+                    config_service = MemoryConfigService(db)
+                    memory_config = config_service.load_memory_config(
+                        config_id=config_id,
+                        workspace_id=workspace_id
+                    )
+                    factory = MemoryClientFactory(db)
+                    return factory.get_llm_client(memory_config.llm_model_id)
+        except Exception as e:
+            business_logger.warning(f"Failed to get user connected config, using default LLM: {e}")
         factory = MemoryClientFactory(db)
-        return factory.get_llm_client(None)  # Uses default LLM
+        return factory.get_llm_client(DEFAULT_LLM_ID)
 
 
 class ExtractedTags(BaseModel):
@@ -33,7 +53,7 @@ class ExtractedPersona(BaseModel):
     personas: List[str] = Field(..., description="从文本中提取的人物形象列表，如'产品设计师'、'旅行爱好者'等")
 
 
-async def extract_chunk_tags(chunks: List[str], max_tags: int = 10, max_chunks: int = 10) -> List[Tuple[str, int]]:
+async def extract_chunk_tags(chunks: List[str], max_tags: int = 10, max_chunks: int = 10, end_user_id: Optional[str] = None) -> List[Tuple[str, int]]:
     """
     Extract meaningful tags from the given chunks.
     
@@ -64,7 +84,7 @@ async def extract_chunk_tags(chunks: List[str], max_tags: int = 10, max_chunks:
             "标签应该是名词或名词短语，能够准确概括文本的核心内容。"
         )
         
-        llm_client = _get_llm_client()
+        llm_client = _get_llm_client(end_user_id)
         
         # 为每个chunk单独提取标签，然后统计频率
         all_tags = []
@@ -116,7 +136,7 @@ async def extract_chunk_tags_with_frequency(chunks: List[str], max_tags: int = 1
     return await extract_chunk_tags(chunks, max_tags=max_tags, max_chunks=len(chunks))
 
 
-async def extract_chunk_persona(chunks: List[str], max_personas: int = 5, max_chunks: int = 20) -> List[str]:
+async def extract_chunk_persona(chunks: List[str], max_personas: int = 5, max_chunks: int = 20, end_user_id: Optional[str] = None) -> List[str]:
     """
     Extract persona (人物形象) from the given chunks.
     
@@ -159,7 +179,7 @@ async def extract_chunk_persona(chunks: List[str], max_personas: int = 5, max_ch
         ]
         
         # 调用LLM提取人物形象
-        llm_client = _get_llm_client()
+        llm_client = _get_llm_client(end_user_id)
         structured_response = await llm_client.response_structured(
             messages=messages,
             response_model=ExtractedPersona

api/app/core/storage/factory.py

@@ -85,6 +85,7 @@ class StorageFactory:
                 access_key_id=settings.S3_ACCESS_KEY_ID,
                 secret_access_key=settings.S3_SECRET_ACCESS_KEY,
                 bucket_name=settings.S3_BUCKET_NAME,
+                endpoint_url=settings.S3_ENDPOINT_URL,
             )
 
         else:

api/app/core/storage/s3.py

@@ -35,6 +35,19 @@ class S3Storage(StorageBackend):
         bucket_name: The name of the S3 bucket.
         region: The AWS region.
     """
+    AMAZON_S3_ENDPOINT_MAP = {
+        "us-east-1": "https://s3.us-east-1.amazonaws.com",  # 特殊：无地域后缀
+        "us-east-2": "https://s3.us-east-2.amazonaws.com",
+        "us-west-1": "https://s3.us-west-1.amazonaws.com",
+        "us-west-2": "https://s3.us-west-2.amazonaws.com",
+        "ap-east-1": "https://s3.ap-east-1.amazonaws.com",  # 香港
+        "ap-southeast-1": "https://s3.ap-southeast-1.amazonaws.com",  # 新加坡
+        "ap-southeast-2": "https://s3.ap-southeast-2.amazonaws.com",  # 悉尼
+        "ap-northeast-1": "https://s3.ap-northeast-1.amazonaws.com",  # 东京
+        "eu-central-1": "https://s3.eu-central-1.amazonaws.com",  # 法兰克福
+        "eu-west-1": "https://s3.eu-west-1.amazonaws.com",  # 爱尔兰
+        # 可根据需要扩展其他地域
+    }
 
     def __init__(
         self,
@@ -42,6 +55,7 @@ class S3Storage(StorageBackend):
         access_key_id: str,
         secret_access_key: str,
         bucket_name: str,
+        endpoint_url: Optional[str] = None
     ):
         """
         Initialize the S3Storage backend.
@@ -51,6 +65,7 @@ class S3Storage(StorageBackend):
             access_key_id: The AWS access key ID.
             secret_access_key: The AWS secret access key.
             bucket_name: The name of the S3 bucket.
+            endpoint_url: The complete URL to use for the constructed client.
 
         Raises:
             StorageConfigError: If any required configuration is missing.
@@ -69,10 +84,19 @@ class S3Storage(StorageBackend):
         self.region = region
         self.bucket_name = bucket_name
 
+        if not endpoint_url:
+            # 优先匹配内置映射表（解决特殊地域）
+            if region in self.AMAZON_S3_ENDPOINT_MAP:
+                endpoint_url = self.AMAZON_S3_ENDPOINT_MAP[region]
+            # 兜底：通用拼接（适配未配置的新地域）
+            else:
+                endpoint_url = f"https://s3.{region}.amazonaws.com"
+
         try:
             self.client = boto3.client(
                 "s3",
                 region_name=region,
+                endpoint_url=endpoint_url,
                 aws_access_key_id=access_key_id,
                 aws_secret_access_key=secret_access_key,
             )

api/app/core/tools/mcp/client.py

@@ -53,6 +53,7 @@ class SimpleMCPClient:
             else:
                 await self._connect_http()
         except Exception as e:
+            await self.disconnect()
             logger.error(f"MCP连接失败: {self.server_url}, 错误: {e}")
             raise MCPConnectionError(f"连接失败: {e}")
     

api/app/core/workflow/adapters/__init__.py

@@ -0,0 +1,8 @@
+# -*- coding: UTF-8 -*-
+# Author: Eternity
+# @Email: 1533512157@qq.com
+# @Time : 2026/2/24 15:54
+from app.core.workflow.adapters.dify.dify_adapter import DifyAdapter
+from app.core.workflow.adapters.memory_bear.memory_bear_adapter import MemoryBearAdapter
+
+__all__ = ["DifyAdapter", "MemoryBearAdapter"]

api/app/core/workflow/adapters/base_adapter.py

@@ -0,0 +1,90 @@
+# -*- coding: UTF-8 -*-
+# Author: Eternity
+# @Email: 1533512157@qq.com
+# @Time : 2026/2/24 15:58
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from enum import StrEnum
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from app.core.workflow.adapters.errors import ExceptionDefineition
+from app.schemas.workflow_schema import (
+    EdgeDefinition,
+    NodeDefinition,
+    VariableDefinition,
+    ExecutionConfig,
+    TriggerConfig
+)
+
+
+class PlatformType(StrEnum):
+    MEMORY_BEAR = "memory_bear"
+    DIFY = "dify"
+    COZE = "coze"
+
+
+class PlatformMetadata(BaseModel):
+    platform_name: str
+    version: str
+    support_node_types: list[str]
+
+
+class WorkflowParserResult(BaseModel):
+    success: bool
+    platform: PlatformMetadata
+    execution_config: ExecutionConfig
+    origin_config: dict[str, Any]
+    trigger: TriggerConfig | None
+    edges: list[EdgeDefinition] = Field(default_factory=list)
+    nodes: list[NodeDefinition] = Field(default_factory=list)
+    variables: list[VariableDefinition] = Field(default_factory=list)
+    warnings: list[ExceptionDefineition] = Field(default_factory=list)
+    errors: list[ExceptionDefineition] = Field(default_factory=list)
+
+
+class WorkflowImportResult(BaseModel):
+    success: bool
+    temp_id: str | None = Field(..., description="cache id")
+    workflow_id: str | None = Field(..., description="workflow id")
+    edges: list[EdgeDefinition] = Field(default_factory=list)
+    nodes: list[NodeDefinition] = Field(default_factory=list)
+    variables: list[VariableDefinition] = Field(default_factory=list)
+    warnings: list[ExceptionDefineition] = Field(default_factory=list)
+    errors: list[ExceptionDefineition] = Field(default_factory=list)
+
+
+class BasePlatformAdapter(ABC):
+    def __init__(self, config: dict[str, Any]):
+        self.config = config
+        self.nodes: list[NodeDefinition] = []
+        self.edges: list[EdgeDefinition] = []
+        self.conv_variables: list[VariableDefinition] = []
+
+        self.errors = []
+        self.warnings = []
+
+        self.branch_node_cache = defaultdict(list)
+        self.error_branch_node_cache = []
+
+        self.node_output_map = {}
+
+    @abstractmethod
+    def get_metadata(self) -> PlatformMetadata:
+        """get platform metadata"""
+        pass
+
+    @abstractmethod
+    def validate_config(self) -> bool:
+        """platform configuration validate"""
+        pass
+
+    @abstractmethod
+    def parse_workflow(self) -> WorkflowParserResult:
+        """parse platform configuration to local config"""
+        pass
+
+    @abstractmethod
+    def map_node_type(self, platform_node_type: str) -> str:
+        pass

api/app/core/workflow/adapters/base_converter.py

@@ -0,0 +1,75 @@
+# -*- coding: UTF-8 -*-
+# Author: Eternity
+# @Email: 1533512157@qq.com
+# @Time : 2026/2/26 14:32
+from abc import ABC, abstractmethod
+
+from app.core.workflow.variable.base_variable import DEFAULT_VALUE, VariableType
+
+
+class BaseConverter(ABC):
+    @staticmethod
+    def _convert_string(var):
+        try:
+            return str(var)
+        except:
+            return DEFAULT_VALUE(VariableType.STRING)
+
+    @staticmethod
+    def _convert_boolean(var):
+        try:
+            return bool(var)
+        except:
+            return DEFAULT_VALUE(VariableType.BOOLEAN)
+
+    @staticmethod
+    def _convert_number(var):
+        try:
+            return float(var)
+        except:
+            return DEFAULT_VALUE(VariableType.NUMBER)
+
+    @staticmethod
+    def _convert_object(var):
+        try:
+            return dict(var)
+        except:
+            return DEFAULT_VALUE(VariableType.OBJECT)
+
+    @staticmethod
+    @abstractmethod
+    def _convert_file(var):
+        pass
+
+    @staticmethod
+    def _convert_array_string(var):
+        try:
+            return list(var)
+        except:
+            return DEFAULT_VALUE(VariableType.ARRAY_STRING)
+
+    @staticmethod
+    def _convert_array_number(var):
+        try:
+            return list(var)
+        except:
+            return DEFAULT_VALUE(VariableType.ARRAY_NUMBER)
+
+    @staticmethod
+    def _convert_array_boolean(var):
+        try:
+            return list(var)
+        except:
+            return DEFAULT_VALUE(VariableType.ARRAY_BOOLEAN)
+
+    @staticmethod
+    def _convert_array_object(var):
+        try:
+            return list(var)
+        except:
+            return DEFAULT_VALUE(VariableType.ARRAY_OBJECT)
+
+    @staticmethod
+    @abstractmethod
+    def _convert_array_file(var):
+        pass

api/app/core/workflow/adapters/dify/__init__.py

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

api/app/core/workflow/adapters/dify/converter.py

@@ -0,0 +1,773 @@
+# -*- coding: UTF-8 -*-
+# Author: Eternity
+# @Email: 1533512157@qq.com
+# @Time : 2026/2/25 18:21
+import base64
+import re
+from typing import Any
+from urllib.parse import quote
+
+from app.core.workflow.adapters.base_converter import BaseConverter
+from app.core.workflow.adapters.errors import (
+    UnsupportVariableType,
+    UnknowModelWarning,
+    ExceptionDefineition,
+    ExceptionType
+)
+from app.core.workflow.nodes.assigner.config import AssignmentItem
+from app.core.workflow.nodes.base_config import VariableDefinition, BaseNodeConfig
+from app.core.workflow.nodes.code.config import InputVariable, OutputVariable
+from app.core.workflow.nodes.configs import (
+    StartNodeConfig,
+    LLMNodeConfig,
+    AssignerNodeConfig,
+    CodeNodeConfig,
+    LoopNodeConfig,
+    IterationNodeConfig,
+    EndNodeConfig,
+    HttpRequestNodeConfig,
+    IfElseNodeConfig,
+    JinjaRenderNodeConfig,
+    KnowledgeRetrievalNodeConfig,
+    NoteNodeConfig,
+    ParameterExtractorNodeConfig,
+    QuestionClassifierNodeConfig,
+    VariableAggregatorNodeConfig
+)
+from app.core.workflow.nodes.cycle_graph.config import (
+    ConditionDetail as LoopConditionDetail,
+    ConditionsConfig,
+    CycleVariable
+)
+from app.core.workflow.nodes.enums import (
+    ValueInputType,
+    ComparisonOperator,
+    AssignmentOperator,
+    HttpAuthType,
+    HttpContentType,
+    HttpErrorHandle,
+    NodeType
+)
+from app.core.workflow.nodes.http_request.config import (
+    HttpAuthConfig,
+    HttpContentTypeConfig,
+    HttpFormData,
+    HttpTimeOutConfig,
+    HttpRetryConfig,
+    HttpErrorDefaultTamplete,
+    HttpErrorHandleConfig
+)
+from app.core.workflow.nodes.if_else.config import ConditionDetail, ConditionBranchConfig
+from app.core.workflow.nodes.jinja_render.config import VariablesMappingConfig
+from app.core.workflow.nodes.llm.config import MemoryWindowSetting, MessageConfig
+from app.core.workflow.nodes.parameter_extractor.config import ParamsConfig
+from app.core.workflow.nodes.question_classifier.config import ClassifierConfig
+from app.core.workflow.variable.base_variable import VariableType, DEFAULT_VALUE
+
+
+class DifyConverter(BaseConverter):
+    errors: list
+    warnings: list
+    branch_node_cache: dict
+    error_branch_node_cache: list
+    node_output_map: dict
+
+    def __init__(self):
+        self.CONFIG_CONVERT_MAP = {
+            NodeType.START: self.convert_start_node_config,
+            NodeType.LLM: self.convert_llm_node_config,
+            NodeType.END: self.convert_end_node_config,
+            NodeType.IF_ELSE: self.convert_if_else_node_config,
+            NodeType.LOOP: self.convert_loop_node_config,
+            NodeType.ITERATION: self.convert_iteration_node_config,
+            NodeType.ASSIGNER: self.convert_assigner_node_config,
+            NodeType.CODE: self.convert_code_node_config,
+            NodeType.HTTP_REQUEST: self.convert_http_node_config,
+            NodeType.JINJARENDER: self.convert_jinja_render_node_config,
+            NodeType.KNOWLEDGE_RETRIEVAL: self.convert_knowledge_node_config,
+            NodeType.PARAMETER_EXTRACTOR: self.convert_parameter_extractor_node_config,
+            NodeType.QUESTION_CLASSIFIER: self.convert_question_classifier_node_config,
+            NodeType.VAR_AGGREGATOR: self.convert_variable_aggregator_node_config,
+            NodeType.TOOL: self.convert_tool_node_config,
+            NodeType.NOTES: self.convert_notes_config,
+            NodeType.CYCLE_START: lambda x: {},
+            NodeType.BREAK: lambda x: {},
+        }
+
+    def get_node_convert(self, node_type):
+        func = self.CONFIG_CONVERT_MAP.get(node_type, lambda x: {})
+        return func
+
+    def config_validate(
+            self,
+            node_id: str,
+            node_name: str,
+            config: type[BaseNodeConfig],
+            value: dict
+    ):
+        try:
+            return config.model_validate(value)
+        except Exception as e:
+            self.errors.append(ExceptionDefineition(
+                type=ExceptionType.CONFIG,
+                node_id=node_id,
+                node_name=node_name,
+                detail=str(e)
+            ))
+            return None
+
+    @staticmethod
+    def is_variable(expression) -> bool:
+        return bool(re.match(r"\{\{#(.*?)#}}", expression))
+
+    def process_var_selector(self, var_selector):
+        if not var_selector:
+            return ""
+        selector = var_selector.split('.')
+        if len(selector) not in [2, 3] and var_selector != "context":
+            raise Exception(f"invalid variable selector: {var_selector}")
+        if len(selector) == 3:
+            selector = selector[1:]
+        if selector[0] == "conversation":
+            selector[0] = "conv"
+        var_selector = ".".join(selector)
+        mapping = {
+                      "sys.query": "sys.message"
+                  } | self.node_output_map
+
+        var_selector = mapping.get(var_selector, var_selector)
+        return var_selector
+
+    def _process_list_variable_litearl(self, variable_selector: list) -> str | None:
+        if not self.process_var_selector(".".join(variable_selector)):
+            return None
+        return "{{" + self.process_var_selector(".".join(variable_selector)) + "}}"
+
+    def trans_variable_format(self, content):
+        pattern = re.compile(r"\{\{#(.*?)#}}")
+
+        def replacer(match: re.Match) -> str:
+            raw_name = match.group(1)
+            new_name = self.process_var_selector(raw_name)
+            return f"{{{{{new_name}}}}}"
+
+        return pattern.sub(replacer, content)
+
+    @staticmethod
+    def _convert_file(var):
+        return None
+
+    @staticmethod
+    def _convert_array_file(var):
+        return []
+
+    @staticmethod
+    def variable_type_map(source_type) -> VariableType | None:
+        type_map = {
+            "file": VariableType.FILE,
+            "paragraph": VariableType.STRING,
+            "text-input": VariableType.STRING,
+            "number": VariableType.NUMBER,
+            "checkbox": VariableType.BOOLEAN,
+            "file-list": VariableType.ARRAY_FILE,
+            "select": VariableType.STRING,
+            "integer": VariableType.NUMBER,
+            "float": VariableType.NUMBER,
+        }
+        var_type = type_map.get(source_type, source_type)
+        return var_type
+
+    def convert_variable_type(self, target_type: VariableType, origin_value: Any):
+        if not origin_value:
+            return DEFAULT_VALUE(target_type)
+        try:
+            match target_type:
+                case VariableType.STRING:
+                    return self._convert_string(origin_value)
+                case VariableType.NUMBER:
+                    return self._convert_number(origin_value)
+                case VariableType.BOOLEAN:
+                    return self._convert_boolean(origin_value)
+                case VariableType.FILE:
+                    return self._convert_file(origin_value)
+                case VariableType.ARRAY_FILE:
+                    return self._convert_array_file(origin_value)
+                case _:
+                    return origin_value
+        except:
+            raise Exception(f"convert variable failed: {target_type}")
+
+    @staticmethod
+    def convert_compare_operator(operator):
+        operator_map = {
+            "is": ComparisonOperator.EQ,
+            "is not": ComparisonOperator.NE,
+            "=": ComparisonOperator.EQ,
+            "≠": ComparisonOperator.NE,
+            ">": ComparisonOperator.GT,
+            "<": ComparisonOperator.LT,
+            "≥": ComparisonOperator.GE,
+            "≤": ComparisonOperator.LE,
+            "not empty": ComparisonOperator.NOT_EMPTY,
+            "start with": ComparisonOperator.START_WITH,
+            "end with": ComparisonOperator.END_WITH,
+            "not contains": ComparisonOperator.NOT_CONTAINS,
+            "exists": ComparisonOperator.NOT_EMPTY,
+            "not exists": ComparisonOperator.EMPTY
+        }
+        return operator_map.get(operator, operator)
+
+    @staticmethod
+    def convert_assignment_operator(operator):
+        operator_map = {
+            "+=": AssignmentOperator.ADD,
+            "-=": AssignmentOperator.SUBTRACT,
+            "*=": AssignmentOperator.MULTIPLY,
+            "/=": AssignmentOperator.DIVIDE,
+            "over-write": AssignmentOperator.COVER,
+            "remove-last": AssignmentOperator.REMOVE_LAST,
+            "remove-first": AssignmentOperator.REMOVE_FIRST,
+            "set": AssignmentOperator.ASSIGN,
+        }
+        return operator_map.get(operator, operator)
+
+    @staticmethod
+    def convert_http_auth_type(auth_type):
+        auth_type_map = {
+            "no-auth": HttpAuthType.NONE,
+            "bearer": HttpAuthType.BEARER,
+            "basic": HttpAuthType.BASIC,
+            "custom": HttpAuthType.CUSTOM,
+        }
+        return auth_type_map.get(auth_type, auth_type)
+
+    @staticmethod
+    def convert_http_content_type(content_type):
+        content_type_map = {
+            "none": HttpContentType.NONE,
+            "form-data": HttpContentType.FROM_DATA,
+            "x-www-form-urlencoded": HttpContentType.WWW_FORM,
+            "json": HttpContentType.JSON,
+            "raw-text": HttpContentType.RAW,
+            "binary": HttpContentType.BINARY,
+        }
+        return content_type_map.get(content_type, content_type)
+
+    @staticmethod
+    def convert_http_error_handle_type(handle_type):
+        handle_type_map = {
+            "none": HttpErrorHandle.NONE,
+            "fail-branch": HttpErrorHandle.BRANCH,
+            "default-value": HttpErrorHandle.DEFAULT,
+        }
+        return handle_type_map.get(handle_type, handle_type)
+
+    def convert_start_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        start_vars = []
+        for var in node_data["variables"]:
+            var_type = self.variable_type_map(var["type"])
+            if not var_type:
+                self.errors.append(
+                    UnsupportVariableType(
+                        scope=node["id"],
+                        name=var["variable"],
+                        var_type=var["type"],
+                        node_id=node["id"],
+                        node_name=node_data["title"]
+                    )
+                )
+                continue
+
+            if var_type in ["file", "array[file]"]:
+                self.errors.append(
+                    ExceptionDefineition(
+                        type=ExceptionType.VARIABLE,
+                        node_id=node["id"],
+                        node_name=node_data["title"],
+                        name=var["variable"],
+                        detail=f"Unsupported Variable type for start node: {var_type}"
+                    )
+                )
+                continue
+
+            var_def = VariableDefinition(
+                name=var["variable"],
+                type=var_type,
+                required=var["required"],
+                default=self.convert_variable_type(
+                    var_type, var.get("default")
+                ),
+                description=var["label"],
+                max_length=var.get("max_length", 50),
+            )
+            start_vars.append(var_def)
+        result = StartNodeConfig.model_construct(
+            variables=start_vars
+        ).model_dump()
+        self.config_validate(node["id"], node["data"]["title"], StartNodeConfig, result)
+        return result
+
+    def convert_question_classifier_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        self.warnings.append(
+            UnknowModelWarning(
+                node_id=node["id"],
+                node_name=node_data["title"],
+                model_name=node_data["model"].get("name")
+            )
+        )
+        categories = []
+        for category in node_data["classes"]:
+            self.branch_node_cache[node["id"]].append(category["id"])
+            categories.append(
+                ClassifierConfig.model_construct(
+                    class_name=category["name"],
+                )
+            )
+
+        result = QuestionClassifierNodeConfig.model_construct(
+            input_variable=self._process_list_variable_litearl(node_data.get("query_variable_selector")),
+            user_supplement_prompt=self.trans_variable_format(node_data.get("instructions", "")),
+            categories=categories,
+        ).model_dump()
+        self.config_validate(node["id"], node["data"]["title"], QuestionClassifierNodeConfig, result)
+        return result
+
+    def convert_llm_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        self.warnings.append(
+            UnknowModelWarning(
+                node_id=node["id"],
+                node_name=node_data["title"],
+                model_name=node_data["model"].get("name")
+            )
+        )
+        context = self._process_list_variable_litearl(node_data["context"]["variable_selector"])
+        memory = MemoryWindowSetting(
+            enable=bool(node_data.get("memory")),
+            enable_window=bool(node_data.get("memory", {}).get("window", {}).get("enabled", False)),
+            window_size=int(node_data.get("memory", {}).get("window", {}).get("size", 20))
+        )
+        messages = []
+        for message in node_data["prompt_template"]:
+            messages.append(
+                MessageConfig(
+                    role=message["role"],
+                    content=self.trans_variable_format(message["text"])
+                )
+            )
+        if memory.enable:
+            messages.append(
+                MessageConfig(
+                    role="user",
+                    content=self.trans_variable_format(
+                        node_data["memory"].get("query_prompt_template") or "{{#sys.query#}}"
+                    )
+                )
+            )
+        vision = node_data["vision"]["enabled"]
+        vision_input = self._process_list_variable_litearl(
+            node_data["vision"]["configs"]["variable_selector"]
+        ) if vision else None
+        result = LLMNodeConfig.model_construct(
+            model_id=None,
+            context=context,
+            memory=memory,
+            vision=vision,
+            vision_input=vision_input,
+            messages=messages
+        ).model_dump()
+        self.config_validate(node["id"], node["data"]["title"], LLMNodeConfig, result)
+        return result
+
+    def convert_end_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        result = EndNodeConfig.model_construct(
+            output=self.trans_variable_format(node_data.get("answer", "")),
+        ).model_dump()
+        self.config_validate(node["id"], node["data"]["title"], EndNodeConfig, result)
+        return result
+
+    def convert_if_else_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        cases = []
+        for case in node_data["cases"]:
+            case_id = case.get("id") or case.get("case_id")
+            logical_operator = case["logical_operator"]
+            conditions = []
+            for condition in case["conditions"]:
+                right_value = condition["value"]
+                condition_detail = ConditionDetail(
+                    operator=self.convert_compare_operator(condition["comparison_operator"]),
+                    left="{{" + self.process_var_selector(".".join(condition["variable_selector"])) + "}}",
+                    right=self.trans_variable_format(
+                        right_value
+                    ) if isinstance(right_value, str) and self.is_variable(right_value) else self.convert_variable_type(
+                        self.variable_type_map(condition["varType"]),
+                        condition["value"]
+                    ),
+                    input_type=ValueInputType.VARIABLE
+                    if isinstance(right_value, str) and self.is_variable(right_value) else ValueInputType.CONSTANT,
+                )
+                conditions.append(condition_detail)
+            cases.append(
+                ConditionBranchConfig(
+                    logical_operator=logical_operator,
+                    expressions=conditions
+                )
+            )
+            self.branch_node_cache[node["id"]].append(case_id)
+        result = IfElseNodeConfig.model_construct(
+            cases=cases
+        ).model_dump()
+        self.config_validate(node["id"], node["data"]["title"], IfElseNodeConfig, result)
+        return result
+
+    def convert_loop_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        logical_operator = node_data["logical_operator"]
+        conditions = []
+        for condition in node_data["break_conditions"]:
+            right_value = condition["value"]
+            conditions.append(
+                LoopConditionDetail.model_construct(
+                    operator=self.convert_compare_operator(condition["comparison_operator"]),
+                    left=self._process_list_variable_litearl(condition["variable_selector"]),
+                    right=self.trans_variable_format(
+                        right_value
+                    ) if isinstance(right_value, str) and self.is_variable(right_value) else self.convert_variable_type(
+                        self.variable_type_map(condition["varType"]),
+                        condition["value"]
+                    ),
+                    input_type=ValueInputType.VARIABLE
+                    if isinstance(right_value, str) and self.is_variable(right_value) else ValueInputType.CONSTANT,
+                )
+            )
+        condition_config = ConditionsConfig.model_construct(
+            logical_operator=logical_operator,
+            expressions=conditions
+        )
+        loop_variables = []
+        for variable in node_data["loop_variables"]:
+            right_input_type = variable["value_type"]
+            right_value_type = self.variable_type_map(variable["var_type"])
+            if right_input_type == ValueInputType.VARIABLE:
+                right_value = self._process_list_variable_litearl(variable.get("value", ""))
+            else:
+                right_value = self.convert_variable_type(right_value_type, variable.get("value", ""))
+            loop_variables.append(
+                CycleVariable(
+                    name=variable["label"],
+                    type=right_value_type,
+                    value=right_value,
+                    input_type=right_input_type
+                )
+            )
+        result = LoopNodeConfig.model_construct(
+            condition=condition_config,
+            cycle_vars=loop_variables,
+            max_loop=node_data.get("loop_count", 10)
+        ).model_dump()
+        self.config_validate(node["id"], node["data"]["title"], LoopNodeConfig, result)
+        return result
+
+    def convert_iteration_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        result = IterationNodeConfig.model_construct(
+            input=self._process_list_variable_litearl(node_data["iterator_selector"]),
+            parallel=node_data["is_parallel"],
+            parallel_count=node_data["parallel_nums"],
+            output=self._process_list_variable_litearl(node_data["output_selector"]),
+            output_type=self.variable_type_map(node_data.get("output_type")),
+            flatten=node_data["flatten_output"],
+        ).model_dump()
+
+        self.config_validate(node["id"], node["data"]["title"], IterationNodeConfig, result)
+        return result
+
+    def convert_assigner_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        assignments = []
+        for assignment in node_data["items"]:
+            if assignment.get("operation") is None or assignment.get("value") is None:
+                continue
+            assignments.append(
+                AssignmentItem(
+                    variable_selector=self._process_list_variable_litearl(assignment["variable_selector"]),
+                    value=self._process_list_variable_litearl(
+                        assignment["value"]
+                    ) if assignment["input_type"] == ValueInputType.VARIABLE else assignment["value"],
+                    operation=self.convert_assignment_operator(assignment["operation"])
+                )
+            )
+        result = AssignerNodeConfig.model_construct(
+            assignments=assignments
+        ).model_dump()
+        self.config_validate(node["id"], node["data"]["title"], AssignerNodeConfig, result)
+        return result
+
+    def convert_code_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        input_variables = []
+        for input_variable in node_data["variables"]:
+            input_variables.append(
+                InputVariable.model_construct(
+                    name=input_variable["variable"],
+                    variable=self._process_list_variable_litearl(input_variable["value_selector"]),
+                )
+            )
+
+        output_variables = []
+        for output_variable in node_data["outputs"]:
+            output_variables.append(
+                OutputVariable.model_construct(
+                    name=output_variable,
+                    type=node_data["outputs"][output_variable]["type"],
+                )
+            )
+
+        code = base64.b64encode(quote(node_data["code"]).encode("utf-8")).decode("utf-8")
+
+        result = CodeNodeConfig.model_construct(
+            input_variables=input_variables,
+            language=node_data["code_language"],
+            output_variables=output_variables,
+            code=code
+        ).model_dump()
+        self.config_validate(node["id"], node["data"]["title"], CodeNodeConfig, result)
+        return result
+
+    def convert_http_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        if node_data["authorization"]["type"] != 'no-auth':
+            auth_type = self.convert_http_auth_type(node_data["authorization"]["config"]["type"])
+            auth_config = HttpAuthConfig.model_construct(
+                auth_type=auth_type,
+                header=node_data["authorization"]["config"].get("header"),
+                api_key=node_data["authorization"]["config"].get("api_key"),
+            )
+        else:
+            auth_config = HttpAuthConfig()
+
+        content_type = self.convert_http_content_type(node_data["body"]["type"])
+        if content_type == HttpContentType.FROM_DATA:
+            body_content = []
+            for content in node_data["body"]["data"]:
+                body_content.append(
+                    HttpFormData(
+                        key=self.trans_variable_format(content["key"]),
+                        type=content["type"],
+                        value=self.trans_variable_format(content["value"]),
+                    )
+                )
+        elif content_type == HttpContentType.WWW_FORM:
+            body_content = {}
+            for content in node_data["body"]["data"]:
+                body_content[
+                    self.trans_variable_format(content["key"])
+                ] = self.trans_variable_format(content["value"])
+        else:
+            if node_data["body"]["data"]:
+                body_content = (node_data["body"]["data"][0].get("value") or
+                                self._process_list_variable_litearl(node_data["body"]["data"][0].get("file")))
+            else:
+                body_content = ""
+
+        headers = {}
+        for header in node_data.get("headers", "").split("\n"):
+            if not header:
+                continue
+
+            key_value = header.split(":")
+            if len(key_value) == 2:
+                headers[
+                    self.trans_variable_format(key_value[0])
+                ] = self.trans_variable_format(key_value[1])
+            else:
+                self.warnings.append(ExceptionDefineition(
+                    type=ExceptionType.CONFIG,
+                    node_id=node["id"],
+                    node_name=node_data["title"],
+                    detail=f"Invalid header/param - {header}",
+                ))
+
+        params = {}
+        for param in node_data.get("params", "").split("\n"):
+            if not param:
+                continue
+
+            key_value = param.split(":")
+            if len(key_value) == 2:
+                params[
+                    self.trans_variable_format(key_value[0])
+                ] = self.trans_variable_format(key_value[1])
+            else:
+                self.warnings.append(ExceptionDefineition(
+                    type=ExceptionType.CONFIG,
+                    node_id=node["id"],
+                    node_name=node_data["title"],
+                    detail=f"Invalid header/param - {param}",
+                ))
+
+        error_handle_type = self.convert_http_error_handle_type(
+            node_data.get("error_strategy", "none")
+        )
+        default_value = None
+        if error_handle_type == HttpErrorHandle.DEFAULT:
+            default_body = ""
+            default_header = {}
+            default_status_code = 0
+            for var in node_data.get("default_value") or []:
+                if var["key"] == "body":
+                    default_body = var["value"]
+                elif var["key"] == "header":
+                    default_header = var["value"]
+                elif var["key"] == "status_code":
+                    default_status_code = var["value"]
+            default_value = HttpErrorDefaultTamplete(
+                body=default_body,
+                headers=default_header,
+                status_code=default_status_code,
+            )
+
+        self.error_branch_node_cache.append(node['id'])
+        result = HttpRequestNodeConfig.model_construct(
+            method=node_data["method"].upper(),
+            url=node_data["url"],
+            auth=auth_config,
+            body=HttpContentTypeConfig.model_construct(
+                content_type=self.convert_http_content_type(node_data["body"]["type"]),
+                data=body_content,
+            ),
+            headers=headers,
+            params=params,
+            verify_ssl=node_data.get("ssl_verify", False),
+            timeouts=HttpTimeOutConfig.model_construct(
+                connect_timeout=node_data["timeout"]["max_connect_timeout"] or 5,
+                read_timeout=node_data["timeout"]["max_read_timeout"] or 5,
+                write_timeout=node_data["timeout"]["max_write_timeout"] or 5,
+            ),
+            retry=HttpRetryConfig.model_construct(
+                enable=node_data["retry_config"]["retry_enabled"],
+                max_attempts=node_data["retry_config"]["max_retries"],
+                retry_interval=node_data["retry_config"]["retry_interval"],
+            ),
+            error_handle=HttpErrorHandleConfig.model_construct(
+                method=error_handle_type,
+                default=default_value,
+            )
+        ).model_dump()
+
+        self.config_validate(node["id"], node["data"]["title"], HttpRequestNodeConfig, result)
+        return result
+
+    def convert_jinja_render_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        mapping = []
+        for variable in node_data["variables"]:
+            mapping.append(VariablesMappingConfig.model_construct(
+                name=variable["variable"],
+                value=self._process_list_variable_litearl(variable["value_selector"])
+            ))
+        result = JinjaRenderNodeConfig.model_construct(
+            template=node_data["template"],
+            mapping=mapping,
+        ).model_dump()
+        self.config_validate(node["id"], node["data"]["title"], JinjaRenderNodeConfig, result)
+        return result
+
+    def convert_knowledge_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        self.warnings.append(ExceptionDefineition(
+            node_id=node["id"],
+            node_name=node_data["title"],
+            type=ExceptionType.CONFIG,
+            detail=f"Please reconfigure the Knowledge Retrieval node.",
+        ))
+        result = KnowledgeRetrievalNodeConfig.model_construct(
+            query=self._process_list_variable_litearl(node_data["query_variable_selector"]),
+        ).model_dump()
+
+        self.config_validate(node["id"], node["data"]["title"], KnowledgeRetrievalNodeConfig, result)
+        return result
+
+    def convert_parameter_extractor_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        self.warnings.append(
+            UnknowModelWarning(
+                node_id=node["id"],
+                node_name=node_data["title"],
+                model_name=node_data["model"].get("name")
+            )
+        )
+        params = []
+        for param in node_data.get("parameters", []):
+            params.append(
+                ParamsConfig.model_construct(
+                    name=param["name"],
+                    desc=param["description"],
+                    required=param["required"],
+                    type=param["type"],
+                )
+            )
+        result = ParameterExtractorNodeConfig.model_construct(
+            text=self._process_list_variable_litearl(node_data["query"]),
+            params=params,
+            prompt=node_data.get("instruction")
+        ).model_dump()
+
+        self.config_validate(node["id"], node["data"]["title"], ParameterExtractorNodeConfig, result)
+        return result
+
+    def convert_variable_aggregator_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        advanced_settings = node_data.get("advanced_settings", {})
+        group_variables = {}
+        group_type = {}
+        if not advanced_settings or not advanced_settings["group_enabled"]:
+            group_variables = [
+                self._process_list_variable_litearl(variable)
+                for variable in node_data["variables"]
+            ]
+            group_type["output"] = node_data["output_type"]
+        else:
+            for group in advanced_settings["groups"]:
+                group_variables[group["group_name"]] = [
+                    self._process_list_variable_litearl(variable)
+                    for variable in group["variables"]
+                ]
+                group_type[group["group_name"]] = group["output_type"]
+
+        result = VariableAggregatorNodeConfig.model_construct(
+            group=advanced_settings.get("group_enabled", False),
+            group_variables=group_variables,
+            group_type=group_type,
+        ).model_dump()
+
+        self.config_validate(node["id"], node["data"]["title"], VariableAggregatorNodeConfig, result)
+
+        return result
+
+    def convert_tool_node_config(self, node: dict) -> dict:
+        node_data = node["data"]
+        self.warnings.append(ExceptionDefineition(
+            node_id=node["id"],
+            node_name=node_data["title"],
+            type=ExceptionType.CONFIG,
+            detail=f"Please reconfigure the tool node.",
+        ))
+        return {}
+
+    @staticmethod
+    def convert_notes_config(node: dict):
+        node_data = node["data"]
+        result = NoteNodeConfig.model_construct(
+            author=node_data.get("author", ""),
+            text=node_data.get("text", ""),
+            width=node_data.get("width", 80),
+            height=node_data.get("height", 80),
+            theme=node_data.get("theme", "blue"),
+            show_author=node_data.get("showAuthor", True)
+        ).model_dump()
+        return result

api/app/core/workflow/adapters/dify/dify_adapter.py

@@ -0,0 +1,259 @@
+# -*- coding: UTF-8 -*-
+# Author: Eternity
+# @Email: 1533512157@qq.com
+# @Time : 2026/2/24 16:05
+from typing import Any
+
+from app.core.logging_config import get_logger
+from app.core.workflow.adapters.base_adapter import (
+    BasePlatformAdapter,
+    PlatformMetadata,
+    PlatformType,
+    WorkflowParserResult
+)
+from app.core.workflow.adapters.dify.converter import DifyConverter
+from app.core.workflow.adapters.errors import ExceptionDefineition, ExceptionType
+from app.core.workflow.nodes.enums import NodeType
+from app.schemas.workflow_schema import (
+    NodeDefinition,
+    EdgeDefinition,
+    VariableDefinition,
+    TriggerConfig,
+    ExecutionConfig
+)
+
+logger = get_logger()
+
+
+class DifyAdapter(BasePlatformAdapter, DifyConverter):
+    NODE_TYPE_MAPPING = {
+        "start": NodeType.START,
+        "llm": NodeType.LLM,
+        "answer": NodeType.END,
+        "if-else": NodeType.IF_ELSE,
+        "loop-start": NodeType.CYCLE_START,
+        "iteration-start": NodeType.CYCLE_START,
+        "assigner": NodeType.ASSIGNER,
+        "loop": NodeType.LOOP,
+        "iteration": NodeType.ITERATION,
+        "loop-end": NodeType.BREAK,
+        "code": NodeType.CODE,
+        "http-request": NodeType.HTTP_REQUEST,
+        "template-transform": NodeType.JINJARENDER,
+        "knowledge-retrieval": NodeType.KNOWLEDGE_RETRIEVAL,
+        "parameter-extractor": NodeType.PARAMETER_EXTRACTOR,
+        "question-classifier": NodeType.QUESTION_CLASSIFIER,
+        "variable-aggregator": NodeType.VAR_AGGREGATOR,
+        "tool": NodeType.TOOL,
+        "": NodeType.NOTES
+    }
+
+    def __init__(self, config: dict[str, Any]):
+        DifyConverter.__init__(self)
+        BasePlatformAdapter.__init__(self, config)
+
+    def get_metadata(self) -> PlatformMetadata:
+        return PlatformMetadata(
+            platform_name=PlatformType.DIFY,
+            version="0.5.0",
+            support_node_types=list(self.NODE_TYPE_MAPPING.keys())
+        )
+
+    def map_node_type(self, platform_node_type) -> NodeType:
+        return self.NODE_TYPE_MAPPING.get(platform_node_type, NodeType.UNKNOWN)
+
+    @property
+    def origin_nodes(self):
+        return self.config.get("workflow").get("graph").get("nodes")
+
+    @property
+    def origin_edges(self):
+        return self.config.get("workflow").get("graph").get("edges")
+
+    @staticmethod
+    def _valid_nodes(node: dict[str, Any]):
+        if "data" not in node:
+            return False
+        if "type" not in node["data"]:
+            return False
+        if "id" not in node or "type" not in node:
+            return False
+        return True
+
+    def validate_config(self) -> bool:
+        require_fields = frozenset({'app', 'kind', 'version', 'workflow'})
+        if not all(field in self.config for field in require_fields):
+            return False
+        if self.config.get("app", {}).get("mode") == "workflow":
+            self.errors.append(ExceptionDefineition(
+                type=ExceptionType.PLATFORM,
+                detail="workflow mode is not supported"
+            ))
+            return False
+
+        for node in self.origin_nodes:
+            if not self._valid_nodes(node):
+                return False
+        return True
+
+    def parse_workflow(self) -> WorkflowParserResult:
+        self._init_node_output_map()
+        for node in self.origin_nodes:
+            node = self._convert_node(node)
+            if node:
+                self.nodes.append(node)
+        nodes_id = [node.id for node in self.nodes]
+        for edge in self.origin_edges:
+            source = edge["source"]
+            target = edge["target"]
+            if source not in nodes_id or target not in nodes_id:
+                continue
+            edge = self._convert_edge(edge)
+            if edge:
+                self.edges.append(edge)
+        #
+        for variable in self.config.get("workflow").get("conversation_variables"):
+            con_var = self._convert_variable(variable)
+            if variable:
+                self.conv_variables.append(con_var)
+        #
+        # for variables in config.get("workflow").get("environment_variables"):
+        #     variable = self._convert_variable(variables)
+        #     conv_variables.append(variable)
+
+        trigger = self._convert_trigger({})
+        execution_config = self._convert_execution({})
+
+        return WorkflowParserResult(
+            success=not self.errors and not self.warnings,
+            platform=self.get_metadata(),
+            execution_config=execution_config,
+            origin_config=self.config,
+            trigger=trigger,
+            edges=self.edges,
+            nodes=self.nodes,
+            variables=self.conv_variables,
+            warnings=self.warnings,
+            errors=self.errors
+        )
+
+    def _init_node_output_map(self):
+        for node in self.origin_nodes:
+            if self.map_node_type(node["data"]["type"]) == NodeType.LLM:
+                self.node_output_map[f"{node['id']}.text"] = f"{node['id']}.output"
+            elif self.map_node_type(node["data"]["type"]) == NodeType.KNOWLEDGE_RETRIEVAL:
+                self.node_output_map[f"{node['id']}.result"] = f"{node['id']}.output"
+
+    def _convert_cycle_node_position(self, node_id: str, position: dict):
+        for node in self.origin_nodes:
+            if node["id"] == node_id:
+                return {
+                    "x": node["position"]["x"] + position["x"],
+                    "y": node["position"]["y"] + position["y"]
+                }
+        self.errors.append(
+            ExceptionDefineition(
+                type=ExceptionType.NODE,
+                node_id=node_id,
+                detail="parent cycle node not found"
+            )
+        )
+        raise Exception("parent cycle node not found")
+
+    def _convert_node(self, node: dict[str, Any]) -> NodeDefinition | None:
+        node_data = node["data"]
+        try:
+            node_type = self.map_node_type(node_data["type"])
+            return NodeDefinition(
+                id=node["id"],
+                type=node_type,
+                name=node_data.get("title") or "notes",
+                cycle=node.get("parentId"),
+                description=None,
+                config=self._convert_node_config(node_type, node),
+                position={
+                    "x": node["position"]["x"],
+                    "y": node["position"]["y"]
+                } if node.get("parentId") is None else self._convert_cycle_node_position(
+                    node["parentId"],
+                    node["position"]
+                ),
+                error_handling=None,
+                cache=None
+            )
+        except Exception as e:
+            logger.debug(f"convert node error - {e}", exc_info=True)
+
+    def _convert_node_config(self, node_type: NodeType, node: dict):
+        try:
+            node_data = node["data"]
+            converter = self.get_node_convert(node_type)
+            if node_type == NodeType.UNKNOWN:
+                self.errors.append(ExceptionDefineition(
+                    type=ExceptionType.NODE,
+                    node_id=node["id"],
+                    node_name=node["data"]["title"],
+                    detail=f"node type {node_data.get('type')} is unsupported",
+                ))
+            return converter(node)
+        except Exception as e:
+            self.errors.append(ExceptionDefineition(
+                type=ExceptionType.NODE,
+                node_id=node["id"],
+                node_name=node["data"]["title"],
+                detail=f"convert node error - {e}",
+            ))
+            raise e
+
+    def _convert_edge(self, edge: dict[str, Any]) -> EdgeDefinition | None:
+        try:
+
+            source = edge["source"]
+            target = edge["target"]
+            label = None
+            if source in self.branch_node_cache:
+                case_id = edge["sourceHandle"]
+                if case_id == "false":
+                    label = f'CASE{len(self.branch_node_cache[source]) + 1}'
+                else:
+                    label = f'CASE{self.branch_node_cache[source].index(case_id) + 1}'
+            if source in self.error_branch_node_cache:
+                case_id = edge["sourceHandle"]
+                if case_id == "source":
+                    label = "SUCCESS"
+                else:
+                    label = "ERROR"
+            return EdgeDefinition(
+                id=edge["id"],
+                source=source,
+                target=target,
+                label=label,
+            )
+        except Exception as e:
+            self.errors.append(ExceptionDefineition(
+                type=ExceptionType.EDGE,
+                detail=f"convert edge error - {e}",
+            ))
+            logger.debug(f"convert edge error - {e}", exc_info=True)
+            return None
+
+    def _convert_variable(self, variable) -> VariableDefinition | None:
+        try:
+            return VariableDefinition(
+                name=variable["name"],
+                default=variable["value"],
+                type=self.variable_type_map(variable["value_type"]),
+                description=variable.get("description")
+            )
+        except Exception as e:
+            self.errors.append(ExceptionDefineition(
+                type=ExceptionType.VARIABLE,
+                name=variable.get("name"),
+                detail=f"convert variable error - {e}",
+            ))
+
+    def _convert_trigger(self, trigger: dict[str, Any]) -> TriggerConfig | None:
+        pass
+
+    def _convert_execution(self, execution: dict[str, Any]) -> ExecutionConfig:
+        return ExecutionConfig()

api/app/core/workflow/adapters/errors.py

@@ -0,0 +1,75 @@
+# -*- coding: UTF-8 -*-
+# Author: Eternity
+# @Email: 1533512157@qq.com
+# @Time : 2026/2/26 11:29
+from enum import StrEnum
+
+from pydantic import BaseModel
+
+
+class ExceptionType(StrEnum):
+    NODE = "node"
+    EDGE = "edge"
+    VARIABLE = "variable"
+    TRIGGER = "trigger"
+    EXECUTION = "execution"
+    CONFIG = "config"
+    PLATFORM = "platform"
+    UNKNOWN = "unknown"
+
+
+class ExceptionDefineition(BaseModel):
+    type: ExceptionType
+    detail: str
+
+    node_id: str | None = None
+    node_name: str | None = None
+
+    scope: str | None = None
+    name: str | None = None
+
+
+class UnknowModelWarning(ExceptionDefineition):
+    type: ExceptionType = ExceptionType.NODE
+
+    def __init__(self, node_id, node_name, model_name):
+        super().__init__(
+            detail=f"Please specify the model mapping manually for model: {model_name}",
+            node_id=node_id,
+            node_name=node_name
+        )
+
+
+class UnknowError(ExceptionDefineition):
+    type: ExceptionType = ExceptionType.UNKNOWN
+
+    def __init__(self, detail: str, **kwargs):
+        super().__init__(detail=detail, **kwargs)
+
+
+class UnsupportPlatform(ExceptionDefineition):
+    type: ExceptionType = ExceptionType.PLATFORM
+
+    def __init__(self, platform: str):
+        super().__init__(detail=f"Unsupport platform {platform}")
+
+
+class UnsupportVariableType(ExceptionDefineition):
+    type: ExceptionType = ExceptionType.VARIABLE
+
+    def __init__(self, scope, name, var_type: str, **kwargs):
+        super().__init__(scope=scope, name=name, detail=f"Unsupport variable type：[{var_type}]", **kwargs)
+
+
+class InvalidConfiguration(ExceptionDefineition):
+    type: ExceptionType = ExceptionType.CONFIG
+
+    def __init__(self):
+        super().__init__(detail="Invalid workflow configuration format")
+
+
+class UnsupportNodeType(ExceptionDefineition):
+    type: ExceptionType = ExceptionType.NODE
+
+    def __init__(self, node_id: str, node_type: str):
+        super().__init__(node_id=node_id, detail=f"Unsupport node Type {node_type}")

api/app/core/workflow/adapters/memory_bear/__init__.py

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

api/app/core/workflow/adapters/memory_bear/memory_bear_adapter.py

@@ -0,0 +1,155 @@
+# -*- coding: UTF-8 -*-
+# Author: Eternity
+# @Email: 1533512157@qq.com
+# @Time : 2026/2/25 14:11
+from typing import Any
+
+from app.core.logging_config import get_logger
+from app.core.workflow.adapters.base_adapter import (
+    PlatformMetadata,
+    PlatformType,
+    BasePlatformAdapter,
+    WorkflowParserResult
+)
+from app.core.workflow.adapters.errors import ExceptionDefineition, ExceptionType, UnsupportNodeType
+from app.core.workflow.adapters.memory_bear.memory_bear_converter import MemoryBearConverter
+from app.core.workflow.nodes.enums import NodeType
+from app.schemas.workflow_schema import ExecutionConfig, NodeDefinition, EdgeDefinition, VariableDefinition
+
+logger = get_logger()
+
+VALID_NODE_TYPES = frozenset(t.value for t in NodeType if t != NodeType.UNKNOWN)
+
+
+class MemoryBearAdapter(BasePlatformAdapter, MemoryBearConverter):
+    NODE_TYPE_MAPPING = {t.value: t for t in NodeType}
+
+    def __init__(self, config: dict[str, Any]):
+        MemoryBearConverter.__init__(self)
+        BasePlatformAdapter.__init__(self, config)
+
+    @property
+    def origin_nodes(self):
+        return self.config.get("workflow").get("nodes") or []
+
+    @property
+    def origin_edges(self):
+        return self.config.get("workflow").get("edges") or []
+
+    @property
+    def origin_variables(self):
+        return self.config.get("workflow").get("variables") or []
+
+    def get_metadata(self) -> PlatformMetadata:
+        return PlatformMetadata(
+            platform_name=PlatformType.MEMORY_BEAR,
+            version="0.2.5",
+            support_node_types=list(VALID_NODE_TYPES)
+        )
+
+    def map_node_type(self, platform_node_type: str) -> NodeType:
+        return self.NODE_TYPE_MAPPING.get(platform_node_type, NodeType.UNKNOWN)
+
+    @staticmethod
+    def _valid_node(node: dict[str, Any]) -> bool:
+        if "id" not in node or "type" not in node:
+            return False
+        if not isinstance(node.get("config"), dict):
+            return False
+        return True
+
+    def validate_config(self) -> bool:
+        require_fields = frozenset({'app', 'workflow'})
+        if not all(field in self.config for field in require_fields):
+            return False
+        for node in self.origin_nodes:
+            if not self._valid_node(node):
+                return False
+        return True
+
+    def _convert_node(self, node: dict[str, Any]) -> NodeDefinition | None:
+        node_id = node.get("id")
+        node_name = node.get("name")
+        try:
+            node_type = self.map_node_type(node["type"])
+            if node_type == NodeType.UNKNOWN:
+                self.errors.append(UnsupportNodeType(
+                    node_id=node_id,
+                    node_type=node["type"]
+                ))
+                return None
+
+            config = node.get("config") or {}
+            converter = self.get_node_convert(node_type)
+            converter(node_id, node_name, config)  # validates and appends errors if invalid
+
+            return NodeDefinition(**node)
+        except Exception as e:
+            self.errors.append(ExceptionDefineition(
+                type=ExceptionType.NODE,
+                node_id=node_id,
+                node_name=node_name,
+                detail=f"convert node error - {e}"
+            ))
+            logger.debug(f"MemoryBear convert node error - {e}", exc_info=True)
+            return None
+
+    def _convert_edge(self, edge: dict[str, Any], valid_node_ids: set) -> EdgeDefinition | None:
+        try:
+            if edge.get("source") not in valid_node_ids or edge.get("target") not in valid_node_ids:
+                self.warnings.append(ExceptionDefineition(
+                    type=ExceptionType.EDGE,
+                    detail=f"edge {edge.get('id')} skipped: source or target node not found"
+                ))
+                return None
+            return EdgeDefinition(**edge)
+        except Exception as e:
+            self.errors.append(ExceptionDefineition(
+                type=ExceptionType.EDGE,
+                detail=f"convert edge error - {e}"
+            ))
+            logger.debug(f"MemoryBear convert edge error - {e}", exc_info=True)
+            return None
+
+    def _convert_variable(self, variable: dict[str, Any]) -> VariableDefinition | None:
+        try:
+            return VariableDefinition(**variable)
+        except Exception as e:
+            self.warnings.append(ExceptionDefineition(
+                type=ExceptionType.VARIABLE,
+                name=variable.get("name"),
+                detail=f"convert variable error - {e}"
+            ))
+            logger.debug(f"MemoryBear convert variable error - {e}", exc_info=True)
+            return None
+
+    def parse_workflow(self) -> WorkflowParserResult:
+        for node in self.origin_nodes:
+            converted = self._convert_node(node)
+            if converted:
+                self.nodes.append(converted)
+
+        valid_node_ids = {n.id for n in self.nodes}
+
+        for edge in self.origin_edges:
+            converted = self._convert_edge(edge, valid_node_ids)
+            if converted:
+                self.edges.append(converted)
+
+        for variable in self.origin_variables:
+            converted = self._convert_variable(variable)
+            if converted:
+                self.conv_variables.append(converted)
+
+        return WorkflowParserResult(
+            success=not self.errors and not self.warnings,
+            platform=self.get_metadata(),
+            execution_config=ExecutionConfig(),
+            origin_config=self.config,
+            trigger=None,
+            edges=self.edges,
+            nodes=self.nodes,
+            variables=self.conv_variables,
+            warnings=self.warnings,
+            errors=self.errors,
+        )

api/app/core/workflow/adapters/memory_bear/memory_bear_converter.py

@@ -0,0 +1,85 @@
+# -*- coding: UTF-8 -*-
+from app.core.workflow.adapters.base_converter import BaseConverter
+from app.core.workflow.adapters.errors import ExceptionDefineition, ExceptionType
+from app.core.workflow.nodes.base_config import BaseNodeConfig
+from app.core.workflow.nodes.configs import (
+    StartNodeConfig,
+    EndNodeConfig,
+    LLMNodeConfig,
+    AgentNodeConfig,
+    IfElseNodeConfig,
+    KnowledgeRetrievalNodeConfig,
+    AssignerNodeConfig,
+    CodeNodeConfig,
+    HttpRequestNodeConfig,
+    JinjaRenderNodeConfig,
+    VariableAggregatorNodeConfig,
+    ParameterExtractorNodeConfig,
+    LoopNodeConfig,
+    IterationNodeConfig,
+    QuestionClassifierNodeConfig,
+    ToolNodeConfig,
+    MemoryReadNodeConfig,
+    MemoryWriteNodeConfig,
+    NoteNodeConfig,
+)
+from app.core.workflow.nodes.enums import NodeType
+
+
+class MemoryBearConverter(BaseConverter):
+    errors: list
+    warnings: list
+
+    CONFIG_CLASS_MAP: dict[NodeType, type[BaseNodeConfig]] = {
+        NodeType.START: StartNodeConfig,
+        NodeType.END: EndNodeConfig,
+        NodeType.ANSWER: EndNodeConfig,
+        NodeType.LLM: LLMNodeConfig,
+        NodeType.AGENT: AgentNodeConfig,
+        NodeType.IF_ELSE: IfElseNodeConfig,
+        NodeType.KNOWLEDGE_RETRIEVAL: KnowledgeRetrievalNodeConfig,
+        NodeType.ASSIGNER: AssignerNodeConfig,
+        NodeType.CODE: CodeNodeConfig,
+        NodeType.HTTP_REQUEST: HttpRequestNodeConfig,
+        NodeType.JINJARENDER: JinjaRenderNodeConfig,
+        NodeType.VAR_AGGREGATOR: VariableAggregatorNodeConfig,
+        NodeType.PARAMETER_EXTRACTOR: ParameterExtractorNodeConfig,
+        NodeType.LOOP: LoopNodeConfig,
+        NodeType.ITERATION: IterationNodeConfig,
+        NodeType.QUESTION_CLASSIFIER: QuestionClassifierNodeConfig,
+        NodeType.TOOL: ToolNodeConfig,
+        NodeType.MEMORY_READ: MemoryReadNodeConfig,
+        NodeType.MEMORY_WRITE: MemoryWriteNodeConfig,
+        NodeType.NOTES: NoteNodeConfig,
+    }
+
+    @staticmethod
+    def _convert_file(var):
+        return None
+
+    @staticmethod
+    def _convert_array_file(var):
+        return []
+
+    def config_validate(self, node_id: str, node_name: str, config_cls: type[BaseNodeConfig], value: dict):
+        try:
+            return config_cls.model_validate(value)
+        except Exception as e:
+            self.errors.append(ExceptionDefineition(
+                type=ExceptionType.CONFIG,
+                node_id=node_id,
+                node_name=node_name,
+                detail=str(e)
+            ))
+            return None
+
+    def get_node_convert(self, node_type: NodeType):
+        config_cls = self.CONFIG_CLASS_MAP.get(node_type)
+        if not config_cls:
+            return lambda node_id, node_name, config: config
+
+        def validate(node_id: str, node_name: str, config: dict):
+            self.config_validate(node_id, node_name, config_cls, config)
+            return config
+
+        return validate

api/app/core/workflow/adapters/registry.py

@@ -0,0 +1,34 @@
+# -*- coding: UTF-8 -*-
+# Author: Eternity
+# @Email: 1533512157@qq.com
+# @Time : 2026/2/25 14:19
+from typing import Any
+
+from app.core.workflow.adapters import DifyAdapter, MemoryBearAdapter
+from app.core.workflow.adapters.base_adapter import BasePlatformAdapter, PlatformType
+
+
+class PlatformAdapterRegistry:
+    _adapters: dict[str, type[BasePlatformAdapter]] = {}
+
+    @classmethod
+    def register(cls, platform: str, adapter: type[BasePlatformAdapter]):
+        cls._adapters[platform] = adapter
+
+    @classmethod
+    def get_adapter(cls, platform: str, config: dict[str, Any]) -> BasePlatformAdapter:
+        if platform not in cls._adapters:
+            raise ValueError(f"Unsupported platform: {platform}")
+        return cls._adapters.get(platform)(config)
+
+    @classmethod
+    def list_platforms(cls) -> list[str]:
+        return list(cls._adapters.keys())
+
+    @classmethod
+    def is_supported(cls, platform: str) -> bool:
+        return platform in cls._adapters
+
+
+PlatformAdapterRegistry.register(PlatformType.MEMORY_BEAR, MemoryBearAdapter)
+PlatformAdapterRegistry.register(PlatformType.DIFY, DifyAdapter)

api/app/core/workflow/engine/event_stream_handler.py

@@ -127,7 +127,7 @@ class EventStreamHandler:
                     yield {
                         "event": "message",
                         "data": {
-                            "chunk": data.get("chunk")
+                            "content": data.get("chunk")
                         }
                     }
 

api/app/core/workflow/engine/graph_builder.py

@@ -292,6 +292,8 @@ class GraphBuilder:
         """
         for node in self.nodes:
             node_type = node.get("type")
+            if node_type == NodeType.NOTES:
+                continue
             node_id = node.get("id")
             cycle_node = node.get("cycle")
             if cycle_node:
@@ -320,7 +322,7 @@ class GraphBuilder:
                     # Used later to determine which branch to take based on the node's output
                     # Assumes node output `node.<node_id>.output` matches the edge's label
                     # For example, if node.123.output == 'CASE1', take the branch labeled 'CASE1'
-                    related_edge[idx]['condition'] = f"node.{node_id}.output == '{related_edge[idx]['label']}'"
+                    related_edge[idx]['condition'] = f"node['{node_id}']['output'] == '{related_edge[idx]['label']}'"
 
             if node_instance:
                 # Wrap node's run method to avoid closure issues

api/app/core/workflow/engine/stream_output_coordinator.py

@@ -13,7 +13,7 @@ from app.core.workflow.engine.variable_pool import VariablePool
 logger = get_logger(__name__)
 
 SCOPE_PATTERN = re.compile(
-    r"\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\.[a-zA-Z0-9_]+\s*}}"
+    r"\{\{\s*([a-zA-Z0-9_]+)\.[a-zA-Z0-9_]+\s*}}"
 )
 
 
@@ -274,7 +274,7 @@ class StreamOutputCoordinator:
                 yield {
                     "event": "message",
                     "data": {
-                        "chunk": final_chunk
+                        "content": final_chunk
                     }
                 }
 

api/app/core/workflow/engine/variable_pool.py

@@ -73,7 +73,7 @@ class VariableStruct(BaseModel, Generic[T]):
         instance:
             The concrete variable object. The actual Python type is
             represented by the generic parameter ``T`` (e.g. StringVariable,
-            NumberVariable, ArrayObject[StringVariable]).
+            NumberVariable, ArrayVariable[StringVariable]).
         mut:
             Whether the variable is mutable.
     """
@@ -152,6 +152,36 @@ class VariablePool:
             return None
         return var_instance
 
+    def get_instance(
+            self,
+            selector: str,
+            default: Any = None,
+            strict: bool = True
+    ):
+        """Retrieve a variable instance from the variable pool.
+
+        Args:
+            selector:
+                Variable selector as a string variable literal (e.g. "{{ sys.message }}").
+            default:
+                The value to return if the variable does not exist.
+            strict:
+                If True, raises KeyError when the variable does not exist.
+
+        Returns:
+            The variable instance object if it exists; otherwise returns `default`.
+
+        Raises:
+            KeyError: If strict is True and the variable does not exist.
+        """
+        variable_struct = self._get_variable_struct(selector)
+        if variable_struct is None:
+            if strict:
+                raise KeyError(f"{selector} not exist")
+            return default
+
+        return variable_struct.instance
+
     def get_value(
             self,
             selector: str,
@@ -273,38 +303,52 @@ class VariablePool:
         """
         return self._get_variable_struct(selector) is not None
 
-    def get_all_system_vars(self) -> dict[str, Any]:
+    def get_all_system_vars(self, literal=False) -> dict[str, Any]:
         """获取所有系统变量
         
         Returns:
             系统变量字典
         """
         sys_namespace = self.variables.get("sys", {})
+        if literal:
+            return {k: v.instance.to_literal() for k, v in sys_namespace.items()}
         return {k: v.instance.get_value() for k, v in sys_namespace.items()}
 
-    def get_all_conversation_vars(self) -> dict[str, Any]:
+    def get_all_conversation_vars(self, literal=False) -> dict[str, Any]:
         """获取所有会话变量
         
         Returns:
             会话变量字典
         """
         conv_namespace = self.variables.get("conv", {})
+        if literal:
+            return {k: v.instance.to_literal() for k, v in conv_namespace.items()}
         return {k: v.instance.get_value() for k, v in conv_namespace.items()}
 
-    def get_all_node_outputs(self) -> dict[str, Any]:
+    def get_all_node_outputs(self, literal=False) -> dict[str, Any]:
         """获取所有节点输出（运行时变量）
         
         Returns:
             节点输出字典，键为节点 ID
         """
-        runtime_vars = {
-            namespace: {
-                k: v.instance.get_value()
-                for k, v in vars_dict.items()
+        if literal:
+            runtime_vars = {
+                namespace: {
+                    k: v.instance.to_literal()
+                    for k, v in vars_dict.items()
+                }
+                for namespace, vars_dict in self.variables.items()
+                if namespace not in ("sys", "conv")
+            }
+        else:
+            runtime_vars = {
+                namespace: {
+                    k: v.instance.get_value()
+                    for k, v in vars_dict.items()
+                }
+                for namespace, vars_dict in self.variables.items()
+                if namespace not in ("sys", "conv")
             }
-            for namespace, vars_dict in self.variables.items()
-            if namespace not in ("sys", "conv")
-        }
         return runtime_vars
 
     def get_node_output(self, node_id: str, defalut: Any = None, strict: bool = True) -> dict[str, Any] | None: