Merge branch 'develop' of codeup.aliyun.com:redbearai/python/redbear-mem-open into develop

# Conflicts: # api/app/services/workspace_service.py
2025-12-24 20:59:51 +08:00
parent c21ae4c571 cf900219a3
commit a7d18712b4
107 changed files with 5443 additions and 5005 deletions
--- a/api/app/controllers/emotion_controller.py
+++ b/api/app/controllers/emotion_controller.py
@@ -10,22 +10,21 @@ Routes:
    POST /emotion/suggestions - 获取个性化情绪建议
 """

-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy.orm import Session
-
-from app.core.response_utils import success, fail
 from app.core.error_codes import BizCode
+from app.core.logging_config import get_api_logger
+from app.core.response_utils import fail, success
 from app.dependencies import get_current_user, get_db
 from app.models.user_model import User
-from app.schemas.response_schema import ApiResponse
 from app.schemas.emotion_schema import (
+    EmotionHealthRequest,
+    EmotionSuggestionsRequest,
    EmotionTagsRequest,
    EmotionWordcloudRequest,
-    EmotionHealthRequest,
-    EmotionSuggestionsRequest
 )
+from app.schemas.response_schema import ApiResponse
 from app.services.emotion_analytics_service import EmotionAnalyticsService
-from app.core.logging_config import get_api_logger
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session

 # 获取API专用日志器
 api_logger = get_api_logger()
@@ -211,13 +210,28 @@ async def get_emotion_suggestions(
    """
    try:
        # 验证 config_id（如果提供）
+        # 获取终端用户关联的配置
        config_id = request.config_id
-        if config_id is not None:
-            from app.controllers.memory_agent_controller import validate_config_id
+        if config_id is None:
+            # 如果没有提供 config_id，尝试获取用户关联的配置
            try:
-                config_id = validate_config_id(config_id, db)
+                from app.services.memory_agent_service import (
+                    get_end_user_connected_config,
+                )
+                connected_config = get_end_user_connected_config(request.group_id, db)
+                config_id = connected_config.get("memory_config_id")
            except ValueError as e:
-                return fail(BizCode.INVALID_PARAMETER, "配置ID无效", str(e))
+                return fail(BizCode.INVALID_PARAMETER, "无法获取用户关联的配置", str(e))
+        else:
+            # 如果提供了 config_id，验证其有效性
+            from app.services.memory_config_service import MemoryConfigService
+            try:
+                config_service = MemoryConfigService(db)
+                config = config_service.get_config_by_id(config_id)
+                if not config:
+                    return fail(BizCode.INVALID_PARAMETER, "配置ID无效", f"配置 {config_id} 不存在")
+            except Exception as e:
+                return fail(BizCode.INVALID_PARAMETER, "配置ID验证失败", str(e))
        
        api_logger.info(
            f"用户 {current_user.username} 请求获取个性化情绪建议",
@@ -230,7 +244,7 @@ async def get_emotion_suggestions(
        # 调用服务层
        data = await emotion_service.generate_emotion_suggestions(
            end_user_id=request.group_id,
-            config_id=config_id
+            db=db
        )
        
        api_logger.info(
--- a/api/app/controllers/memory_agent_controller.py
+++ b/api/app/controllers/memory_agent_controller.py
@@ -1,36 +1,28 @@
-import json
-import time
-from typing import Optional, List
-from fastapi import APIRouter, Depends, Query, UploadFile
-from sqlalchemy.orm import Session
-from starlette.responses import StreamingResponse
-from app.db import get_db
-from app.core.memory.utils.config.config_utils import get_model_config
-from app.core.rag.llm.cv_model import QWenCV
-from app.models import ModelApiKey, Knowledge
-from app.services.memory_agent_service import MemoryAgentService
-from app.dependencies import get_current_superuser, get_current_user, get_current_tenant, workspace_access_guard, cur_workspace_access_guard
+from typing import List, Optional
+
 from app.celery_app import celery_app
-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.services import task_service, workspace_service
+from app.core.logging_config import get_api_logger
+from app.core.rag.llm.cv_model import QWenCV
+from app.core.response_utils import fail, success
+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.schemas.memory_agent_schema import UserInput, Write_UserInput
 from app.schemas.response_schema import ApiResponse
-from app.dependencies import get_current_user
-from app.models.user_model import User
-from fastapi import APIRouter, Depends, File, UploadFile, Form
-from app.repositories import knowledge_repository
+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
-import os
+from fastapi import APIRouter, Depends, File, Form, Query, UploadFile
+from sqlalchemy.orm import Session
+from starlette.responses import StreamingResponse

-# 加载.env文件
 load_dotenv()
-# Get API logger
 api_logger = get_api_logger()

-# Initialize service
 memory_agent_service = MemoryAgentService()

 router = APIRouter(
@@ -39,95 +31,6 @@ router = APIRouter(
 )


-def validate_config_id(config_id: int, db: Session) -> int:
-    """
-    Validate and ensure config_id is available, valid, and exists in database.
-    
-    Args:
-        config_id: Configuration ID to validate
-        db: Database session for checking existence
-        
-    Returns:
-        int: Validated config_id
-        
-    Raises:
-        ValueError: If config_id is None, invalid, or doesn't exist in database
-    """
-    if config_id is None:
-        api_logger.info("config_id is required but was not provided")
-        config_id = os.getenv('config_id')
-        if config_id is None:
-            raise ValueError("config_id is required but was not provided")
-    
-    
-    # Check if config exists in database
-    try:
-        from app.models.data_config_model import DataConfig
-        from app.models.models_model import ModelConfig
-        
-        config = db.query(DataConfig).filter(DataConfig.config_id == config_id).first()
-        if config is None:
-            error_msg = f"Configuration with config_id={config_id} does not exist in database"
-            api_logger.error(error_msg)
-            raise ValueError(error_msg)
-        
-        # Validate llm_id exists and is usable
-        if config.llm_id:
-            try:
-                llm_config = db.query(ModelConfig).filter(ModelConfig.id == config.llm_id).first()
-                if llm_config is None:
-                    error_msg = f"LLM model with id={config.llm_id} (from config_id={config_id}) does not exist"
-                    api_logger.error(error_msg)
-                    raise ValueError(error_msg)
-                if not llm_config.is_active:
-                    error_msg = f"LLM model with id={config.llm_id} (from config_id={config_id}) is not active"
-                    api_logger.error(error_msg)
-                    raise ValueError(error_msg)
-                api_logger.debug(f"LLM validation successful: llm_id={config.llm_id}, name={llm_config.name}")
-            except ValueError:
-                raise
-            except Exception as e:
-                error_msg = f"Error validating LLM model: {str(e)}"
-                api_logger.error(error_msg, exc_info=True)
-                raise ValueError(error_msg)
-        else:
-            api_logger.error(f"Config {config_id} has no llm_id set")
-            raise ValueError(f"Config {config_id} has no llm_id set")
-        
-        # Validate embedding_id exists and is usable
-        if config.embedding_id:
-            try:
-                embedding_config = db.query(ModelConfig).filter(ModelConfig.id == config.embedding_id).first()
-                if embedding_config is None:
-                    error_msg = f"Embedding model with id={config.embedding_id} (from config_id={config_id}) does not exist"
-                    api_logger.error(error_msg)
-                    raise ValueError(error_msg)
-                if not embedding_config.is_active:
-                    error_msg = f"Embedding model with id={config.embedding_id} (from config_id={config_id}) is not active"
-                    api_logger.error(error_msg)
-                    raise ValueError(error_msg)
-                api_logger.debug(f"Embedding validation successful: embedding_id={config.embedding_id}, name={embedding_config.name}")
-            except ValueError:
-                raise
-            except Exception as e:
-                error_msg = f"Error validating embedding model: {str(e)}"
-                api_logger.error(error_msg, exc_info=True)
-                raise ValueError(error_msg)
-        else:
-            api_logger.error(f"Config {config_id} has no embedding_id set")
-            raise ValueError(f"Config {config_id} has no embedding_id set")
-        
-        api_logger.info(f"Config validation successful: config_id={config_id}, config_name={config.config_name}, llm_id={config.llm_id}, embedding_id={config.embedding_id}")
-        return config_id
-    except ValueError:
-        # Re-raise ValueError from above
-        raise
-    except Exception as e:
-        error_msg = f"Database error while validating config_id={config_id}: {str(e)}"
-        api_logger.error(error_msg, exc_info=True)
-        raise ValueError(error_msg)
-
-
@router.get("/health/status", response_model=ApiResponse)
 async def get_health_status(
    current_user: User = Depends(get_current_user)
@@ -225,12 +128,7 @@ async def write_server(
    Returns:
        Response with write operation status
    """
-    # Validate config_id
-    try:
-        config_id = validate_config_id(user_input.config_id, db)
-    except ValueError as e:
-        return fail(BizCode.INVALID_PARAMETER, "配置ID无效", str(e))
-    
+    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}")
    
@@ -265,13 +163,20 @@ async def write_server(
        result = await memory_agent_service.write_memory(
            user_input.group_id, 
            user_input.message, 
-            config_id, 
+            config_id,
+            db,
            storage_type, 
            user_rag_memory_id
        )
        return success(data=result, msg="写入成功")
-    except Exception as e:
-        api_logger.error(f"Write operation error: {str(e)}")
+    except BaseException as e:
+        # Handle ExceptionGroup from TaskGroup (Python 3.11+) or BaseExceptionGroup
+        if hasattr(e, 'exceptions'):
+            error_messages = [f"{type(sub_e).__name__}: {str(sub_e)}" for sub_e in e.exceptions]
+            detailed_error = "; ".join(error_messages)
+            api_logger.error(f"Write operation error (TaskGroup): {detailed_error}", exc_info=True)
+            return fail(BizCode.INTERNAL_ERROR, "写入失败", detailed_error)
+        api_logger.error(f"Write operation error: {str(e)}", exc_info=True)
        return fail(BizCode.INTERNAL_ERROR, "写入失败", str(e))


@@ -292,12 +197,7 @@ async def write_server_async(
        Task ID for tracking async operation
        Use GET /memory/write_result/{task_id} to check task status and get result
    """
-    # Validate config_id
-    try:
-        config_id = validate_config_id(user_input.config_id, db)
-    except ValueError as e:
-        return fail(BizCode.INVALID_PARAMETER, "配置ID无效", str(e))
-    
+    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}")

@@ -352,12 +252,7 @@ async def read_server(
    Returns:
        Response with query answer
    """
-    # Validate config_id
-    try:
-        config_id = validate_config_id(user_input.config_id, db)
-    except ValueError as e:
-        return fail(BizCode.INVALID_PARAMETER, "配置ID无效", str(e))
-    
+    config_id = user_input.config_id
    workspace_id = current_user.current_workspace_id
    api_logger.info(f"Read service: workspace_id={workspace_id}, config_id={config_id}")

@@ -386,12 +281,19 @@ async def read_server(
            user_input.history,
            user_input.search_switch,
            config_id,
+            db,
            storage_type,
            user_rag_memory_id
        )
        return success(data=result, msg="回复对话消息成功")
-    except Exception as e:
-        api_logger.error(f"Read operation error: {str(e)}")
+    except BaseException as e:
+        # Handle ExceptionGroup from TaskGroup (Python 3.11+) or BaseExceptionGroup
+        if hasattr(e, 'exceptions'):
+            error_messages = [f"{type(sub_e).__name__}: {str(sub_e)}" for sub_e in e.exceptions]
+            detailed_error = "; ".join(error_messages)
+            api_logger.error(f"Read operation error (TaskGroup): {detailed_error}", exc_info=True)
+            return fail(BizCode.INTERNAL_ERROR, "回复对话消息失败", detailed_error)
+        api_logger.error(f"Read operation error: {str(e)}", exc_info=True)
        return fail(BizCode.INTERNAL_ERROR, "回复对话消息失败", str(e))


@@ -456,12 +358,7 @@ async def read_server_async(
        db: Session = Depends(get_db),
        current_user: User = Depends(get_current_user)
 ):
-    # Validate config_id
-    try:
-        config_id = validate_config_id(user_input.config_id, db)
-    except ValueError as e:
-        return fail(BizCode.INVALID_PARAMETER, "配置ID无效", str(e))
-    
+    config_id = user_input.config_id
    workspace_id = current_user.current_workspace_id
    api_logger.info(f"Async read service: workspace_id={workspace_id}, config_id={config_id}")

@@ -653,6 +550,7 @@ 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)
 ):
    """
@@ -666,7 +564,11 @@ async def status_type(
    """
    api_logger.info(f"Status type check requested for group {user_input.group_id}")
    try:
-        result = await memory_agent_service.classify_message_type(user_input.message)
+        result = await memory_agent_service.classify_message_type(
+            user_input.message,
+            user_input.config_id,
+            db
+        )
        return success(data=result)
    except Exception as e:
        api_logger.error(f"Message type classification failed: {str(e)}")
@@ -741,6 +643,7 @@ async def get_hot_memory_tags_by_user_api(
@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)
 ):
    """
@@ -764,7 +667,8 @@ async def get_user_profile_api(
    try:
        result = await memory_agent_service.get_user_profile(
            end_user_id=end_user_id,
-            current_user_id=str(current_user.id)
+            current_user_id=str(current_user.id),
+            db=db
        )
        return success(data=result, msg="获取用户详情成功")
    except Exception as e:
@@ -799,4 +703,41 @@ async def get_user_profile_api(
 #             )
 #     except Exception as e:
 #         api_logger.error(f"API docs retrieval failed: {str(e)}")
-#         return fail(BizCode.INTERNAL_ERROR, "API文档获取失败", str(e))
+#         return fail(BizCode.INTERNAL_ERROR, "API文档获取失败", str(e))
+
+
+@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)
+):
+    """
+    获取终端用户关联的记忆配置
+    
+    通过以下流程获取配置：
+    1. 根据 end_user_id 获取用户的 app_id
+    2. 获取该应用的最新发布版本
+    3. 从发布版本的 config 字段中提取 memory_config_id
+    
+    Args:
+        end_user_id: 终端用户ID
+    
+    Returns:
+        包含 memory_config_id 和相关信息的响应
+    """
+    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="获取终端用户关联配置成功")
+    except ValueError as e:
+        api_logger.warning(f"End user config not found: {str(e)}")
+        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))
--- a/api/app/controllers/memory_reflection_controller.py
+++ b/api/app/controllers/memory_reflection_controller.py
@@ -1,22 +1,27 @@
 import asyncio
 import time

-from dotenv import load_dotenv
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy.orm import Session
-from sqlalchemy import text
-
 from app.core.logging_config import get_api_logger
+from app.core.memory.storage_services.reflection_engine.self_reflexion import (
+    ReflectionConfig,
+    ReflectionEngine,
+)
 from app.core.response_utils import success
-from app.core.memory.storage_services.reflection_engine.self_reflexion import ReflectionConfig, ReflectionEngine
-from app.dependencies import get_current_user
 from app.db import get_db
+from app.dependencies import get_current_user
 from app.models.user_model import User
 from app.repositories.data_config_repository import DataConfigRepository
 from app.repositories.neo4j.neo4j_connector import Neo4jConnector
-from app.services.memory_reflection_service import WorkspaceAppService, MemoryReflectionService
 from app.schemas.memory_reflection_schemas import Memory_Reflection
+from app.services.memory_reflection_service import (
+    MemoryReflectionService,
+    WorkspaceAppService,
+)
 from app.services.model_service import ModelConfigService
+from dotenv import load_dotenv
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy import text
+from sqlalchemy.orm import Session

 load_dotenv()
 api_logger = get_api_logger()
--- a/api/app/controllers/memory_storage_controller.py
+++ b/api/app/controllers/memory_storage_controller.py
@@ -1,50 +1,49 @@
-from typing import Optional
+import datetime
 import os
 import uuid
-import datetime
-from sqlalchemy.orm import Session
-from fastapi import APIRouter, Depends
-from fastapi.responses import StreamingResponse
+from typing import Optional

-
-from app.db import get_db
-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.logging_config import get_api_logger
 from app.core.memory.utils.self_reflexion_utils import self_reflexion
-from app.services.memory_storage_service import (
-    MemoryStorageService,
-    DataConfigService,
-    kb_type_distribution,
-    search_dialogue,
-    search_chunk,
-    search_statement,
-    search_entity,
-    search_all,
-    search_detials,
-    search_edges,
-    search_entity_graph,
-    analytics_hot_memory_tags,
-    analytics_recent_activity_stats,
-)
-from app.schemas.response_schema import ApiResponse
-from app.schemas.memory_storage_schema import (
-    ConfigParamsCreate,
-    ConfigParamsDelete,
-    ConfigUpdate,
-    ConfigUpdateExtracted,
-    ConfigUpdateForget,
-    ConfigKey,
-    ConfigPilotRun,
-    GenerateCacheRequest,
-)
+from app.core.response_utils import fail, success
+from app.db import get_db
+from app.dependencies import get_current_user
+from app.models.end_user_model import EndUser
+from app.models.user_model import User
 from app.schemas.end_user_schema import (
    EndUserProfileResponse,
    EndUserProfileUpdate,
 )
-from app.models.end_user_model import EndUser
-from app.dependencies import get_current_user
-from app.models.user_model import User
+from app.schemas.memory_storage_schema import (
+    ConfigKey,
+    ConfigParamsCreate,
+    ConfigParamsDelete,
+    ConfigPilotRun,
+    ConfigUpdate,
+    ConfigUpdateExtracted,
+    ConfigUpdateForget,
+    GenerateCacheRequest,
+)
+from app.schemas.response_schema import ApiResponse
+from app.services.memory_storage_service import (
+    DataConfigService,
+    MemoryStorageService,
+    analytics_hot_memory_tags,
+    analytics_recent_activity_stats,
+    kb_type_distribution,
+    search_all,
+    search_chunk,
+    search_detials,
+    search_dialogue,
+    search_edges,
+    search_entity,
+    search_entity_graph,
+    search_statement,
+)
+from fastapi import APIRouter, Depends
+from fastapi.responses import StreamingResponse
+from sqlalchemy.orm import Session

 # Get API logger
 api_logger = get_api_logger()
@@ -335,8 +334,10 @@ async def pilot_run(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
 ) -> StreamingResponse:
-    api_logger.info(f"Pilot run requested: config_id={payload.config_id}, dialogue_text_length={len(payload.dialogue_text)}")
-    
+    api_logger.info(
+        f"Pilot run requested: config_id={payload.config_id}, "
+        f"dialogue_text_length={len(payload.dialogue_text)}"
+    )
    svc = DataConfigService(db)
    return StreamingResponse(
        svc.pilot_run_stream(payload),
@@ -344,8 +345,8 @@ async def pilot_run(
        headers={
            "Cache-Control": "no-cache",
            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no"
-        }
+            "X-Accel-Buffering": "no",
+        },
    )

 """
@@ -508,6 +509,8 @@ async def get_recent_activity_stats_api(
        return fail(BizCode.INTERNAL_ERROR, "最近活动统计失败", str(e))


+
+
@router.get("/self_reflexion")
 async def self_reflexion_endpoint(host_id: uuid.UUID) -> str:
    """
--- a/api/app/controllers/user_memory_controllers.py
+++ b/api/app/controllers/user_memory_controllers.py
@@ -14,6 +14,7 @@ from app.core.error_codes import BizCode
 from app.services.user_memory_service import (
    UserMemoryService,
    analytics_node_statistics,
+    analytics_memory_types,
    analytics_graph_data,
 )
 from app.schemas.response_schema import ApiResponse
@@ -185,21 +186,19 @@ async def get_node_statistics_api(
        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}, workspace={workspace_id}")
+    api_logger.info(f"记忆类型统计请求: end_user_id={end_user_id}, user={current_user.username}, workspace={workspace_id}")
    
    try:
-        result = await analytics_node_statistics(db, end_user_id)
+        # 调用新的记忆类型统计函数
+        result = await analytics_memory_types(db, end_user_id)
        
-        # 检查是否有错误消息
-        if "message" in result and result["total"] == 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}, total={result['total']}")
+        # 计算总数用于日志
+        total_count = sum(item["count"] for item in result)
+        api_logger.info(f"成功获取记忆类型统计: end_user_id={end_user_id}, 总记忆数={total_count}, 类型数={len(result)}")
        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))
+        api_logger.error(f"记忆类型查询失败: end_user_id={end_user_id}, error={str(e)}")
+        return fail(BizCode.INTERNAL_ERROR, "记忆类型查询失败", str(e))

@router.get("/analytics/graph_data", response_model=ApiResponse)
 async def get_graph_data_api(
@@ -293,7 +292,7 @@ async def get_end_user_profile(
        # 构建响应数据
        profile_data = EndUserProfileResponse(
            id=end_user.id,
-            name=end_user.name,
+            other_name=end_user.other_name,
            position=end_user.position,
            department=end_user.department,
            contact=end_user.contact,
@@ -364,7 +363,7 @@ async def update_end_user_profile(
        # 构建响应数据
        profile_data = EndUserProfileResponse(
            id=end_user.id,
-            name=end_user.name,
+            other_name=end_user.other_name,
            position=end_user.position,
            department=end_user.department,
            contact=end_user.contact,
--- a/api/app/controllers/workspace_controller.py
+++ b/api/app/controllers/workspace_controller.py
@@ -1,25 +1,38 @@
-from fastapi import APIRouter, Depends, HTTPException, status, Query
-from sqlalchemy.orm import Session
-from typing import List, Optional
 import uuid
+from typing import List, 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_superuser, get_current_user, get_current_tenant, workspace_access_guard, cur_workspace_access_guard
-from app.models.user_model import User
+from app.dependencies import (
+    cur_workspace_access_guard,
+    get_current_superuser,
+    get_current_tenant,
+    get_current_user,
+    workspace_access_guard,
+)
 from app.models.tenant_model import Tenants
-from app.models.workspace_model import Workspace, InviteStatus
+from app.models.user_model import User
+from app.models.workspace_model import InviteStatus, Workspace
+from app.schemas import knowledge_schema
 from app.schemas.response_schema import ApiResponse
 from app.schemas.workspace_schema import (
-    WorkspaceCreate, WorkspaceUpdate, WorkspaceResponse,
-    WorkspaceInviteCreate, WorkspaceInviteResponse, 
-    InviteValidateResponse, InviteAcceptRequest,
-    WorkspaceMemberUpdate, WorkspaceMemberItem
+    InviteAcceptRequest,
+    InviteValidateResponse,
+    WorkspaceCreate,
+    WorkspaceInviteCreate,
+    WorkspaceInviteResponse,
+    WorkspaceMemberItem,
+    WorkspaceMemberUpdate,
+    WorkspaceModelsConfig,
+    WorkspaceModelsUpdate,
+    WorkspaceResponse,
+    WorkspaceUpdate,
 )
-from app.schemas import knowledge_schema
-from app.services import workspace_service
-from app.core.logging_config import get_api_logger
-from app.services import knowledge_service, document_service
+from app.services import document_service, knowledge_service, workspace_service
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.orm import Session
+
 # 获取API专用日志器
 api_logger = get_api_logger()
 # 需要认证的路由器
@@ -338,5 +351,30 @@ def workspace_models_configs(
        f"成功获取工作空间 {workspace_id} 的模型配置: "
        f"llm={configs.get('llm')}, embedding={configs.get('embedding')}, rerank={configs.get('rerank')}"
    )
-    return success(data=configs, msg="模型配置获取成功")
+    return success(data=WorkspaceModelsConfig.model_validate(configs), msg="模型配置获取成功")
+
+
+@router.put("/workspace_models", response_model=ApiResponse)
+@cur_workspace_access_guard()
+def update_workspace_models_configs(
+        models_update: WorkspaceModelsUpdate,
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_user),
+):
+    """更新当前工作空间的模型配置（llm, embedding, rerank）"""
+    workspace_id = current_user.current_workspace_id
+    api_logger.info(f"用户 {current_user.username} 请求更新工作空间 {workspace_id} 的模型配置")
+
+    updated_workspace = workspace_service.update_workspace_models_configs(
+        db=db,
+        workspace_id=workspace_id,
+        models_update=models_update,
+        user=current_user
+    )
+    
+    api_logger.info(
+        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="模型配置更新成功")