Fix/language unification (#283)

* [changes]add user_summary language unification * [add]Entity extraction, user memory, emotion suggestions, unified language type for writing * [add]Complete the switch between Chinese and English for the emotion labels and emotion suggestions fields. * [changes]add user_summary language unification * [add]Entity extraction, user memory, emotion suggestions, unified language type for writing * [add]Complete the switch between Chinese and English for the emotion labels and emotion suggestions fields. * [changes]Modify the code based on the AI review
2026-02-03 16:03:08 +08:00
parent 63fa4dc8ec
commit 8670aaba1e
30 changed files with 1033 additions and 810 deletions
--- a/api/app/controllers/emotion_controller.py
+++ b/api/app/controllers/emotion_controller.py
@@ -11,6 +11,7 @@ Routes:
 """

 from app.core.error_codes import BizCode
+from app.core.language_utils import get_language_from_header
 from app.core.logging_config import get_api_logger
 from app.core.response_utils import fail, success
 from app.dependencies import get_current_user, get_db
@@ -45,11 +46,14 @@ emotion_service = EmotionAnalyticsService()
@router.post("/tags", response_model=ApiResponse)
 async def get_emotion_tags(
    request: EmotionTagsRequest,
-    language_type: str = Header(default="zh", alias="X-Language-Type"),
+    language_type: str = Header(default=None, alias="X-Language-Type"),
    current_user: User = Depends(get_current_user),
 ):

    try:
+        # 使用集中化的语言校验
+        language = get_language_from_header(language_type)
+        
        api_logger.info(
            f"用户 {current_user.username} 请求获取情绪标签统计",
            extra={
@@ -57,7 +61,8 @@ async def get_emotion_tags(
                "emotion_type": request.emotion_type,
                "start_date": request.start_date,
                "end_date": request.end_date,
-                "limit": request.limit
+                "limit": request.limit,
+                "language_type": language
            }
        )

@@ -67,7 +72,8 @@ async def get_emotion_tags(
            emotion_type=request.emotion_type,
            start_date=request.start_date,
            end_date=request.end_date,
-            limit=request.limit
+            limit=request.limit,
+            language=language
        )

        api_logger.info(
@@ -97,11 +103,14 @@ async def get_emotion_tags(
@router.post("/wordcloud", response_model=ApiResponse)
 async def get_emotion_wordcloud(
    request: EmotionWordcloudRequest,
-    language_type: str = Header(default="zh", alias="X-Language-Type"),
+    language_type: str = Header(default=None, alias="X-Language-Type"),
    current_user: User = Depends(get_current_user),
 ):

    try:
+        # 使用集中化的语言校验
+        language = get_language_from_header(language_type)
+        
        api_logger.info(
            f"用户 {current_user.username} 请求获取情绪词云数据",
            extra={
@@ -144,11 +153,14 @@ async def get_emotion_wordcloud(
@router.post("/health", response_model=ApiResponse)
 async def get_emotion_health(
    request: EmotionHealthRequest,
-    language_type: str = Header(default="zh", alias="X-Language-Type"),
+    language_type: str = Header(default=None, alias="X-Language-Type"),
    current_user: User = Depends(get_current_user),
 ):

    try:
+        # 使用集中化的语言校验
+        language = get_language_from_header(language_type)
+        
        # 验证时间范围参数
        if request.time_range not in ["7d", "30d", "90d"]:
            raise HTTPException(
@@ -199,7 +211,7 @@ async def get_emotion_health(
@router.post("/suggestions", response_model=ApiResponse)
 async def get_emotion_suggestions(
    request: EmotionSuggestionsRequest,
-    language_type: str = Header(default="zh", alias="X-Language-Type"),
+    language_type: str = Header(default=None, alias="X-Language-Type"),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
 ):
@@ -214,6 +226,9 @@ async def get_emotion_suggestions(
        缓存的个性化情绪建议响应
    """
    try:
+        # 使用集中化的语言校验
+        language = get_language_from_header(language_type)
+        
        api_logger.info(
            f"用户 {current_user.username} 请求获取个性化情绪建议（缓存）",
            extra={
@@ -265,7 +280,7 @@ async def get_emotion_suggestions(
@router.post("/generate_suggestions", response_model=ApiResponse)
 async def generate_emotion_suggestions(
    request: EmotionGenerateSuggestionsRequest,
-    language_type: str = Header(default="zh", alias="X-Language-Type"),
+    language_type: str = Header(default=None, alias="X-Language-Type"),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
 ):
@@ -280,6 +295,9 @@ async def generate_emotion_suggestions(
        新生成的个性化情绪建议响应
    """
    try:
+        # 使用集中化的语言校验
+        language = get_language_from_header(language_type)
+        
        api_logger.info(
            f"用户 {current_user.username} 请求生成个性化情绪建议",
            extra={
@@ -290,7 +308,8 @@ async def generate_emotion_suggestions(
        # 调用服务层生成建议
        data = await emotion_service.generate_emotion_suggestions(
            end_user_id=request.end_user_id,
-            db=db
+            db=db,
+            language=language
        )

        # 保存到缓存
--- a/api/app/controllers/memory_agent_controller.py
+++ b/api/app/controllers/memory_agent_controller.py
@@ -2,6 +2,7 @@ from typing import List, Optional

 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.rag.llm.cv_model import QWenCV
 from app.core.response_utils import fail, success
@@ -118,6 +119,7 @@ async def download_log(
@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)
 ):
@@ -126,13 +128,17 @@ async def write_server(
    
    Args:
        user_input: Write request containing message and end_user_id
+        language_type: 语言类型 ("zh" 中文, "en" 英文)，通过 X-Language-Type Header 传递
    
    Returns:
        Response with write operation status
    """
+    # 使用集中化的语言校验
+    language = get_language_from_header(language_type)
+    
    config_id = user_input.config_id
    workspace_id = current_user.current_workspace_id
-    api_logger.info(f"Write service: workspace_id={workspace_id}, config_id={config_id}")
+    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(
@@ -169,7 +175,8 @@ async def write_server(
            config_id,
            db,
            storage_type, 
-            user_rag_memory_id
+            user_rag_memory_id,
+            language
        )

        return success(data=result, msg="写入成功")
@@ -188,6 +195,7 @@ async def write_server(
@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)
 ):
@@ -196,14 +204,18 @@ async def write_server_async(
    
    Args:
        user_input: Write request containing message and end_user_id
+        language_type: 语言类型 ("zh" 中文, "en" 英文)，通过 X-Language-Type Header 传递
    
    Returns:
        Task ID for tracking async operation
        Use GET /memory/write_result/{task_id} to check task status and get result
    """
+    # 使用集中化的语言校验
+    language = get_language_from_header(language_type)
+    
    config_id = user_input.config_id
    workspace_id = current_user.current_workspace_id
-    api_logger.info(f"Async write service: workspace_id={workspace_id}, config_id={config_id}")
+    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(
@@ -228,7 +240,7 @@ async def write_server_async(

        task = celery_app.send_task(
            "app.core.memory.agent.write_message",
-            args=[user_input.end_user_id, messages_list, config_id, storage_type, user_rag_memory_id]
+            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}")
        
@@ -653,7 +665,6 @@ 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: str = Header(default="zh", alias="X-Language-Type"),
    limit: int = Query(20, description="返回标签数量限制"),
    current_user: User = Depends(get_current_user),
    db: Session=Depends(get_db),
@@ -661,28 +672,18 @@ async def get_hot_memory_tags_by_user_api(
    """
    获取指定用户的热门记忆标签
    
+    注意：标签语言由写入时的 X-Language-Type 决定，查询时不进行翻译
+    
    返回格式：
    [
        {"name": "标签名", "frequency": 频次},
        ...
    ]
    """
-
-    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="获取热门记忆标签成功")
--- a/api/app/controllers/memory_reflection_controller.py
+++ b/api/app/controllers/memory_reflection_controller.py
@@ -3,6 +3,7 @@ import time
 import uuid
 from uuid import UUID

+from app.core.language_utils import get_language_from_header
 from app.core.logging_config import get_api_logger
 from app.core.memory.storage_services.reflection_engine.self_reflexion import (
    ReflectionConfig,
@@ -211,11 +212,13 @@ async def start_reflection_configs(
@router.get("/reflection/run")
 async def reflection_run(
    config_id: UUID|int,
-    language_type: str = Header(default="zh", alias="X-Language-Type"),
+    language_type: str = Header(default=None, alias="X-Language-Type"),
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
 ) -> dict:
    """Activate the reflection function for all matching applications in the workspace"""
+    # 使用集中化的语言校验
+    language = get_language_from_header(language_type)

    api_logger.info(f"用户 {current_user.username} 查询反思配置，config_id: {config_id}")
    config_id = resolve_config_id(config_id, db)
--- a/api/app/controllers/memory_short_term_controller.py
+++ b/api/app/controllers/memory_short_term_controller.py
@@ -1,4 +1,5 @@
 from fastapi import APIRouter, Depends, HTTPException, status,Header
+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
@@ -20,10 +21,13 @@ router = APIRouter(
@router.get("/short_term")
 async def short_term_configs(
        end_user_id: str,
-        language_type:str = Header(default="zh", alias="X-Language-Type"),
+        language_type:str = Header(default=None, alias="X-Language-Type"),
        current_user: User = Depends(get_current_user),
        db: Session = Depends(get_db),
 ):
+    # 使用集中化的语言校验
+    language = get_language_from_header(language_type)
+    
    # 获取短期记忆数据
    short_term=ShortService(end_user_id)
    short_result=short_term.get_short_databasets()
--- a/api/app/controllers/memory_storage_controller.py
+++ b/api/app/controllers/memory_storage_controller.py
@@ -3,6 +3,7 @@ from typing import Optional
 from uuid import UUID

 from app.core.error_codes import BizCode
+from app.core.language_utils import get_language_from_header
 from app.core.logging_config import get_api_logger
 from app.core.response_utils import fail, success
 from app.db import get_db
@@ -31,7 +32,7 @@ from app.services.memory_storage_service import (
    search_entity,
    search_statement,
 )
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, Header
 from fastapi.responses import StreamingResponse
 from sqlalchemy.orm import Session

@@ -280,17 +281,21 @@ def read_all_config(
@router.post("/pilot_run", response_model=None)
 async def pilot_run(
    payload: ConfigPilotRun,
+    language_type: str = Header(default=None, alias="X-Language-Type"),
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
 ) -> StreamingResponse:
+    # 使用集中化的语言校验
+    language = get_language_from_header(language_type)
+    
    api_logger.info(
        f"Pilot run requested: config_id={payload.config_id}, "
-        f"dialogue_text_length={len(payload.dialogue_text)}"
+        f"dialogue_text_length={len(payload.dialogue_text)}, language={language}"
    )
    payload.config_id = resolve_config_id(payload.config_id, db)
    svc = DataConfigService(db)
    return StreamingResponse(
-        svc.pilot_run_stream(payload),
+        svc.pilot_run_stream(payload, language=language),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
--- a/api/app/controllers/ontology_controller.py
+++ b/api/app/controllers/ontology_controller.py
@@ -25,12 +25,12 @@ from fastapi import APIRouter, Depends, HTTPException, Header
 from sqlalchemy.orm import Session

 from app.core.error_codes import BizCode
+from app.core.language_utils import get_language_from_header
 from app.core.logging_config import get_api_logger
 from app.core.response_utils import fail, success
 from app.db import get_db
 from app.dependencies import get_current_user
 from app.models.user_model import User
-from app.services.memory_base_service import Translation_English
 from app.core.memory.models.ontology_models import OntologyClass
 from typing import List
 from app.schemas.ontology_schemas import (
@@ -63,72 +63,6 @@ router = APIRouter(
 )


-async def translate_ontology_classes(
-    classes: List[OntologyClass], 
-    model_id: str
-) -> List[OntologyClass]:
-    """翻译本体类列表
-    
-    将本体类的中文字段翻译为英文，包括：
-    - name_chinese: 中文名称
-    - description: 描述
-    - examples: 示例列表
-    
-    Args:
-        classes: 本体类列表
-        model_id: LLM模型ID，用于翻译
-        
-    Returns:
-        List[OntologyClass]: 翻译后的本体类列表
-    """
-    translated_classes = []
-    
-    for ontology_class in classes:
-        # 创建类的副本，避免修改原对象
-        translated_class = ontology_class.model_copy(deep=True)
-        
-        # 翻译 name_chinese 字段
-        if translated_class.name_chinese:
-            try:
-                translated_class.name_chinese = await Translation_English(
-                    model_id, 
-                    translated_class.name_chinese
-                )
-            except Exception as e:
-                logger.warning(f"Failed to translate name_chinese: {e}")
-                # 保留原文
-        
-        # 翻译 description 字段
-        if translated_class.description:
-            try:
-                translated_class.description = await Translation_English(
-                    model_id, 
-                    translated_class.description
-                )
-            except Exception as e:
-                logger.warning(f"Failed to translate description: {e}")
-                # 保留原文
-        
-        # 翻译 examples 列表
-        if translated_class.examples:
-            translated_examples = []
-            for example in translated_class.examples:
-                try:
-                    translated_example = await Translation_English(
-                        model_id, 
-                        example
-                    )
-                    translated_examples.append(translated_example)
-                except Exception as e:
-                    logger.warning(f"Failed to translate example: {e}")
-                    translated_examples.append(example)  # 保留原文
-            translated_class.examples = translated_examples
-        
-        translated_classes.append(translated_class)
-    
-    return translated_classes
-
-
 def _get_ontology_service(
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
@@ -243,7 +177,7 @@ def _get_ontology_service(
@router.post("/extract", response_model=ApiResponse)
 async def extract_ontology(
    request: ExtractionRequest,
-    language_type: str = Header(default="zh", alias="X-Language-Type"),
+    language_type: str = Header(default=None, alias="X-Language-Type"),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
 ):
@@ -260,31 +194,6 @@ async def extract_ontology(
        db: 数据库会话
        current_user: 当前用户
        
-    Returns:
-        ApiResponse: 包含提取结果的响应
-        
-    Response format:
-        {
-            "code": 200,
-            "msg": "本体提取成功",
-            "data": {
-                "classes": [
-                    {
-                        "id": "147d9db50b524a9e909e01a753d3acdd",
-                        "name": "Patient",
-                        "name_chinese": "患者",
-                        "description": "在医疗机构中接受诊疗、护理或健康管理的个体",
-                        "examples": ["糖尿病患者", "术后康复患者", "门诊初诊患者"],
-                        "parent_class": null,
-                        "entity_type": "Person",
-                        "domain": "Healthcare"
-                    },
-                    ...
-                ],
-                "domain": "Healthcare",
-                "extracted_count": 7
-            }
-        }
    """
    api_logger.info(
        f"Ontology extraction requested by user {current_user.id}, "
@@ -296,6 +205,9 @@ async def extract_ontology(
    )
    
    try:
+        # 使用集中化的语言校验
+        language = get_language_from_header(language_type)
+        
        # 获取当前工作空间ID
        workspace_id = current_user.current_workspace_id
        if not workspace_id:
@@ -314,33 +226,11 @@ async def extract_ontology(
            scenario=request.scenario,
            domain=request.domain,
            scene_id=request.scene_id,
-            workspace_id=workspace_id
+            workspace_id=workspace_id,
+            language=language
        )
        
-        # ===== 新增：翻译逻辑 =====
-        # 如果需要英文，则翻译数据
-        if language_type != 'zh':
-            api_logger.info(f"Translating extraction result to English")
-            
-            # 翻译 classes 列表
-            result.classes = await translate_ontology_classes(
-                result.classes, 
-                request.llm_id
-            )
-            
-            # 翻译 domain 字段
-            if result.domain:
-                try:
-                    result.domain = await Translation_English(
-                        request.llm_id, 
-                        result.domain
-                    )
-                except Exception as e:
-                    logger.warning(f"Failed to translate domain: {e}")
-                    # 保留原文
-        # ===== 翻译逻辑结束 =====
-        
-        # 构建响应
+        # 构建响应（语言已在提取时通过模板控制，无需二次翻译）
        response = ExtractionResponse(
            classes=result.classes,
            domain=result.domain,
--- a/api/app/controllers/user_memory_controllers.py
+++ b/api/app/controllers/user_memory_controllers.py
@@ -8,11 +8,11 @@ from sqlalchemy.orm import Session
 from fastapi import APIRouter, Depends,Header

 from app.db import get_db
+from app.core.language_utils import get_language_from_header
 from app.core.logging_config import get_api_logger
 from app.core.response_utils import success, fail
 from app.core.error_codes import BizCode
 from app.core.api_key_utils import timestamp_to_datetime
-from app.services.memory_base_service import Translation_English
 from app.services.user_memory_service import (
    UserMemoryService,
    analytics_memory_types,
@@ -45,7 +45,6 @@ router = APIRouter(
@router.get("/analytics/memory_insight/report", response_model=ApiResponse)
 async def get_memory_insight_report_api(
    end_user_id: str,
-    language_type: str = Header(default="zh", alias="X-Language-Type"),
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
 ) -> dict:
@@ -55,18 +54,10 @@ 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,model_id,language_type)
+        result = await user_memory_service.get_cached_memory_insight(db, end_user_id)

        if result["is_cached"]:
            api_logger.info(f"成功返回缓存的记忆洞察报告: end_user_id={end_user_id}")
@@ -82,7 +73,7 @@ async def get_memory_insight_report_api(
@router.get("/analytics/user_summary", response_model=ApiResponse)
 async def get_user_summary_api(
    end_user_id: str,
-    language_type: str = Header(default="zh", alias="X-Language-Type"),
+    language_type: str = Header(default=None, alias="X-Language-Type"),
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
 ) -> dict:
@@ -91,7 +82,14 @@ async def get_user_summary_api(

    此接口仅查询数据库中已缓存的用户摘要数据，不执行生成操作。
    如需生成新的用户摘要，请使用专门的生成接口。
+    
+    语言控制：
+    - 使用 X-Language-Type Header 指定语言
+    - 如果未传 Header，默认使用中文 (zh)
    """
+    # 使用集中化的语言校验
+    language = get_language_from_header(language_type)
+    
    workspace_id = current_user.current_workspace_id
    workspace_repo = WorkspaceRepository(db)
    workspace_models = workspace_repo.get_workspace_models_configs(workspace_id)
@@ -103,7 +101,7 @@ async def get_user_summary_api(
    api_logger.info(f"用户摘要查询请求: end_user_id={end_user_id}, user={current_user.username}")
    try:
        # 调用服务层获取缓存数据
-        result = await user_memory_service.get_cached_user_summary(db, end_user_id,model_id,language_type)
+        result = await user_memory_service.get_cached_user_summary(db, end_user_id,model_id,language)

        if result["is_cached"]:
            api_logger.info(f"成功返回缓存的用户摘要: end_user_id={end_user_id}")
@@ -119,6 +117,7 @@ async def get_user_summary_api(
@router.post("/analytics/generate_cache", response_model=ApiResponse)
 async def generate_cache_api(
    request: GenerateCacheRequest,
+    language_type: str = Header(default=None, alias="X-Language-Type"),
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
 ) -> dict:
@@ -127,7 +126,14 @@ async def generate_cache_api(

    - 如果提供 end_user_id，只为该用户生成
    - 如果不提供，为当前工作空间的所有用户生成
+    
+    语言控制：
+    - 使用 X-Language-Type Header 指定语言 ("zh" 中文, "en" 英文)
+    - 如果未传 Header，默认使用中文 (zh)
    """
+    # 使用集中化的语言校验
+    language = get_language_from_header(language_type)
+    
    workspace_id = current_user.current_workspace_id

    # 检查用户是否已选择工作空间
@@ -139,7 +145,7 @@ async def generate_cache_api(

    api_logger.info(
        f"缓存生成请求: user={current_user.username}, workspace={workspace_id}, "
-        f"end_user_id={end_user_id if end_user_id else '全部用户'}"
+        f"end_user_id={end_user_id if end_user_id else '全部用户'}, language={language}"
    )

    try:
@@ -148,10 +154,10 @@ async def generate_cache_api(
            api_logger.info(f"开始为单个用户生成缓存: end_user_id={end_user_id}")

            # 生成记忆洞察
-            insight_result = await user_memory_service.generate_and_cache_insight(db, end_user_id, workspace_id)
+            insight_result = await user_memory_service.generate_and_cache_insight(db, end_user_id, workspace_id, language=language)

            # 生成用户摘要
-            summary_result = await user_memory_service.generate_and_cache_summary(db, end_user_id, workspace_id)
+            summary_result = await user_memory_service.generate_and_cache_summary(db, end_user_id, workspace_id, language=language)

            # 构建响应
            result = {
@@ -185,7 +191,7 @@ async def generate_cache_api(
            # 为整个工作空间生成
            api_logger.info(f"开始为工作空间 {workspace_id} 批量生成缓存")

-            result = await user_memory_service.generate_cache_for_workspace(db, workspace_id)
+            result = await user_memory_service.generate_cache_for_workspace(db, workspace_id, language=language)

            # 记录统计信息
            api_logger.info(
@@ -385,10 +391,13 @@ async def update_end_user_profile(
            return fail(BizCode.INTERNAL_ERROR, "用户信息更新失败", error_msg)

@router.get("/memory_space/timeline_memories", response_model=ApiResponse)
-async def memory_space_timeline_of_shared_memories(id: str, label: str,language_type: str = Header(default="zh", alias="X-Language-Type"),
+async def memory_space_timeline_of_shared_memories(id: str, label: str,language_type: str = Header(default=None, alias="X-Language-Type"),
                                      current_user: User = Depends(get_current_user),
                                      db: Session = Depends(get_db),
                                      ):
+    # 使用集中化的语言校验
+    language = get_language_from_header(language_type)
+    
    workspace_id=current_user.current_workspace_id
    workspace_repo = WorkspaceRepository(db)
    workspace_models = workspace_repo.get_workspace_models_configs(workspace_id)
@@ -398,7 +407,7 @@ async def memory_space_timeline_of_shared_memories(id: str, label: str,language_
    else:
        model_id = None
    MemoryEntity = MemoryEntityService(id, label)
-    timeline_memories_result = await MemoryEntity.get_timeline_memories_server(model_id, language_type)
+    timeline_memories_result = await MemoryEntity.get_timeline_memories_server(model_id, language)

    return success(data=timeline_memories_result, msg="共同记忆时间线")
@router.get("/memory_space/relationship_evolution", response_model=ApiResponse)