Merge branch 'develop' of github.com:SuanmoSuanyangTechnology/MemoryBear into develop

api/app/controllers/app_controller.py

@@ -802,7 +802,8 @@ async def draft_run_compare(
                     web_search=True,
                     memory=True,
                     parallel=payload.parallel,
-                    timeout=payload.timeout or 60
+                    timeout=payload.timeout or 60,
+                    files=payload.files
             ):
                 yield event
 

api/app/controllers/memory_reflection_controller.py

@@ -104,14 +104,18 @@ async def start_workspace_reflection(
 ) -> dict:
     """启动工作空间中所有匹配应用的反思功能"""
     workspace_id = current_user.current_workspace_id
-    reflection_service = MemoryReflectionService(db)
 
     try:
         api_logger.info(f"用户 {current_user.username} 启动workspace反思，workspace_id: {workspace_id}")
 
-        service = WorkspaceAppService(db)
+        # 使用独立的数据库会话来获取工作空间应用详情，避免事务失败
+        from app.db import get_db_context
+        with get_db_context() as query_db:
+            service = WorkspaceAppService(query_db)
             result = service.get_workspace_apps_detailed(workspace_id)
+        
         reflection_results = []
+        
         for data in result['apps_detailed_info']:
             # 跳过没有配置的应用
             if not data['memory_configs']:
@@ -133,11 +137,14 @@ async def start_workspace_reflection(
                     api_logger.debug(f"配置 {config_id_str} 没有匹配的release")
                     continue
 
-                # 为每个用户执行反思
+                # 为每个用户执行反思 - 使用独立的数据库会话
                 for user in end_users:
                     api_logger.info(f"为用户 {user['id']} 启动反思，config_id: {config_id_str}")
 
+                    # 为每个用户创建独立的数据库会话，避免事务失败影响其他用户
+                    with get_db_context() as user_db:
                         try:
+                            reflection_service = MemoryReflectionService(user_db)
                             reflection_result = await reflection_service.start_text_reflection(
                                 config_data=config,
                                 end_user_id=user['id']

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

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

api/app/schemas/app_schema.py

@@ -488,7 +488,7 @@ class DraftRunCompareRequest(BaseModel):
         max_length=5,
         description="要对比的模型列表（1-5个）"
     )
-
+    files: Optional[List[FileInput]] = Field(default=None, description="附件列表（支持多文件）")
     parallel: bool = Field(True, description="是否并行执行")
     stream: bool = Field(False, description="是否流式返回")
     timeout: Optional[int] = Field(60, ge=10, le=300, description="超时时间（秒）")

api/app/services/draft_run_service.py

@@ -16,26 +16,26 @@ from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from app.celery_app import celery_app
+from app.core.agent.agent_middleware import AgentMiddleware
 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.rag.nlp.search import knowledge_retrieval
-from app.models import AgentConfig, ModelApiKey, ModelConfig
+from app.models import AgentConfig, ModelConfig
-from app.repositories.model_repository import ModelApiKeyRepository
 from app.repositories.tool_repository import ToolRepository
-from app.schemas.prompt_schema import PromptMessageRole, render_prompt_message
 from app.schemas.app_schema import FileInput
+from app.schemas.prompt_schema import PromptMessageRole, render_prompt_message
 from app.services import task_service
 from app.services.langchain_tool_server import Search
 from app.services.memory_agent_service import MemoryAgentService
 from app.services.model_parameter_merger import ModelParameterMerger
 from app.services.model_service import ModelApiKeyService
-from app.services.tool_service import ToolService
 from app.services.multimodal_service import MultimodalService
-from app.core.agent.agent_middleware import AgentMiddleware
+from app.services.tool_service import ToolService
-
 
 logger = get_business_logger()
+
+
 class KnowledgeRetrievalInput(BaseModel):
     """知识库检索工具输入参数"""
     query: str = Field(description="需要检索的问题或关键词")
@@ -48,9 +48,12 @@ class WebSearchInput(BaseModel):
 
 class LongTermMemoryInput(BaseModel):
     """长期记忆工具输入参数"""
-    question: str = Field(description="经过优化重写的查询问题。请将用户的原始问题重写为更合适的检索形式，包含关键词，上下文和具体描述，注意错词检查并且改写")
+    question: str = Field(
+        description="经过优化重写的查询问题。请将用户的原始问题重写为更合适的检索形式，包含关键词，上下文和具体描述，注意错词检查并且改写")
 
-def create_long_term_memory_tool(memory_config: Dict[str, Any], end_user_id: str, storage_type: Optional[str] = None,user_rag_memory_id: Optional[str] = None):
+
+def create_long_term_memory_tool(memory_config: Dict[str, Any], end_user_id: str, storage_type: Optional[str] = None,
+                                 user_rag_memory_id: Optional[str] = None):
     """创建记忆工具,
 
 
@@ -66,6 +69,7 @@ def create_long_term_memory_tool(memory_config: Dict[str, Any], end_user_id: str
     # 兼容新旧字段名：优先使用 memory_config_id，回退到 memory_content
     config_id = memory_config.get("memory_config_id") or memory_config.get("memory_content", None)
     logger.info(f"创建长期记忆工具，配置: end_user_id={end_user_id}, config_id={config_id}, storage_type={storage_type}")
+
     @tool(args_schema=LongTermMemoryInput)
     def long_term_memory(question: str) -> str:
         """
@@ -133,6 +137,7 @@ def create_long_term_memory_tool(memory_config: Dict[str, Any], end_user_id: str
         except Exception as e:
             logger.error("长期记忆检索失败", extra={"error": str(e), "error_type": type(e).__name__})
             return f"记忆检索失败: {str(e)}"
+
     return long_term_memory
 
 
@@ -189,6 +194,7 @@ def create_knowledge_retrieval_tool(kb_config,kb_ids,user_id):
         检索到的相关知识内容
     """
     logger.info(f"创建知识库检索工具，用户：{user_id}")
+
     @tool(args_schema=KnowledgeRetrievalInput)
     def knowledge_retrieval_tool(query: str) -> str:
         """从知识库中检索相关信息。当用户的问题需要参考知识库、文档或历史记录时，使用此工具进行检索。
@@ -200,7 +206,6 @@ def create_knowledge_retrieval_tool(kb_config,kb_ids,user_id):
             检索到的相关知识内容
         """
 
-
         try:
 
             retrieve_chunks_result = knowledge_retrieval(query, kb_config)
@@ -226,6 +231,7 @@ def create_knowledge_retrieval_tool(kb_config,kb_ids,user_id):
 
     return knowledge_retrieval_tool
 
+
 class DraftRunService:
     """试运行服务类"""
 
@@ -296,7 +302,6 @@ class DraftRunService:
                 agent_config=agent_config
             )
 
-
             items_params = variables
             system_prompt = render_prompt_message(
                 agent_config.system_prompt,  # 修正拼写错误
@@ -358,7 +363,8 @@ class DraftRunService:
 
                     # 应用动态过滤
                     if skill_configs:
-                        tools, activated_skill_ids = middleware.filter_tools(tools, message, skill_configs, tool_to_skill_map)
+                        tools, activated_skill_ids = middleware.filter_tools(tools, message, skill_configs,
+                                                                             tool_to_skill_map)
                         logger.debug(f"过滤后剩余 {len(tools)} 个工具")
                         active_prompts = AgentMiddleware.get_active_prompts(
                             activated_skill_ids, skill_configs
@@ -391,7 +397,8 @@ class DraftRunService:
                     memory_config = agent_config.memory
                     if user_id:
                         # 创建长期记忆工具
-                        memory_tool = create_long_term_memory_tool(memory_config, user_id,storage_type,user_rag_memory_id)
+                        memory_tool = create_long_term_memory_tool(memory_config, user_id, storage_type,
+                                                                   user_rag_memory_id)
                         tools.append(memory_tool)
 
                         logger.debug(
@@ -626,14 +633,14 @@ class DraftRunService:
 
                     # 应用动态过滤
                     if skill_configs:
-                        tools, activated_skill_ids = middleware.filter_tools(tools, message, skill_configs, tool_to_skill_map)
+                        tools, activated_skill_ids = middleware.filter_tools(tools, message, skill_configs,
+                                                                             tool_to_skill_map)
                         logger.debug(f"过滤后剩余 {len(tools)} 个工具")
                         active_prompts = AgentMiddleware.get_active_prompts(
                             activated_skill_ids, skill_configs
                         )
                         system_prompt = f"{system_prompt}\n\n{active_prompts}"
 
-
             # 添加知识库检索工具
             if agent_config.knowledge_retrieval:
                 kb_config = agent_config.knowledge_retrieval
@@ -658,7 +665,8 @@ class DraftRunService:
                     memory_config = agent_config.memory
                     if user_id:
                         # 创建长期记忆工具
-                        memory_tool = create_long_term_memory_tool(memory_config, user_id,storage_type,user_rag_memory_id)
+                        memory_tool = create_long_term_memory_tool(memory_config, user_id, storage_type,
+                                                                   user_rag_memory_id)
                         tools.append(memory_tool)
 
                         logger.debug(
@@ -863,7 +871,6 @@ class DraftRunService:
             BusinessException: 当指定的会话不存在时
         """
         from app.models import Conversation as ConversationModel
-        from app.schemas.conversation_schema import ConversationCreate
         from app.services.conversation_service import ConversationService
 
         conversation_service = ConversationService(self.db)
@@ -1157,6 +1164,7 @@ class DraftRunService:
             user_rag_memory_id: Optional[str] = None,
             web_search: bool = True,
             memory: bool = True,
+            files: list[FileInput] | None = None
     ) -> Dict[str, Any]:
         """多模型对比试运行
 
@@ -1206,7 +1214,8 @@ class DraftRunService:
                             storage_type=storage_type,
                             user_rag_memory_id=user_rag_memory_id,
                             web_search=web_search,
-                            memory=memory
+                            memory=memory,
+                            files=files
                         ),
                         timeout=timeout
                     )
@@ -1363,7 +1372,8 @@ class DraftRunService:
             web_search: bool = True,
             memory: bool = True,
             parallel: bool = True,
-        timeout: int = 60
+            timeout: int = 60,
+            files: list[FileInput] | None = None
     ) -> AsyncGenerator[str, None]:
         """多模型对比试运行（流式返回）
 
@@ -1383,6 +1393,7 @@ class DraftRunService:
             memory: 是否启用记忆
             parallel: 是否并行执行
             timeout: 超时时间（秒）
+            files: 多模态文件
 
         Yields:
             str: SSE 格式的事件数据
@@ -1441,7 +1452,8 @@ class DraftRunService:
                             storage_type=storage_type,
                             user_rag_memory_id=user_rag_memory_id,
                             web_search=web_search,
-                        memory=memory
+                            memory=memory,
+                            files=files
                     ):
                         # 解析原始事件
                         try:
@@ -1696,4 +1708,3 @@ async def draft_run(
         similarity_threshold=similarity_threshold,
         top_k=top_k
     )
-

api/app/services/memory_agent_service.py

@@ -313,8 +313,11 @@ class MemoryAgentService:
         start_time = time.time()
 
         # Load configuration from database with workspace fallback
+        # Use a separate database session to avoid transaction failures
         try:
-            config_service = MemoryConfigService(db)
+            from app.db import get_db_context
+            with get_db_context() as config_db:
+                config_service = MemoryConfigService(config_db)
                 memory_config = config_service.load_memory_config(
                     config_id=config_id,
                     workspace_id=workspace_id,
@@ -454,7 +457,10 @@ class MemoryAgentService:
 
         config_load_start = time.time()
         try:
-            config_service = MemoryConfigService(db)
+            # Use a separate database session to avoid transaction failures
+            from app.db import get_db_context
+            with get_db_context() as config_db:
+                config_service = MemoryConfigService(config_db)
                 memory_config = config_service.load_memory_config(
                     config_id=config_id,
                     workspace_id=workspace_id,

api/app/services/memory_reflection_service.py

@@ -364,6 +364,7 @@ class MemoryReflectionService:
         reflexion_range_value = config_data.get("reflexion_range")
         if reflexion_range_value is None or reflexion_range_value == "":
             reflexion_range_value = "partial"
+        
         # Map legacy/invalid values to valid enum values
         reflexion_range_mapping = {
             "retrieval": "partial",  # Map old 'retrieval' to 'partial'
@@ -378,13 +379,19 @@ class MemoryReflectionService:
             baseline_value = "TIME"
         baseline = ReflectionBaseline(baseline_value)
 
-        # iteration_period =
+        # iteration_period
         iteration_period = config_data.get("iteration_period", 24)
         if isinstance(iteration_period, str):
             try:
                 iteration_period = int(iteration_period)
             except (ValueError, TypeError):
                 iteration_period = 24  # 默认24小时
+        
+        # 获取 model_id 并转换为字符串（如果是 UUID 对象）
+        reflection_model_id = config_data.get("reflection_model_id", "")
+        if reflection_model_id:
+            reflection_model_id = str(reflection_model_id)
+        
         return ReflectionConfig(
             enabled=config_data.get("enable_self_reflexion", False),
             iteration_period=str(iteration_period),  # ReflectionConfig期望字符串
@@ -392,7 +399,7 @@ class MemoryReflectionService:
             baseline=baseline,
             memory_verify=config_data.get("memory_verify", False),
             quality_assessment=config_data.get("quality_assessment", False),
-            model_id=config_data.get("reflection_model_id", "")
+            model_id=reflection_model_id
         )
     
     async def _execute_reflection_engine(

web/src/views/KnowledgeBase/components/CreateModal.tsx

@@ -211,7 +211,8 @@ const CreateModal = forwardRef<CreateModalRef, CreateModalRefProps>(({
 
     // Process parser_config data, set default values if not present
     const recordAny = record as any;
-    baseValues.parser_config = record.parser_config || {
+    baseValues.parser_config = {
+      ...record.parser_config,
       graphrag: {
         use_graphrag: false,
         scene_name: '',
@@ -219,6 +220,7 @@ const CreateModal = forwardRef<CreateModalRef, CreateModalRefProps>(({
         method: 'general',
         resolution: false,
         community: false,
+        ...(record.parser_config?.graphrag || {})
       }
     };
 
@@ -656,7 +658,7 @@ const CreateModal = forwardRef<CreateModalRef, CreateModalRefProps>(({
       {currentType !== 'Folder' && dynamicTypeList.map((tp) => {
         const fieldKey = typeToFieldKey(tp);
         // When tp is 'llm', merge llm and chat options
-        const options = tp.toLowerCase() === 'llm' 
+        const options = tp.toLowerCase() === 'llm' || tp.toLowerCase() === 'image2text'
           ? [...(modelOptionsByType['llm'] || []), ...(modelOptionsByType['chat'] || [])]
           : modelOptionsByType[tp] || [];
         return (