style(memory): Some code style optimizations

api/app/controllers/memory_storage_controller.py

@@ -54,8 +54,8 @@ router = APIRouter(
 
 @router.get("/info", response_model=ApiResponse)
 async def get_storage_info(
-    storage_id: str,
-    current_user: User = Depends(get_current_user)
+        storage_id: str,
+        current_user: User = Depends(get_current_user)
 ):
     """
     Example wrapper endpoint - retrieves storage information
@@ -75,17 +75,12 @@ async def get_storage_info(
         return fail(BizCode.INTERNAL_ERROR, "存储信息获取失败", str(e))
 
 
-
-
-
-
-
-@router.post("/create_config", response_model=ApiResponse)   # 创建配置文件，其他参数默认
+@router.post("/create_config", response_model=ApiResponse)  # 创建配置文件，其他参数默认
 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"),
+        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
     # 检查用户是否已选择工作空间
@@ -107,9 +102,11 @@ def create_config(
             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.")
+                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}」的记忆配置，请使用其他名称")
+                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)
@@ -119,9 +116,11 @@ def create_config(
             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.")
+                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}」的记忆配置，请使用其他名称")
+                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))
@@ -129,10 +128,10 @@ def create_config(
 
 @router.delete("/delete_config", response_model=ApiResponse)  # 删除数据库中的内容（按配置名称）
 def delete_config(
-    config_id: UUID|int,
-    force: bool = Query(False, description="是否强制删除（即使有终端用户正在使用）"),
-    current_user: User = Depends(get_current_user),
-    db: Session = Depends(get_db),
+        config_id: UUID | int,
+        force: bool = Query(False, description="是否强制删除（即使有终端用户正在使用）"),
+        current_user: User = Depends(get_current_user),
+        db: Session = Depends(get_db),
 ) -> dict:
     """删除记忆配置（带终端用户保护）
     
@@ -145,7 +144,7 @@ def delete_config(
         force: 设置为 true 可强制删除（即使有终端用户正在使用）
     """
     workspace_id = current_user.current_workspace_id
-    config_id=resolve_config_id(config_id, db)
+    config_id = resolve_config_id(config_id, db)
     # 检查用户是否已选择工作空间
     if workspace_id is None:
         api_logger.warning(f"用户 {current_user.username} 尝试删除配置但未选择工作空间")
@@ -203,9 +202,9 @@ def delete_config(
 
 @router.post("/update_config", response_model=ApiResponse)  # 更新配置文件中name和desc
 def update_config(
-    payload: ConfigUpdate,
-    current_user: User = Depends(get_current_user),
-    db: Session = Depends(get_db),
+        payload: ConfigUpdate,
+        current_user: User = Depends(get_current_user),
+        db: Session = Depends(get_db),
 ) -> dict:
     workspace_id = current_user.current_workspace_id
     payload.config_id = resolve_config_id(payload.config_id, db)
@@ -217,7 +216,8 @@ def update_config(
     # 校验至少有一个字段需要更新
     if payload.config_name is None and payload.config_desc is None and payload.scene_id is None:
         api_logger.warning(f"用户 {current_user.username} 尝试更新配置但未提供任何更新字段")
-        return fail(BizCode.INVALID_PARAMETER, "请至少提供一个需要更新的字段", "config_name, config_desc, scene_id 均为空")
+        return fail(BizCode.INVALID_PARAMETER, "请至少提供一个需要更新的字段",
+                    "config_name, config_desc, scene_id 均为空")
 
     api_logger.info(f"用户 {current_user.username} 在工作空间 {workspace_id} 请求更新配置: {payload.config_id}")
     try:
@@ -231,9 +231,9 @@ def update_config(
 
 @router.post("/update_config_extracted", response_model=ApiResponse)  # 更新数据库中的部分内容 所有业务字段均可选
 def update_config_extracted(
-    payload: ConfigUpdateExtracted,
-    current_user: User = Depends(get_current_user),
-    db: Session = Depends(get_db),
+        payload: ConfigUpdateExtracted,
+        current_user: User = Depends(get_current_user),
+        db: Session = Depends(get_db),
 ) -> dict:
     workspace_id = current_user.current_workspace_id
     payload.config_id = resolve_config_id(payload.config_id, db)
@@ -256,11 +256,11 @@ def update_config_extracted(
 # 遗忘引擎配置接口已迁移到 memory_forget_controller.py
 # 使用新接口: /api/memory/forget/read_config 和 /api/memory/forget/update_config
 
-@router.get("/read_config_extracted", response_model=ApiResponse) # 通过查询参数读取某条配置（固定路径） 没有意义的话就删除
+@router.get("/read_config_extracted", response_model=ApiResponse)  # 通过查询参数读取某条配置（固定路径） 没有意义的话就删除
 def read_config_extracted(
-    config_id: UUID | int,
-    current_user: User = Depends(get_current_user),
-    db: Session = Depends(get_db),
+        config_id: UUID | int,
+        current_user: User = Depends(get_current_user),
+        db: Session = Depends(get_db),
 ) -> dict:
     workspace_id = current_user.current_workspace_id
     config_id = resolve_config_id(config_id, db)
@@ -278,10 +278,11 @@ def read_config_extracted(
         api_logger.error(f"Read config extracted failed: {str(e)}")
         return fail(BizCode.INTERNAL_ERROR, "查询配置失败", str(e))
 
-@router.get("/read_all_config", response_model=ApiResponse) # 读取所有配置文件列表
+
+@router.get("/read_all_config", response_model=ApiResponse)  # 读取所有配置文件列表
 def read_all_config(
-    current_user: User = Depends(get_current_user),
-    db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_user),
+        db: Session = Depends(get_db),
 ) -> dict:
     workspace_id = current_user.current_workspace_id
 
@@ -303,10 +304,10 @@ 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),
+        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)
@@ -333,9 +334,9 @@ async def pilot_run(
 
 @router.get("/search/kb_type_distribution", response_model=ApiResponse)
 async def get_kb_type_distribution(
-    end_user_id: Optional[str] = None,
-    current_user: User = Depends(get_current_user),
-    ) -> dict:
+        end_user_id: Optional[str] = None,
+        current_user: User = Depends(get_current_user),
+) -> dict:
     api_logger.info(f"KB type distribution requested for end_user_id: {end_user_id}")
     try:
         result = await kb_type_distribution(end_user_id)
@@ -347,9 +348,9 @@ async def get_kb_type_distribution(
 
 @router.get("/search/dialogue", response_model=ApiResponse)
 async def search_dialogues_num(
-    end_user_id: Optional[str] = None,
-    current_user: User = Depends(get_current_user),
-    ) -> dict:
+        end_user_id: Optional[str] = None,
+        current_user: User = Depends(get_current_user),
+) -> dict:
     api_logger.info(f"Search dialogue requested for end_user_id: {end_user_id}")
     try:
         result = await search_dialogue(end_user_id)
@@ -361,9 +362,9 @@ async def search_dialogues_num(
 
 @router.get("/search/chunk", response_model=ApiResponse)
 async def search_chunks_num(
-    end_user_id: Optional[str] = None,
-    current_user: User = Depends(get_current_user),
-    ) -> dict:
+        end_user_id: Optional[str] = None,
+        current_user: User = Depends(get_current_user),
+) -> dict:
     api_logger.info(f"Search chunk requested for end_user_id: {end_user_id}")
     try:
         result = await search_chunk(end_user_id)
@@ -375,9 +376,9 @@ async def search_chunks_num(
 
 @router.get("/search/statement", response_model=ApiResponse)
 async def search_statements_num(
-    end_user_id: Optional[str] = None,
-    current_user: User = Depends(get_current_user),
-    ) -> dict:
+        end_user_id: Optional[str] = None,
+        current_user: User = Depends(get_current_user),
+) -> dict:
     api_logger.info(f"Search statement requested for end_user_id: {end_user_id}")
     try:
         result = await search_statement(end_user_id)
@@ -389,9 +390,9 @@ async def search_statements_num(
 
 @router.get("/search/entity", response_model=ApiResponse)
 async def search_entities_num(
-    end_user_id: Optional[str] = None,
-    current_user: User = Depends(get_current_user),
-    ) -> dict:
+        end_user_id: Optional[str] = None,
+        current_user: User = Depends(get_current_user),
+) -> dict:
     api_logger.info(f"Search entity requested for end_user_id: {end_user_id}")
     try:
         result = await search_entity(end_user_id)
@@ -403,9 +404,9 @@ async def search_entities_num(
 
 @router.get("/search", response_model=ApiResponse)
 async def search_all_num(
-    end_user_id: Optional[str] = None,
-    current_user: User = Depends(get_current_user),
-    ) -> dict:
+        end_user_id: Optional[str] = None,
+        current_user: User = Depends(get_current_user),
+) -> dict:
     api_logger.info(f"Search all requested for end_user_id: {end_user_id}")
     try:
         result = await search_all(end_user_id)
@@ -417,9 +418,9 @@ async def search_all_num(
 
 @router.get("/search/detials", response_model=ApiResponse)
 async def search_entities_detials(
-    end_user_id: Optional[str] = None,
-    current_user: User = Depends(get_current_user),
-    ) -> dict:
+        end_user_id: Optional[str] = None,
+        current_user: User = Depends(get_current_user),
+) -> dict:
     api_logger.info(f"Search details requested for end_user_id: {end_user_id}")
     try:
         result = await search_detials(end_user_id)
@@ -431,9 +432,9 @@ async def search_entities_detials(
 
 @router.get("/search/edges", response_model=ApiResponse)
 async def search_entity_edges(
-    end_user_id: Optional[str] = None,
-    current_user: User = Depends(get_current_user),
-    ) -> dict:
+        end_user_id: Optional[str] = None,
+        current_user: User = Depends(get_current_user),
+) -> dict:
     api_logger.info(f"Search edges requested for end_user_id: {end_user_id}")
     try:
         result = await search_edges(end_user_id)
@@ -443,14 +444,12 @@ async def search_entity_edges(
         return fail(BizCode.INTERNAL_ERROR, "边查询失败", str(e))
 
 
-
-
 @router.get("/analytics/hot_memory_tags", response_model=ApiResponse)
 async def get_hot_memory_tags_api(
-    limit: int = 10,
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_user),
-    ) -> dict:
+        limit: int = 10,
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_user),
+) -> dict:
     """
     获取热门记忆标签（带Redis缓存）
     
@@ -505,8 +504,8 @@ async def get_hot_memory_tags_api(
 
 @router.delete("/analytics/hot_memory_tags/cache", response_model=ApiResponse)
 async def clear_hot_memory_tags_cache(
-    current_user: User = Depends(get_current_user),
-    ) -> dict:
+        current_user: User = Depends(get_current_user),
+) -> dict:
     """
     清除热门标签缓存
     
@@ -543,7 +542,7 @@ 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),
+        current_user: User = Depends(get_current_user),
 ) -> 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}")
@@ -553,4 +552,3 @@ async def get_recent_activity_stats_api(
     except Exception as e:
         api_logger.error(f"Recent activity stats failed: {str(e)}")
         return fail(BizCode.INTERNAL_ERROR, "最近活动统计失败", str(e))
-

api/app/core/agent/langchain_agent.py

@@ -598,8 +598,10 @@ class LangChainAgent:
                 for msg in reversed(output_messages):
                     if isinstance(msg, AIMessage):
                         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
+                        total_tokens = response_meta.get("token_usage", {}).get(
+                            "total_tokens",
+                            0
+                        ) if response_meta else 0
                         yield total_tokens
                         break
                 if memory_flag:

api/app/core/memory/models/graph_models.py

@@ -206,7 +206,8 @@ class DialogueNode(Node):
     ref_id: str = Field(..., description="Reference identifier of the dialog")
     content: str = Field(..., description="Dialogue content")
     dialog_embedding: Optional[List[float]] = Field(None, description="Dialog embedding vector")
-    config_id: Optional[int | str] = Field(None, description="Configuration ID used to process this dialogue (integer or string)")
+    config_id: Optional[int | str] = Field(None,
+                                           description="Configuration ID used to process this dialogue (integer or string)")
 
 
 class StatementNode(Node):
@@ -281,7 +282,8 @@ class StatementNode(Node):
     statement_embedding: Optional[List[float]] = Field(None, description="Statement embedding vector")
     chunk_embedding: Optional[List[float]] = Field(None, description="Chunk embedding vector")
     connect_strength: str = Field(..., description="Strong VS Weak classification of this statement")
-    config_id: Optional[int | str] = Field(None, description="Configuration ID used to process this statement (integer or string)")
+    config_id: Optional[int | str] = Field(None,
+                                           description="Configuration ID used to process this statement (integer or string)")
 
     # ACT-R Memory Activation Properties
     importance_score: float = Field(
@@ -416,7 +418,8 @@ class ExtractedEntityNode(Node):
     # TODO: fact_summary 功能暂时禁用，待后续开发完善后启用
     # fact_summary: str = Field(default="", description="Summary of the fact about this entity")
     connect_strength: str = Field(..., description="Strong VS Weak about this entity")
-    config_id: Optional[int | str] = Field(None, description="Configuration ID used to process this entity (integer or string)")
+    config_id: Optional[int | str] = Field(None,
+                                           description="Configuration ID used to process this entity (integer or string)")
 
     # ACT-R Memory Activation Properties
     importance_score: float = Field(
@@ -453,7 +456,7 @@ class ExtractedEntityNode(Node):
 
     @field_validator('aliases', mode='before')
     @classmethod
-    def validate_aliases_field(cls, v): # 字段验证器 自动清理和验证 aliases 字段
+    def validate_aliases_field(cls, v):  # 字段验证器 自动清理和验证 aliases 字段
         """Validate and clean aliases field using utility function.
         
         This validator ensures that the aliases field is always a valid list of strings.
@@ -507,7 +510,8 @@ class MemorySummaryNode(Node):
     memory_type: Optional[str] = Field(None, description="Type/category of the episodic memory")
     summary_embedding: Optional[List[float]] = Field(None, description="Embedding vector for the summary")
     metadata: dict = Field(default_factory=dict, description="Additional metadata for the summary")
-    config_id: Optional[int | str] = Field(None, description="Configuration ID used to process this summary (integer or string)")
+    config_id: Optional[int | str] = Field(None,
+                                           description="Configuration ID used to process this summary (integer or string)")
 
     # ACT-R Forgetting Engine Properties
     original_statement_id: Optional[str] = Field(

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

@@ -227,7 +227,8 @@ class EmbeddingGenerator:
 
         # 打印前几个嵌入向量的维度
         for i in range(min(5, len(embeddings))):
-            print(f"实体 '{entity_texts[i]}' 嵌入向量维度: {len(embeddings[i])}")
+            print(f"实体 '{entity_texts[i]}' "
+                  f"嵌入向量维度: {len(embeddings[i])}")
 
         # 将嵌入向量赋值给实体
         for ent, emb in zip(entity_refs, embeddings):

api/app/repositories/neo4j/cypher_queries.py

@@ -709,7 +709,6 @@ SET r.end_user_id = e.end_user_id,
 RETURN elementId(r) AS uuid
 """
 
-
 # Entity Merge Query
 MERGE_ENTITIES = """
 MATCH (canonical:ExtractedEntity {id: $canonical_id})
@@ -829,9 +828,8 @@ neo4j_query_all = """
                 other as entity2
                           """
 
-
 '''针对当前节点下扩长的句子，实体和总结'''
-Memory_Timeline_ExtractedEntity="""
+Memory_Timeline_ExtractedEntity = """
 MATCH (n)-[r1]-(e)-[r2]-(ms)
 WHERE elementId(n) = $id
   AND (ms:ExtractedEntity OR ms:MemorySummary)
@@ -869,7 +867,7 @@ RETURN
 
 
 """
-Memory_Timeline_MemorySummary=""" 
+Memory_Timeline_MemorySummary = """ 
 MATCH (n)-[r1]-(e)-[r2]-(ms)
 WHERE elementId(n) =$id
   AND (ms:MemorySummary OR ms:ExtractedEntity)
@@ -904,7 +902,7 @@ RETURN
     }
   ) AS statement;
 """
-Memory_Timeline_Statement="""
+Memory_Timeline_Statement = """
 MATCH (n)
 WHERE elementId(n) = $id
 
@@ -947,7 +945,7 @@ RETURN
 """
 
 '''针对当前节点，主要获取更加完整的句子节点'''
-Memory_Space_Emotion_Statement="""
+Memory_Space_Emotion_Statement = """
 MATCH (n)
 WHERE elementId(n) = $id
 RETURN
@@ -957,7 +955,7 @@ RETURN
   n.statement         AS statement;
 
 """
-Memory_Space_Emotion_MemorySummary="""
+Memory_Space_Emotion_MemorySummary = """
 MATCH (n)-[]-(e)
 WHERE elementId(n) = $id
   AND EXISTS {
@@ -970,7 +968,7 @@ RETURN DISTINCT
   e.emotion_type      AS emotion_type,
   e.statement         AS statement;
 """
-Memory_Space_Emotion_ExtractedEntity="""
+Memory_Space_Emotion_ExtractedEntity = """
 MATCH (n)-[]-(e)
 WHERE elementId(n) = $id
   AND EXISTS {
@@ -985,18 +983,18 @@ RETURN DISTINCT
 
 '''获取实体'''
 
-Memory_Space_User="""
+Memory_Space_User = """
 MATCH (n)-[r]->(m)
 WHERE n.end_user_id = $end_user_id  AND m.name="用户" 
 return DISTINCT elementId(m) as id
 """
-Memory_Space_Entity="""
+Memory_Space_Entity = """
 MATCH (n)-[]-(m)
 WHERE elementId(m) = $id AND  m.entity_type = "Person"
 RETURN
 DISTINCT m.name as name,m.end_user_id as end_user_id
 """
-Memory_Space_Associative="""
+Memory_Space_Associative = """
 MATCH (u)-[]-(x)-[]-(h)
 WHERE elementId(u) = $user_id
   AND elementId(h) = $id
@@ -1060,7 +1058,6 @@ Graph_Node_query = """
 
             """
 
-
 # ============================================================
 # Community 节点 & BELONGS_TO_COMMUNITY 边
 # ============================================================

api/app/schemas/memory_storage_schema.py

@@ -8,9 +8,6 @@ import uuid
 from pydantic import BaseModel, Field, ConfigDict, field_validator, model_validator
 
 
-
-
-
 # ============================================================================
 # 从 json_schema.py 迁移的 Schema
 # ============================================================================
@@ -58,10 +55,13 @@ class MemoryVerifySchema(BaseModel):
 
 class ConflictResultSchema(BaseModel):
     """Schema for the conflict result data in the reflexion_data.json file."""
-    data: List[BaseDataSchema] = Field(..., description="The conflict memory data. Only contains conflicting records when conflict is True.")
+    data: List[BaseDataSchema] = Field(...,
+                                       description="The conflict memory data. Only contains conflicting records when conflict is True.")
     conflict: bool = Field(..., description="Whether the memory is in conflict.")
-    quality_assessment: Optional[QualityAssessmentSchema] = Field(None, description="The quality assessment object. Contains score and summary when quality_assessment is enabled, null otherwise.")
-    memory_verify: Optional[MemoryVerifySchema] = Field(None, description="The memory privacy verification object. Contains privacy detection results when memory_verify is enabled, null otherwise.")
+    quality_assessment: Optional[QualityAssessmentSchema] = Field(None,
+                                                                  description="The quality assessment object. Contains score and summary when quality_assessment is enabled, null otherwise.")
+    memory_verify: Optional[MemoryVerifySchema] = Field(None,
+                                                        description="The memory privacy verification object. Contains privacy detection results when memory_verify is enabled, null otherwise.")
 
     @model_validator(mode="before")
     def _normalize_data(cls, v):
@@ -105,12 +105,15 @@ class ChangeRecordSchema(BaseModel):
         description="List of field changes. First item: {id: value}, followed by changed fields as {field_name: [old_value, new_value]} or {field_name: new_value} or nested structures like {entity2: {field_name: [old, new]}}"
     )
 
+
 class ResolvedSchema(BaseModel):
     """Schema for the resolved memory data in the reflexion_data"""
     original_memory_id: Optional[str] = Field(None, description="The original memory identifier.")
     # resolved_memory: Optional[BaseDataSchema] = Field(None, description="The resolved memory data (only contains records that need modification).")
-    resolved_memory: Optional[Union[BaseDataSchema, List[BaseDataSchema]]] = Field(None, description="The resolved memory data (only contains records that need modification). Can be a single record or list of records.")
-    change: Optional[List[ChangeRecordSchema]] = Field(None, description="List of detailed change records with IDs and field information.")
+    resolved_memory: Optional[Union[BaseDataSchema, List[BaseDataSchema]]] = Field(None,
+                                                                                   description="The resolved memory data (only contains records that need modification). Can be a single record or list of records.")
+    change: Optional[List[ChangeRecordSchema]] = Field(None,
+                                                       description="List of detailed change records with IDs and field information.")
 
 
 class SingleReflexionResultSchema(BaseModel):
@@ -120,9 +123,11 @@ class SingleReflexionResultSchema(BaseModel):
     resolved: Optional[ResolvedSchema] = Field(None, description="The resolved memory data for this conflict.")
     type: str = Field("reflexion_result", description="The type identifier.")
 
+
 class ReflexionResultSchema(BaseModel):
     """Schema for the complete reflexion result data - a list of individual conflict resolutions."""
-    results: List[SingleReflexionResultSchema] = Field(..., description="List of individual conflict resolution results, grouped by conflict type.")
+    results: List[SingleReflexionResultSchema] = Field(...,
+                                                       description="List of individual conflict resolution results, grouped by conflict type.")
 
     @model_validator(mode="before")
     def _normalize_resolved(cls, v):
@@ -147,9 +152,9 @@ class ReflexionResultSchema(BaseModel):
 # Composite key identifying a config row
 class ConfigKey(BaseModel):  # 配置参数键模型
     model_config = ConfigDict(populate_by_name=True, extra="forbid")
-    config_id:Union[uuid.UUID, int, str] = Field(..., description="配置唯一标识（UUID或int)")
-    user_id: str = Field("user_id", description="用户标识（字符串）")
-    apply_id: str = Field("apply_id", description="应用或场景标识（字符串）")
+    config_id: Union[uuid.UUID, int, str] = Field(..., description="配置唯一标识（UUID或int)")
+    user_id: str | None = Field(default=None, description="用户标识（字符串）")
+    apply_id: str | None = Field(default=None, description="应用或场景标识（字符串）")
 
 
 # Allowed chunking strategies (extendable later)
@@ -241,10 +246,12 @@ class ConfigParamsCreate(BaseModel):  # 创建配置参数模型（仅 body，
     rerank_id: Optional[str] = Field(None, description="重排序模型配置ID")
     reflection_model_id: Optional[str] = Field(None, description="反思模型ID，默认与llm_id一致")
     emotion_model_id: Optional[str] = Field(None, description="情绪分析模型ID，默认与llm_id一致")
+
+
 class ConfigParamsDelete(BaseModel):  # 删除配置参数模型（请求体）
     model_config = ConfigDict(populate_by_name=True, extra="forbid")
     # config_name: str = Field("配置名称", description="配置名称（字符串）")
-    config_id:Union[uuid.UUID, int, str]  = Field(..., description="配置ID（支持UUID、整数或字符串）")
+    config_id: Union[uuid.UUID, int, str] = Field(..., description="配置ID（支持UUID、整数或字符串）")
 
 
 class ConfigUpdate(BaseModel):  # 更新记忆萃取引擎配置参数时使用的模型
@@ -255,7 +262,7 @@ class ConfigUpdate(BaseModel):  # 更新记忆萃取引擎配置参数时使用
 
 
 class ConfigUpdateExtracted(BaseModel):  # 更新记忆萃取引擎配置参数时使用的模型
-    config_id:Union[uuid.UUID, int, str]  = None
+    config_id: Union[uuid.UUID, int, str] = None
     llm_id: Optional[str] = Field(None, description="LLM模型配置ID")
     embedding_id: Optional[str] = Field(None, description="嵌入模型配置ID")
     rerank_id: Optional[str] = Field(None, description="重排序模型配置ID")
@@ -322,14 +329,14 @@ class ConfigUpdateExtracted(BaseModel):  # 更新记忆萃取引擎配置参数
 
 class ConfigUpdateForget(BaseModel):  # 更新遗忘引擎配置参数时使用的模型
     # 遗忘引擎配置参数更新模型
-    config_id:Union[uuid.UUID, int, str]  = None
+    config_id: Union[uuid.UUID, int, str] = None
     lambda_time: Optional[float] = Field(0.5, ge=0.0, le=1.0, description="最低保持度，0-1 小数；默认 0.5")
     lambda_mem: Optional[float] = Field(0.5, ge=0.0, le=1.0, description="遗忘率，0-1 小数；默认 0.5")
     offset: Optional[float] = Field(0.0, ge=0.0, le=1.0, description="偏移度，0-1 小数；默认 0.0")
 
 
 class ConfigPilotRun(BaseModel):  # 试运行触发请求模型
-    config_id:Union[uuid.UUID, int, str] = Field(..., description="配置ID（唯一，支持UUID、整数或字符串）")
+    config_id: Union[uuid.UUID, int, str] = Field(..., description="配置ID（唯一，支持UUID、整数或字符串）")
     dialogue_text: str = Field(..., description="前端传入的对话文本，格式如 '用户: ...\nAI: ...' 可多行，试运行必填")
     custom_text: Optional[str] = Field(None, description="自定义输入文本，当配置关联本体场景时使用此字段进行试运行")
     model_config = ConfigDict(populate_by_name=True, extra="forbid")
@@ -364,11 +371,11 @@ def ok(msg: str = "OK", data: Optional[Any] = None, time: Optional[int] = None)
 
 
 def fail(
-    msg: str,
-    error_code: str = "ERROR",
-    data: Optional[Any] = None,
-    time: Optional[int] = None,
-    query_preview: Optional[str] = None,
+        msg: str,
+        error_code: str = "ERROR",
+        data: Optional[Any] = None,
+        time: Optional[int] = None,
+        query_preview: Optional[str] = None,
 ) -> ApiResponse:
     payload = data
     if query_preview is not None:
@@ -387,6 +394,7 @@ def fail(
         time=time or _now_ms(),
     )
 
+
 class GenerateCacheRequest(BaseModel):
     """缓存生成请求模型"""
     model_config = ConfigDict(populate_by_name=True, extra="forbid")
@@ -432,7 +440,7 @@ class ForgettingConfigUpdateRequest(BaseModel):
     """遗忘引擎配置更新请求模型"""
     model_config = ConfigDict(populate_by_name=True, extra="forbid")
 
-    config_id: Union[uuid.UUID, int,str] = Field(..., description="配置唯一标识（UUID或int)")
+    config_id: Union[uuid.UUID, int, str] = Field(..., description="配置唯一标识（UUID或int)")
     decay_constant: Optional[float] = Field(None, ge=0.0, le=1.0, description="衰减常数 d")
     lambda_time: Optional[float] = Field(None, ge=0.0, le=1.0, description="时间衰减参数")
     lambda_mem: Optional[float] = Field(None, ge=0.0, le=1.0, description="记忆衰减参数")
@@ -472,7 +480,8 @@ class ForgettingStatsResponse(BaseModel):
     model_config = ConfigDict(populate_by_name=True, extra="forbid")
     activation_metrics: Dict[str, Any] = Field(..., description="激活值相关指标")
     node_distribution: Dict[str, int] = Field(..., description="节点类型分布")
-    recent_trends: List[ForgettingCycleHistoryPoint] = Field(..., description="最近7个日期的遗忘趋势数据（每天取最后一次执行）")
+    recent_trends: List[ForgettingCycleHistoryPoint] = Field(...,
+                                                             description="最近7个日期的遗忘趋势数据（每天取最后一次执行）")
     pending_nodes: List[PendingForgettingNode] = Field(..., description="待遗忘节点列表（前20个满足遗忘条件的节点）")
     timestamp: int = Field(..., description="统计时间（时间戳）")
 

api/app/services/memory_storage_service.py

@@ -11,9 +11,11 @@ import time
 from datetime import datetime
 from typing import Any, AsyncGenerator, Dict, List, Optional
 
+from dotenv import load_dotenv
+from sqlalchemy.orm import Session
+
 from app.core.logging_config import get_config_logger, get_logger
 from app.core.memory.analytics.hot_memory_tags import (
-    get_hot_memory_tags,
     get_raw_tags_from_db,
     filter_tags_with_llm,
 )
@@ -32,8 +34,6 @@ from app.schemas.memory_storage_schema import (
 )
 from app.services.memory_config_service import MemoryConfigService
 from app.utils.sse_utils import format_sse_message
-from dotenv import load_dotenv
-from sqlalchemy.orm import Session
 
 logger = get_logger(__name__)
 config_logger = get_config_logger()
@@ -69,7 +69,7 @@ class MemoryStorageService:
         return result
 
 
-class DataConfigService: # 数据配置服务类（PostgreSQL）
+class DataConfigService:  # 数据配置服务类（PostgreSQL）
     """Service layer for config params CRUD.
 
     使用 SQLAlchemy ORM 进行数据库操作。
@@ -114,7 +114,7 @@ class DataConfigService: # 数据配置服务类（PostgreSQL）
         return data_list
 
     # --- Create ---
-    def create(self, params: ConfigParamsCreate) -> Dict[str, Any]: # 创建配置参数（仅名称与描述）
+    def create(self, params: ConfigParamsCreate) -> Dict[str, Any]:  # 创建配置参数（仅名称与描述）
         # 业务层检查同一工作空间下是否已存在同名配置
         if params.workspace_id and params.config_name:
             from app.models.memory_config_model import MemoryConfig
@@ -183,20 +183,20 @@ class DataConfigService: # 数据配置服务类（PostgreSQL）
             return None
 
     # --- Delete ---
-    def delete(self, key: ConfigParamsDelete) -> Dict[str, Any]: # 删除配置参数（按配置ID）
+    def delete(self, key: ConfigParamsDelete) -> Dict[str, Any]:  # 删除配置参数（按配置ID）
         success = MemoryConfigRepository.delete(self.db, key.config_id)
         if not success:
             raise ValueError("未找到配置")
         return {"affected": 1}
 
     # --- Update ---
-    def update(self, update: ConfigUpdate) -> Dict[str, Any]: # 部分更新配置参数
+    def update(self, update: ConfigUpdate) -> Dict[str, Any]:  # 部分更新配置参数
         config = MemoryConfigRepository.update(self.db, update)
         if not config:
             raise ValueError("未找到配置")
         return {"affected": 1}
 
-    def update_extracted(self, update: ConfigUpdateExtracted) -> Dict[str, Any]: # 更新记忆萃取引擎配置参数
+    def update_extracted(self, update: ConfigUpdateExtracted) -> Dict[str, Any]:  # 更新记忆萃取引擎配置参数
         config = MemoryConfigRepository.update_extracted(self.db, update)
         if not config:
             raise ValueError("未找到配置")
@@ -207,14 +207,14 @@ class DataConfigService: # 数据配置服务类（PostgreSQL）
     # 使用新方法: MemoryForgetService.read_forgetting_config() 和 MemoryForgetService.update_forgetting_config()
 
     # --- Read ---
-    def get_extracted(self, key: ConfigKey) -> Dict[str, Any]: # 获取萃取配置参数
+    def get_extracted(self, key: ConfigKey) -> Dict[str, Any]:  # 获取萃取配置参数
         result = MemoryConfigRepository.get_extracted_config(self.db, key.config_id)
         if not result:
             raise ValueError("未找到配置")
         return result
 
     # --- Read All ---
-    def get_all(self, workspace_id = None) -> List[Dict[str, Any]]: # 获取所有配置参数
+    def get_all(self, workspace_id=None) -> List[Dict[str, Any]]:  # 获取所有配置参数
         results = MemoryConfigRepository.get_all(self.db, workspace_id)
 
         # 检查并修正 pruning_scene 与 scene_name 不一致的记录
@@ -241,11 +241,10 @@ class DataConfigService: # 数据配置服务类（PostgreSQL）
                 except (ValueError, TypeError):
                     config_id_old = None
 
-
             if config_id_old:
-                memory_config=config_id_old
+                memory_config = config_id_old
             else:
-                memory_config=config.config_id
+                memory_config = config.config_id
             config_dict = {
                 "config_id": memory_config,
                 "config_name": config.config_name,
@@ -289,7 +288,6 @@ class DataConfigService: # 数据配置服务类（PostgreSQL）
         # 将 created_at 和 updated_at 转换为 YYYYMMDDHHmmss 格式
         return self._convert_timestamps_to_format(data_list)
 
-
     async def pilot_run_stream(self, payload: ConfigPilotRun, language: str = "zh") -> AsyncGenerator[str, None]:
         """
         流式执行试运行，产生 SSE 格式的进度事件
@@ -344,11 +342,13 @@ class DataConfigService: # 数据配置服务类（PostgreSQL）
                 # 关联了本体场景，优先使用 custom_text
                 if hasattr(payload, 'custom_text') and payload.custom_text:
                     dialogue_text = payload.custom_text.strip()
-                    logger.info(f"[PILOT_RUN_STREAM] Using custom_text for scene_id={memory_config.scene_id}, length: {len(dialogue_text)}")
+                    logger.info(
+                        f"[PILOT_RUN_STREAM] Using custom_text for scene_id={memory_config.scene_id}, length: {len(dialogue_text)}")
                 else:
                     # 如果没有提供 custom_text，回退到 dialogue_text
                     dialogue_text = payload.dialogue_text.strip() if payload.dialogue_text else ""
-                    logger.info(f"[PILOT_RUN_STREAM] No custom_text provided, using dialogue_text for scene_id={memory_config.scene_id}")
+                    logger.info(
+                        f"[PILOT_RUN_STREAM] No custom_text provided, using dialogue_text for scene_id={memory_config.scene_id}")
             else:
                 # 没有关联本体场景，使用 dialogue_text
                 dialogue_text = payload.dialogue_text.strip() if payload.dialogue_text else ""
@@ -360,7 +360,6 @@ class DataConfigService: # 数据配置服务类（PostgreSQL）
 
             logger.info(f"[PILOT_RUN_STREAM] Final text preview: {dialogue_text[:100]}")
 
-
             # 步骤 2: 创建进度回调函数捕获管线进度
             # 使用队列在回调和生成器之间传递进度事件
             progress_queue: asyncio.Queue = asyncio.Queue()
@@ -382,7 +381,8 @@ class DataConfigService: # 数据配置服务类（PostgreSQL）
                 try:
                     from app.services.pilot_run_service import run_pilot_extraction
 
-                    logger.info(f"[PILOT_RUN_STREAM] Calling run_pilot_extraction with dialogue_text length: {len(dialogue_text)}")
+                    logger.info(
+                        f"[PILOT_RUN_STREAM] Calling run_pilot_extraction with dialogue_text length: {len(dialogue_text)}")
                     await run_pilot_extraction(
                         memory_config=memory_config,
                         dialogue_text=dialogue_text,
@@ -483,11 +483,10 @@ class DataConfigService: # 数据配置服务类（PostgreSQL）
                 "time": int(time.time() * 1000)
             })
 
-
     async def _compute_ontology_coverage(
-        self,
-        extracted_result: Dict[str, Any],
-        memory_config,
+            self,
+            extracted_result: Dict[str, Any],
+            memory_config,
     ) -> Optional[Dict[str, Any]]:
         """根据提取结果中的实体类型，与场景/通用本体类型做互斥分类统计。
 
@@ -580,8 +579,6 @@ class DataConfigService: # 数据配置服务类（PostgreSQL）
 
 # -------------------- Neo4j Search & Analytics (fused from data_search_service.py) --------------------
 # Ensure env for connector (e.g., NEO4J_PASSWORD)
-load_dotenv()
-_neo4j_connector = Neo4jConnector()
 
 
 async def search_dialogue(end_user_id: Optional[str] = None) -> Dict[str, Any]:
@@ -701,10 +698,11 @@ async def search_edges(end_user_id: Optional[str] = None) -> List[Dict[str, Any]
     )
     return result
 
+
 async def analytics_hot_memory_tags(
-    db: Session, 
-    current_user: User,
-    limit: int = 10
+        db: Session,
+        current_user: User,
+        limit: int = 10
 ) -> List[Dict[str, Any]]:
     """
     获取热门记忆标签，按数量排序并返回前N个
@@ -815,11 +813,11 @@ async def analytics_recent_activity_stats(workspace_id: Optional[str] = None) ->
         source = "log"
 
     total = (
-        stats.get("chunk_count", 0)
-        + stats.get("statements_count", 0)
-        + stats.get("triplet_entities_count", 0)
-        + stats.get("triplet_relations_count", 0)
-        + stats.get("temporal_count", 0)
+            stats.get("chunk_count", 0)
+            + stats.get("statements_count", 0)
+            + stats.get("triplet_entities_count", 0)
+            + stats.get("triplet_relations_count", 0)
+            + stats.get("temporal_count", 0)
     )
 
     # 计算"最新一次活动多久前"（仅日志来源时有效）
@@ -845,5 +843,3 @@ async def analytics_recent_activity_stats(workspace_id: Optional[str] = None) ->
 
     data = {"total": total, "stats": stats, "latest_relative": latest_relative, "source": source}
     return data
-
-

api/app/tasks.py

@@ -1073,9 +1073,15 @@ def read_message_task(self, end_user_id: str, message: str, history: List[Dict[s
 
 
 @celery_app.task(name="app.core.memory.agent.write_message", bind=True)
-def write_message_task(self, end_user_id: str, message: list[dict], config_id: str | int, storage_type: str,
-                       user_rag_memory_id: str,
-                       language: str = "zh") -> Dict[str, Any]:
+def write_message_task(
+        self,
+        end_user_id: str,
+        message: list[dict],
+        config_id: str | int,
+        storage_type: str,
+        user_rag_memory_id: str,
+        language: str = "zh"
+) -> Dict[str, Any]:
     """Celery task to process a write message via MemoryAgentService.
     Args:
         end_user_id: Group ID for the memory agent (also used as end_user_id)
@@ -1105,14 +1111,11 @@ def write_message_task(self, end_user_id: str, message: list[dict], config_id: s
         try:
             with get_db_context() as db:
                 actual_config_id = resolve_config_id(config_id, db)
-            print(100 * '-')
-            print(actual_config_id)
-            print(100 * '-')
-            logger.info(
-                f"[CELERY WRITE] Converted config_id to UUID: {actual_config_id} (type: {type(actual_config_id).__name__})")
+            logger.info(f"[CELERY WRITE] Converted config_id to UUID: {actual_config_id} "
+                        f"(type: {type(actual_config_id).__name__})")
         except (ValueError, AttributeError) as e:
-            logger.error(
-                f"[CELERY WRITE] Invalid config_id format: {config_id} (type: {type(config_id).__name__}), error: {e}")
+            logger.error(f"[CELERY WRITE] Invalid config_id format: {config_id} "
+                         f"(type: {type(config_id).__name__}), error: {e}")
             return {
                 "status": "FAILURE",
                 "error": f"Invalid config_id format: {config_id} - {str(e)}",
@@ -1151,8 +1154,8 @@ def write_message_task(self, end_user_id: str, message: list[dict], config_id: s
         result = loop.run_until_complete(_run())
         elapsed_time = time.time() - start_time
 
-        logger.info(
-            f"[CELERY WRITE] Task completed successfully - elapsed_time={elapsed_time:.2f}s, task_id={self.request.id}")
+        logger.info(f"[CELERY WRITE] Task completed successfully "
+                    f"- elapsed_time={elapsed_time:.2f}s, task_id={self.request.id}")
 
         # 记录该用户最后一次 write_message 成功的时间，供时间轴筛选使用
         try:
@@ -1167,7 +1170,6 @@ def write_message_task(self, end_user_id: str, message: list[dict], config_id: s
                 )
         except Exception as _e:
             logger.warning(f"[CELERY WRITE] 写入 last_done 时间戳失败（不影响主流程）: {_e}")
-
         return {
             "status": "SUCCESS",
             "result": result,
@@ -2672,7 +2674,7 @@ def write_perceptual_memory(
     ignore_result=False,
     max_retries=0,
     acks_late=False,
-    time_limit=7200,   # 2小时硬超时
+    time_limit=7200,  # 2小时硬超时
     soft_time_limit=6900,
 )
 def init_community_clustering_for_users(self, end_user_ids: List[str]) -> Dict[str, Any]:
@@ -2749,7 +2751,8 @@ def init_community_clustering_for_users(self, end_user_ids: List[str]) -> Dict[s
                         llm_model_id=llm_model_id,
                     )
 
-                    logger.info(f"[CommunityCluster] 用户 {end_user_id} 有 {len(entities)} 个实体，开始全量聚类，llm_model_id={llm_model_id}")
+                    logger.info(
+                        f"[CommunityCluster] 用户 {end_user_id} 有 {len(entities)} 个实体，开始全量聚类，llm_model_id={llm_model_id}")
                     await engine.full_clustering(end_user_id)
                     initialized += 1
                     logger.info(f"[CommunityCluster] 用户 {end_user_id} 聚类完成")
@@ -2772,12 +2775,6 @@ def init_community_clustering_for_users(self, end_user_ids: List[str]) -> Dict[s
         }
 
     try:
-        try:
-            import nest_asyncio
-            nest_asyncio.apply()
-        except ImportError:
-            pass
-
         loop = set_asyncio_event_loop()
         result = loop.run_until_complete(_run())
         result["elapsed_time"] = time.time() - start_time