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

# Conflicts: # api/pyproject.toml
2026-01-22 10:22:40 +08:00
parent 64e4411048 fb25495f1b
commit fafab973ee
44 changed files with 1524 additions and 884 deletions
--- a/api/app/controllers/memory_agent_controller.py
+++ b/api/app/controllers/memory_agent_controller.py
@@ -9,7 +9,9 @@ from app.db import get_db
 from app.dependencies import cur_workspace_access_guard, get_current_user
 from app.models import ModelApiKey
 from app.models.user_model import User
-from app.repositories import knowledge_repository
+from app.core.memory.agent.utils.session_tools import SessionService
+from app.core.memory.agent.utils.redis_tool import store
+from app.repositories import knowledge_repository, WorkspaceRepository
 from app.schemas.memory_agent_schema import UserInput, Write_UserInput
 from app.schemas.response_schema import ApiResponse
 from app.services import task_service, workspace_service
@@ -160,9 +162,12 @@ async def write_server(
    
    api_logger.info(f"Write service requested for group {user_input.group_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(
            user_input.group_id, 
-            user_input.message, 
+            messages_list,  # 传递结构化消息列表
            config_id,
            db,
            storage_type, 
@@ -219,9 +224,12 @@ async def write_server_async(
        if knowledge: user_rag_memory_id = str(knowledge.id)
    api_logger.info(f"Async write: storage_type={storage_type}, user_rag_memory_id={user_rag_memory_id}")
    try:
+        # 获取标准化的消息列表
+        messages_list = memory_agent_service.get_messages_list(user_input)
+        
        task = celery_app.send_task(
            "app.core.memory.agent.write_message",
-            args=[user_input.group_id, user_input.message, config_id, storage_type, user_rag_memory_id]
+            args=[user_input.group_id, messages_list, config_id, storage_type, user_rag_memory_id]
        )
        api_logger.info(f"Write task queued: {task.id}")
        
@@ -285,6 +293,19 @@ async def read_server(
            storage_type,
            user_rag_memory_id
        )
+        if str(user_input.search_switch) == "2":
+            retrieve_info = result['answer']
+            history = await SessionService(store).get_history(user_input.group_id, user_input.group_id, user_input.group_id)
+            query = user_input.message
+            
+            # 调用 memory_agent_service 的方法生成最终答案
+            result['answer'] = await memory_agent_service.generate_summary_from_retrieve(
+                retrieve_info=retrieve_info,
+                history=history,
+                query=query,
+                config_id=config_id,
+                db=db
+            )
        return success(data=result, msg="回复对话消息成功")
    except BaseException as e:
        # Handle ExceptionGroup from TaskGroup (Python 3.11+) or BaseExceptionGroup
@@ -564,8 +585,23 @@ async def status_type(
    """
    api_logger.info(f"Status type check requested for group {user_input.group_id}")
    try:
+        # 获取标准化的消息列表
+        messages_list = memory_agent_service.get_messages_list(user_input)
+        
+        # 将消息列表转换为字符串用于分类
+        # 只取最后一条用户消息进行分类
+        last_user_message = ""
+        for msg in reversed(messages_list):
+            if msg.get('role') == 'user':
+                last_user_message = msg.get('content', '')
+                break
+        
+        if not last_user_message:
+            # 如果没有用户消息，使用所有消息的内容
+            last_user_message = " ".join([msg.get('content', '') for msg in messages_list])
+        
        result = await memory_agent_service.classify_message_type(
-            user_input.message,
+            last_user_message,
            user_input.config_id,
            db
        )
@@ -616,8 +652,10 @@ async def get_knowledge_type_stats_api(
@router.get("/analytics/hot_memory_tags/by_user", response_model=ApiResponse)
 async def get_hot_memory_tags_by_user_api(
    end_user_id: Optional[str] = Query(None, description="用户ID（可选）"),
+    language_type: Optional[str] ="zh",
    limit: int = Query(20, description="返回标签数量限制"),
-    current_user: User = Depends(get_current_user)
+    current_user: User = Depends(get_current_user),
+    db: Session=Depends(get_db),
 ):
    """
    获取指定用户的热门记忆标签
@@ -628,10 +666,22 @@ async def get_hot_memory_tags_by_user_api(
        ...
    ]
    """
+
+    workspace_id=current_user.current_workspace_id
+    workspace_repo = WorkspaceRepository(db)
+    workspace_models = workspace_repo.get_workspace_models_configs(workspace_id)
+
+    if workspace_models:
+        model_id = workspace_models.get("llm", None)
+    else:
+        model_id = None
+
    api_logger.info(f"Hot memory tags by user requested: end_user_id={end_user_id}")
    try:
        result = await memory_agent_service.get_hot_memory_tags_by_user(
            end_user_id=end_user_id,
+            language_type=language_type,
+            model_id=model_id,
            limit=limit
        )
        return success(data=result, msg="获取热门记忆标签成功")
@@ -647,7 +697,7 @@ async def get_user_profile_api(
    current_user: User = Depends(get_current_user)
 ):
    """
-    获取用户详情，包含：
+    获取工作空间下Popular Memory Tags，包含：
    - name: 用户名字（直接使用 end_user_id）
    - tags: 3个用户特征标签（从语句和实体中LLM总结）
    - hot_tags: 4个热门记忆标签
--- a/api/app/controllers/memory_dashboard_controller.py
+++ b/api/app/controllers/memory_dashboard_controller.py
@@ -5,7 +5,6 @@ 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.schemas.memory_agent_schema import End_User_Information
 from app.schemas.response_schema import ApiResponse

 from app.services import memory_dashboard_service, memory_storage_service, workspace_service
@@ -40,54 +39,7 @@ def get_workspace_total_end_users(
    api_logger.info(f"成功获取最新用户总数: total_num={total_end_users.get('total_num', 0)}")
    return success(data=total_end_users, msg="用户数量获取成功")

-@router.post("/update/end_users", response_model=ApiResponse)
-async def update_workspace_end_users(
-    user_input: End_User_Information,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-):
-    """
-    更新工作空间的宿主信息
-    """
-    username = user_input.end_user_name  # 要更新的用户名
-    end_user_input_id = user_input.id  # 宿主ID
-    workspace_id = current_user.current_workspace_id
-    
-    api_logger.info(f"用户 {current_user.username} 请求更新工作空间 {workspace_id} 的宿主信息")
-    api_logger.info(f"更新参数: username={username}, end_user_id={end_user_input_id}")

-    try:
-        # 导入更新函数
-        from app.repositories.end_user_repository import update_end_user_other_name
-        import uuid
-        
-        # 转换 end_user_id 为 UUID 类型
-        end_user_uuid = uuid.UUID(end_user_input_id)
-        
-        # 直接更新数据库中的 other_name 字段
-        updated_count = update_end_user_other_name(
-            db=db,
-            end_user_id=end_user_uuid,
-            other_name=username
-        )
-        
-        api_logger.info(f"成功更新宿主 {end_user_input_id} 的 other_name 为: {username}")
-
-        return success(
-            data={
-                "updated_count": updated_count,
-                "end_user_id": end_user_input_id,
-                "updated_other_name": username
-            },
-            msg=f"成功更新 {updated_count} 个宿主的信息"
-        )
-        
-    except Exception as e:
-        api_logger.error(f"更新宿主信息失败: {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"更新宿主信息失败: {str(e)}"
-        )



--- a/api/app/controllers/memory_short_term_controller.py
+++ b/api/app/controllers/memory_short_term_controller.py
@@ -20,6 +20,7 @@ router = APIRouter(
@router.get("/short_term")
 async def short_term_configs(
        end_user_id: str,
+        language_type:Optional[str] = "zh",
        current_user: User = Depends(get_current_user),
        db: Session = Depends(get_db),
 ):
--- a/api/app/controllers/memory_storage_controller.py
+++ b/api/app/controllers/memory_storage_controller.py
@@ -28,7 +28,6 @@ from app.services.memory_storage_service import (
    search_dialogue,
    search_edges,
    search_entity,
-    search_entity_graph,
    search_statement,
 )
 from fastapi import APIRouter, Depends
@@ -412,21 +411,7 @@ async def search_entity_edges(
        api_logger.error(f"Search edges failed: {str(e)}")
        return fail(BizCode.INTERNAL_ERROR, "边查询失败", str(e))

-@router.get("/search/entity_graph", response_model=ApiResponse)
-async def search_for_entity_graph(
-    end_user_id: Optional[str] = None,
-    current_user: User = Depends(get_current_user),
-    ) -> dict:
-    """
-    搜索所有实体之间的关系网络
-    """
-    api_logger.info(f"Search entity graph requested for end_user_id: {end_user_id}")
-    try:
-        result = await search_entity_graph(end_user_id)
-        return success(data=result, msg="查询成功")
-    except Exception as e:
-        api_logger.error(f"Search entity graph failed: {str(e)}")
-        return fail(BizCode.INTERNAL_ERROR, "实体图查询失败", str(e))
+


@router.get("/analytics/hot_memory_tags", response_model=ApiResponse)
--- a/api/app/controllers/user_memory_controllers.py
+++ b/api/app/controllers/user_memory_controllers.py
@@ -12,6 +12,7 @@ from app.core.logging_config import get_api_logger
 from app.core.response_utils import success, fail
 from app.core.error_codes import BizCode
 from app.core.api_key_utils import timestamp_to_datetime
+from app.services.memory_base_service import Translation_English
 from app.services.user_memory_service import (
    UserMemoryService,
    analytics_memory_types,
@@ -20,7 +21,7 @@ from app.services.user_memory_service import (
 from app.services.memory_entity_relationship_service import MemoryEntityService,MemoryEmotion,MemoryInteraction
 from app.schemas.response_schema import ApiResponse
 from app.schemas.memory_storage_schema import GenerateCacheRequest
-
+from app.repositories.workspace_repository import WorkspaceRepository
 from app.schemas.end_user_schema import (
    EndUserProfileResponse,
    EndUserProfileUpdate,
@@ -44,6 +45,7 @@ router = APIRouter(
@router.get("/analytics/memory_insight/report", response_model=ApiResponse)
 async def get_memory_insight_report_api(
    end_user_id: str,
+    language_type: str = "zh",
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
 ) -> dict:
@@ -53,10 +55,18 @@ async def get_memory_insight_report_api(
    此接口仅查询数据库中已缓存的记忆洞察数据，不执行生成操作。
    如需生成新的洞察报告，请使用专门的生成接口。
    """
+    workspace_id = current_user.current_workspace_id
+    workspace_repo = WorkspaceRepository(db)
+    workspace_models = workspace_repo.get_workspace_models_configs(workspace_id)
+
+    if workspace_models:
+        model_id = workspace_models.get("llm", None)
+    else:
+        model_id = None
    api_logger.info(f"记忆洞察报告查询请求: end_user_id={end_user_id}, user={current_user.username}")
    try:
        # 调用服务层获取缓存数据
-        result = await user_memory_service.get_cached_memory_insight(db, end_user_id)
+        result = await user_memory_service.get_cached_memory_insight(db, end_user_id,model_id,language_type)

        if result["is_cached"]:
            api_logger.info(f"成功返回缓存的记忆洞察报告: end_user_id={end_user_id}")
@@ -72,6 +82,7 @@ async def get_memory_insight_report_api(
@router.get("/analytics/user_summary", response_model=ApiResponse)
 async def get_user_summary_api(
    end_user_id: str,
+    language_type: str="zh",
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
 ) -> dict:
@@ -81,10 +92,18 @@ async def get_user_summary_api(
    此接口仅查询数据库中已缓存的用户摘要数据，不执行生成操作。
    如需生成新的用户摘要，请使用专门的生成接口。
    """
+    workspace_id = current_user.current_workspace_id
+    workspace_repo = WorkspaceRepository(db)
+    workspace_models = workspace_repo.get_workspace_models_configs(workspace_id)
+
+    if workspace_models:
+        model_id = workspace_models.get("llm", None)
+    else:
+        model_id = None
    api_logger.info(f"用户摘要查询请求: end_user_id={end_user_id}, user={current_user.username}")
    try:
        # 调用服务层获取缓存数据
-        result = await user_memory_service.get_cached_user_summary(db, end_user_id)
+        result = await user_memory_service.get_cached_user_summary(db, end_user_id,model_id,language_type)

        if result["is_cached"]:
            api_logger.info(f"成功返回缓存的用户摘要: end_user_id={end_user_id}")
@@ -253,7 +272,6 @@ async def get_graph_data_api(
            depth=depth,
            center_node_id=center_node_id
        )
-
        # 检查是否有错误消息
        if "message" in result and result["statistics"]["total_nodes"] == 0:
            api_logger.warning(f"图数据查询返回空结果: {result.get('message')}")
@@ -278,7 +296,13 @@ async def get_end_user_profile(
    db: Session = Depends(get_db),
 ) -> dict:
    workspace_id = current_user.current_workspace_id
+    workspace_repo = WorkspaceRepository(db)
+    workspace_models = workspace_repo.get_workspace_models_configs(workspace_id)

+    if workspace_models:
+        model_id = workspace_models.get("llm", None)
+    else:
+        model_id = None
    # 检查用户是否已选择工作空间
    if workspace_id is None:
        api_logger.warning(f"用户 {current_user.username} 尝试查询用户信息但未选择工作空间")
@@ -296,7 +320,6 @@ async def get_end_user_profile(
        if not end_user:
            api_logger.warning(f"终端用户不存在: end_user_id={end_user_id}")
            return fail(BizCode.INVALID_PARAMETER, "终端用户不存在", f"end_user_id={end_user_id}")
-
        # 构建响应数据
        profile_data = EndUserProfileResponse(
            id=end_user.id,
@@ -328,12 +351,11 @@ async def update_end_user_profile(

    该接口可以更新用户的姓名、职位、部门、联系方式、电话和入职日期等信息。
    所有字段都是可选的，只更新提供的字段。
-
    """
    workspace_id = current_user.current_workspace_id
    end_user_id = profile_update.end_user_id

-    # 检查用户是否已选择工作空间
+    # 验证工作空间
    if workspace_id is None:
        api_logger.warning(f"用户 {current_user.username} 尝试更新用户信息但未选择工作空间")
        return fail(BizCode.INVALID_PARAMETER, "请先切换到一个工作空间", "current_workspace_id is None")
@@ -343,65 +365,41 @@ async def update_end_user_profile(
        f"workspace={workspace_id}"
    )

-    try:
-        # 查询终端用户
-        end_user = db.query(EndUser).filter(EndUser.id == end_user_id).first()
+    # 调用 Service 层处理业务逻辑
+    result = user_memory_service.update_end_user_profile(db, end_user_id, profile_update)

-        if not end_user:
-            api_logger.warning(f"终端用户不存在: end_user_id={end_user_id}")
-            return fail(BizCode.INVALID_PARAMETER, "终端用户不存在", f"end_user_id={end_user_id}")
-
-        # 更新字段（只更新提供的字段，排除 end_user_id）
-        # 允许 None 值来重置字段（如 hire_date）
-        update_data = profile_update.model_dump(exclude_unset=True, exclude={'end_user_id'})
-
-        # 特殊处理 hire_date：如果提供了时间戳，转换为 DateTime
-        if 'hire_date' in update_data:
-            hire_date_timestamp = update_data['hire_date']
-            if hire_date_timestamp is not None:
-                update_data['hire_date'] = timestamp_to_datetime(hire_date_timestamp)
-            # 如果是 None，保持 None（允许清空）
-
-        for field, value in update_data.items():
-            setattr(end_user, field, value)
-
-        # 更新 updated_at 时间戳
-        end_user.updated_at = datetime.datetime.now()
-
-        # 更新 updatetime_profile 为当前时间
-        end_user.updatetime_profile = datetime.datetime.now()
-
-        # 提交更改
-        db.commit()
-        db.refresh(end_user)
-
-        # 构建响应数据
-        profile_data = EndUserProfileResponse(
-            id=end_user.id,
-            other_name=end_user.other_name,
-            position=end_user.position,
-            department=end_user.department,
-            contact=end_user.contact,
-            phone=end_user.phone,
-            hire_date=end_user.hire_date,
-            updatetime_profile=end_user.updatetime_profile
-        )
-
-        api_logger.info(f"成功更新用户信息: end_user_id={end_user_id}, updated_fields={list(update_data.keys())}")
-        return success(data=UserMemoryService.convert_profile_to_dict_with_timestamp(profile_data), msg="更新成功")
-
-    except Exception as e:
-        db.rollback()
-        api_logger.error(f"用户信息更新失败: end_user_id={end_user_id}, error={str(e)}")
-        return fail(BizCode.INTERNAL_ERROR, "用户信息更新失败", str(e))
+    if result["success"]:
+        api_logger.info(f"成功更新用户信息: end_user_id={end_user_id}")
+        return success(data=result["data"], msg="更新成功")
+    else:
+        error_msg = result["error"]
+        api_logger.error(f"用户信息更新失败: end_user_id={end_user_id}, error={error_msg}")
+        
+        # 根据错误类型映射到合适的业务错误码
+        if error_msg == "终端用户不存在":
+            return fail(BizCode.USER_NOT_FOUND, "终端用户不存在", error_msg)
+        elif error_msg == "无效的用户ID格式":
+            return fail(BizCode.INVALID_USER_ID, "无效的用户ID格式", error_msg)
+        else:
+            # 只有未预期的错误才使用 INTERNAL_ERROR
+            return fail(BizCode.INTERNAL_ERROR, "用户信息更新失败", error_msg)

@router.get("/memory_space/timeline_memories", response_model=ApiResponse)
-async def memory_space_timeline_of_shared_memories(id: str, label: str,
+async def memory_space_timeline_of_shared_memories(id: str, label: str,language_type: str="zh",
                                      current_user: User = Depends(get_current_user),
                                      db: Session = Depends(get_db),
                                      ):
+    workspace_id=current_user.current_workspace_id
+    workspace_repo = WorkspaceRepository(db)
+    workspace_models = workspace_repo.get_workspace_models_configs(workspace_id)
+
+    if workspace_models:
+        model_id = workspace_models.get("llm", None)
+    else:
+        model_id = None
    MemoryEntity = MemoryEntityService(id, label)
-    timeline_memories_result = await MemoryEntity.get_timeline_memories_server()
+    timeline_memories_result = await MemoryEntity.get_timeline_memories_server(model_id, language_type)
+
    return success(data=timeline_memories_result, msg="共同记忆时间线")
@router.get("/memory_space/relationship_evolution", response_model=ApiResponse)
 async def memory_space_relationship_evolution(id: str, label: str,