diff --git a/.gitignore b/.gitignore index 939ac091..b6c55867 100644 --- a/.gitignore +++ b/.gitignore @@ -20,8 +20,7 @@ examples/ .idea # Temporary outputs -app/core/memory/agent/.DS_Store -app/core/memory/src/utils/.DS_Store +**/.DS_Store time.log celerybeat-schedule.db search_results.json diff --git a/api/app/celery_app.py b/api/app/celery_app.py index 8e1b4d5d..d072a346 100644 --- a/api/app/celery_app.py +++ b/api/app/celery_app.py @@ -3,6 +3,7 @@ from datetime import timedelta from urllib.parse import quote from celery import Celery from app.core.config import settings +from app.core.memory.utils.config.definitions import reload_configuration_from_database # 创建 Celery 应用实例 # broker: 任务队列（使用 Redis DB 0） @@ -12,6 +13,7 @@ celery_app = Celery( broker=f"redis://:{quote(settings.REDIS_PASSWORD)}@{settings.REDIS_HOST}:{settings.REDIS_PORT}/{settings.CELERY_BROKER}", backend=f"redis://:{quote(settings.REDIS_PASSWORD)}@{settings.REDIS_HOST}:{settings.REDIS_PORT}/{settings.CELERY_BACKEND}", ) +reload_configuration_from_database(config_id=os.getenv("config_id"), force_reload=True) # 配置使用本地队列，避免与远程 worker 冲突 celery_app.conf.task_default_queue = 'localhost_test_wyl' diff --git a/api/app/controllers/api_key_controller.py b/api/app/controllers/api_key_controller.py index 3948115e..815d8c69 100644 --- a/api/app/controllers/api_key_controller.py +++ b/api/app/controllers/api_key_controller.py @@ -1,8 +1,12 @@ """API Key 管理接口 - 基于 JWT 认证""" +import uuid +from typing import Optional +from datetime import datetime + from fastapi import APIRouter, Depends, Query from sqlalchemy.orm import Session -import uuid +from app.core.error_codes import BizCode from app.db import get_db from app.dependencies import get_current_user, cur_workspace_access_guard from app.models.user_model import User @@ -10,142 +14,344 @@ from app.core.response_utils import success from app.schemas import api_key_schema from app.schemas.response_schema import ApiResponse from app.services.api_key_service import ApiKeyService -from app.core.logging_config import get_business_logger +from app.core.logging_config import get_api_logger +from app.core.exceptions import ( + BusinessException, +) router = APIRouter(prefix="/apikeys", tags=["API Keys"]) -logger = get_business_logger() +logger = get_api_logger() @router.post("", response_model=ApiResponse) @cur_workspace_access_guard() def create_api_key( - data: api_key_schema.ApiKeyCreate, - db: Session = Depends(get_db), - current_user: User = Depends(get_current_user) + data: api_key_schema.ApiKeyCreate, + db: Session = Depends(get_db), + current_user: User = Depends(get_current_user) ): - """创建 API Key - + """ + 创建 API Key + + - 支持三种类型：app/rag/memory - 创建后返回明文 API Key（仅此一次） - 支持设置权限范围、速率限制、配额等 """ - workspace_id = current_user.current_workspace_id - api_key_obj, api_key = ApiKeyService.create_api_key( - db, - workspace_id=workspace_id, - user_id=current_user.id, - data=data - ) - - # 返回包含明文 Key 的响应 - response_data = api_key_schema.ApiKeyResponse( - **api_key_obj.__dict__, - api_key=api_key - ) - - return success(data=response_data, msg="API Key 创建成功") + try: + workspace_id = current_user.current_workspace_id + + # 创建 API Key + api_key_obj, api_key = ApiKeyService.create_api_key( + db, + workspace_id=workspace_id, + user_id=current_user.id, + data=data + ) + + # 返回包含明文 Key 的响应 + response_data = api_key_schema.ApiKeyResponse( + **api_key_obj.__dict__, + api_key=api_key + ) + + return success(data=response_data, msg="API Key 创建成功") + except BusinessException: + raise + except Exception as e: + logger.error(f"未知错误: {str(e)}", extra={ + "workspace_id": str(current_user.current_workspace_id), + "user_id": str(current_user.id), + "operation": "create_api_key" + }, exc_info=True) + raise Exception(f"创建API Key失败：{str(e)}") @router.get("", response_model=ApiResponse) @cur_workspace_access_guard() def list_api_keys( - type: api_key_schema.ApiKeyType = Query(None), - is_active: bool = Query(None), - resource_id: uuid.UUID = Query(None), - page: int = Query(1, ge=1), - pagesize: int = Query(10, ge=1, le=100), - db: Session = Depends(get_db), - current_user: User = Depends(get_current_user) + type: api_key_schema.ApiKeyType = Query(None, description="按类型过滤"), + is_active: bool = Query(True, description="按状态过滤"), + resource_id: uuid.UUID = Query(None, description="按资源过滤"), + page: int = Query(1, ge=1, description="页码"), + pagesize: int = Query(10, ge=1, le=100, description="每页数量"), + db: Session = Depends(get_db), + current_user: User = Depends(get_current_user) ): - """列出 API Keys""" - workspace_id = current_user.current_workspace_id - query = api_key_schema.ApiKeyQuery( - type=type, - is_active=is_active, - resource_id=resource_id, - page=page, - pagesize=pagesize - ) - - result = ApiKeyService.list_api_keys(db, workspace_id, query) - return success(data=result) + """ + 列出 API Keys + + - 支持多维度过滤 + - 支持分页 + - 自动按创建时间倒序 + """ + try: + workspace_id = current_user.current_workspace_id + + query = api_key_schema.ApiKeyQuery( + type=type, + is_active=is_active, + resource_id=resource_id, + page=page, + pagesize=pagesize + ) + + result = ApiKeyService.list_api_keys(db, workspace_id, query) + + logger.info("API Keys 查询成功", extra={ + "workspace_id": str(workspace_id), + "user_id": str(current_user.id), + "page": page, + "pagesize": pagesize, + "total_count": result.get("total", 0) if isinstance(result, dict) else 0 + }) + + return success(data=result) + + except Exception as e: + logger.error(f"未知错误: {str(e)}", extra={ + "workspace_id": str(current_user.current_workspace_id), + "user_id": str(current_user.id), + "operation": "list_api_keys" + }, exc_info=True) + raise Exception(f"API Keys 查询失败：{str(e)}") @router.get("/{api_key_id}", response_model=ApiResponse) @cur_workspace_access_guard() def get_api_key( - api_key_id: uuid.UUID, - db: Session = Depends(get_db), - current_user: User = Depends(get_current_user) + api_key_id: uuid.UUID, + db: Session = Depends(get_db), + current_user: User = Depends(get_current_user) ): """获取 API Key 详情""" - workspace_id = current_user.current_workspace_id - api_key = ApiKeyService.get_api_key(db, api_key_id, workspace_id) - - return success(data=api_key_schema.ApiKey.model_validate(api_key)) + try: + workspace_id = current_user.current_workspace_id + api_key = ApiKeyService.get_api_key(db, api_key_id, workspace_id) + + logger.info("获取API Key详情成功", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(workspace_id), + "user_id": str(current_user.id), + "operation": "get_api_key" + }) + + return success(data=api_key_schema.ApiKey.model_validate(api_key)) + except Exception as e: + logger.error(f"未知错误: {str(e)}", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(current_user.current_workspace_id), + "user_id": str(current_user.id), + "operation": "get_api_key" + }, exc_info=True) + raise Exception(f"获取API Key失败: {str(e)}") @router.put("/{api_key_id}", response_model=ApiResponse) @cur_workspace_access_guard() def update_api_key( - api_key_id: uuid.UUID, - data: api_key_schema.ApiKeyUpdate, - db: Session = Depends(get_db), - current_user: User = Depends(get_current_user) + api_key_id: uuid.UUID, + data: api_key_schema.ApiKeyUpdate, + db: Session = Depends(get_db), + current_user: User = Depends(get_current_user) ): - """更新 API Key""" - workspace_id = current_user.current_workspace_id - api_key = ApiKeyService.update_api_key(db, api_key_id, workspace_id, data) - - return success(data=api_key_schema.ApiKey.model_validate(api_key), msg="API Key 更新成功") + """更新 API Key配置""" + try: + workspace_id = current_user.current_workspace_id + + api_key = ApiKeyService.update_api_key(db, api_key_id, workspace_id, data) + + logger.info("API Key 更新配置成功", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(workspace_id), + "user_id": str(current_user.id) + }) + + return success(data=api_key_schema.ApiKey.model_validate(api_key), msg="API Key 更新成功") + + except Exception as e: + logger.error(f"未知错误: {str(e)}", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(current_user.current_workspace_id), + "user_id": str(current_user.id), + "operation": "update_api_key" + }, exc_info=True) + raise Exception(f"更新API Key失败: {str(e)}") @router.delete("/{api_key_id}", response_model=ApiResponse) @cur_workspace_access_guard() def delete_api_key( - api_key_id: uuid.UUID, - db: Session = Depends(get_db), - current_user: User = Depends(get_current_user) + api_key_id: uuid.UUID, + db: Session = Depends(get_db), + current_user: User = Depends(get_current_user) ): """删除 API Key""" - workspace_id = current_user.current_workspace_id - ApiKeyService.delete_api_key(db, api_key_id, workspace_id) - - return success(msg="API Key 删除成功") + try: + workspace_id = current_user.current_workspace_id + ApiKeyService.delete_api_key(db, api_key_id, workspace_id) + + logger.info("API Key 删除成功", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(workspace_id), + "user_id": str(current_user.id) + }) + + return success(msg="API Key 删除成功") + + except Exception as e: + logger.error(f"未知错误: {str(e)}", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(current_user.current_workspace_id), + "user_id": str(current_user.id), + "operation": "delete_api_key" + }, exc_info=True) + raise Exception(f"删除API Key失败: {str(e)}") @router.post("/{api_key_id}/regenerate", response_model=ApiResponse) @cur_workspace_access_guard() def regenerate_api_key( - api_key_id: uuid.UUID, - db: Session = Depends(get_db), - current_user: User = Depends(get_current_user) + api_key_id: uuid.UUID, + db: Session = Depends(get_db), + current_user: User = Depends(get_current_user) ): - """重新生成 API Key + """ + 重新生成 API Key - 生成新的 API Key 并返回明文（仅此一次） - 旧的 API Key 立即失效 """ - workspace_id = current_user.current_workspace_id - api_key_obj, api_key = ApiKeyService.regenerate_api_key(db, api_key_id, workspace_id) - - # 返回包含明文 Key 的响应 - response_data = api_key_schema.ApiKeyResponse( - **api_key_obj.__dict__, - api_key=api_key - ) - - return success(data=response_data, msg="API Key 重新生成成功") + try: + workspace_id = current_user.current_workspace_id + api_key_obj, api_key = ApiKeyService.regenerate_api_key(db, api_key_id, workspace_id) + + # 返回包含明文 Key 的响应 + response_data = api_key_schema.ApiKeyResponse( + **api_key_obj.__dict__, + api_key=api_key + ) + + logger.info("API Key 重新生成成功", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(workspace_id), + "user_id": str(current_user.id) + }) + + return success(data=response_data, msg="API Key 重新生成成功") + except BusinessException: + raise + except Exception as e: + logger.error(f"未知错误: {str(e)}", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(current_user.current_workspace_id), + "user_id": str(current_user.id), + "operation": "regenerate_api_key" + }, exc_info=True) + raise Exception(f"重新生成API Key失败: {str(e)}") @router.get("/{api_key_id}/stats", response_model=ApiResponse) @cur_workspace_access_guard() def get_api_key_stats( - api_key_id: uuid.UUID, - db: Session = Depends(get_db), - current_user: User = Depends(get_current_user) + api_key_id: uuid.UUID, + db: Session = Depends(get_db), + current_user: User = Depends(get_current_user) ): """获取 API Key 使用统计""" - workspace_id = current_user.current_workspace_id - stats = ApiKeyService.get_stats(db, api_key_id, workspace_id) - - return success(data=stats) + try: + workspace_id = current_user.current_workspace_id + stats = ApiKeyService.get_stats(db, api_key_id, workspace_id) + + logger.info("API Key stats retrieved successfully", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(workspace_id), + "user_id": str(current_user.id) + }) + + return success(data=stats) + except Exception as e: + logger.error(f"未知错误: {str(e)}", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(current_user.current_workspace_id), + "user_id": str(current_user.id), + "operation": "get_api_key_stats" + }, exc_info=True) + raise Exception(f"获取API Key统计失败: {str(e)}") + + +@router.get("/{api_key_id}/logs", response_model=ApiResponse) +@cur_workspace_access_guard() +def get_api_key_logs( + api_key_id: uuid.UUID, + start_date: Optional[datetime] = Query(None, description="开始日期"), + end_date: Optional[datetime] = Query(None, description="结束日期"), + status_code: Optional[int] = Query(None, description="HTTP状态码过滤"), + endpoint: Optional[str] = Query(None, description="端点路径过滤"), + page: int = Query(1, ge=1, description="页码"), + pagesize: int = Query(10, ge=1, le=100, description="每页数量"), + db: Session = Depends(get_db), + current_user: User = Depends(get_current_user) +): + """ + 获取 API Key 使用日志 + + - 支持时间范围过滤 + - 支持状态码和端点过滤 + - 按时间倒序返回 + """ + try: + workspace_id = current_user.current_workspace_id + + # 验证日期范围 + if start_date and end_date and start_date > end_date: + logger.warning("开始日期晚于结束日期", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(workspace_id), + "user_id": str(current_user.id), + "start_date": start_date.isoformat(), + "end_date": end_date.isoformat() + }) + raise BusinessException("开始日期不能晚于结束日期", BizCode.INVALID_PARAMETER) + + # 验证状态码 + if status_code and (status_code < 100 or status_code > 599): + logger.warning("查询无效的状态码", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(workspace_id), + "user_id": str(current_user.id), + "status_code": status_code + }) + raise BusinessException("无效的HTTP状态码", BizCode.INVALID_PARAMETER) + + # 构建过滤条件 + filters = { + "start_date": start_date, + "end_date": end_date, + "status_code": status_code, + "endpoint": endpoint + } + + # 调用服务层获取日志 + result = ApiKeyService.get_logs( + db, api_key_id, workspace_id, filters, page, pagesize + ) + + logger.info("API Key 日志查询成功", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(workspace_id), + "user_id": str(current_user.id), + "page": page, + "pagesize": pagesize, + "filters": {k: str(v) if v else None for k, v in filters.items()} + }) + + return success(data=result) + + except Exception as e: + logger.error(f"未知错误: {str(e)}", extra={ + "api_key_id": str(api_key_id), + "workspace_id": str(current_user.current_workspace_id), + "user_id": str(current_user.id), + "operation": "get_api_key_logs" + }, exc_info=True) + raise Exception(f"API Key 日志查询失败: {str(e)}") diff --git a/api/app/controllers/app_controller.py b/api/app/controllers/app_controller.py index 90783647..8177916e 100644 --- a/api/app/controllers/app_controller.py +++ b/api/app/controllers/app_controller.py @@ -121,7 +121,7 @@ def delete_app( """ workspace_id = current_user.current_workspace_id logger.info( - f"用户请求删除应用", + "用户请求删除应用", extra={ "app_id": str(app_id), "user_id": str(current_user.id), @@ -151,7 +151,7 @@ def copy_app( """ workspace_id = current_user.current_workspace_id logger.info( - f"用户请求复制应用", + "用户请求复制应用", extra={ "source_app_id": str(app_id), "user_id": str(current_user.id), @@ -432,7 +432,7 @@ async def draft_run( # 非流式返回 logger.debug( - f"开始非流式试运行", + "开始非流式试运行", extra={ "app_id": str(app_id), "message_length": len(payload.message), @@ -456,7 +456,7 @@ async def draft_run( ) logger.debug( - f"试运行返回结果", + "试运行返回结果", extra={ "result_type": str(type(result)), "result_keys": list(result.keys()) if isinstance(result, dict) else "not_dict" @@ -466,11 +466,11 @@ async def draft_run( # 验证结果 try: validated_result = app_schema.DraftRunResponse.model_validate(result) - logger.debug(f"结果验证成功") + logger.debug("结果验证成功") return success(data=validated_result) except Exception as e: logger.error( - f"结果验证失败", + "结果验证失败", extra={ "error": str(e), "error_type": str(type(e)), @@ -496,7 +496,7 @@ async def draft_run( # 3. 流式返回 if payload.stream: logger.debug( - f"开始多智能体流式试运行", + "开始多智能体流式试运行", extra={ "app_id": str(app_id), "message_length": len(payload.message), @@ -530,7 +530,7 @@ async def draft_run( # 4. 非流式返回 logger.debug( - f"开始多智能体非流式试运行", + "开始多智能体非流式试运行", extra={ "app_id": str(app_id), "message_length": len(payload.message), @@ -542,7 +542,7 @@ async def draft_run( result = await multiservice.run(app_id, multi_agent_request) logger.debug( - f"多智能体试运行返回结果", + "多智能体试运行返回结果", extra={ "result_type": str(type(result)), "has_response": "response" in result if isinstance(result, dict) else False @@ -599,7 +599,7 @@ async def draft_run_compare( if knowledge: user_rag_memory_id = str(knowledge.id) logger.info( - f"多模型对比试运行", + "多模型对比试运行", extra={ "app_id": str(app_id), "model_count": len(payload.models), @@ -705,7 +705,7 @@ async def draft_run_compare( ) logger.info( - f"多模型对比完成", + "多模型对比完成", extra={ "app_id": str(app_id), "successful": result["successful_count"], diff --git a/api/app/controllers/chunk_controller.py b/api/app/controllers/chunk_controller.py index 9942eed0..162c8e57 100644 --- a/api/app/controllers/chunk_controller.py +++ b/api/app/controllers/chunk_controller.py @@ -178,7 +178,7 @@ async def get_chunks( # 3. Execute paged query try: - api_logger.debug(f"Start executing document chunk query") + api_logger.debug("Start executing document chunk query") vector_service = ElasticSearchVectorFactory().init_vector(knowledge=db_knowledge) total, items = vector_service.search_by_segment(document_id=str(document_id), query=keywords, pagesize=pagesize, page=page, asc=True) api_logger.info(f"Document chunk query successful: total={total}, returned={len(items)} records") @@ -213,7 +213,9 @@ async def create_chunk( """ create chunk """ - api_logger.info(f"Create chunk request: kb_id={kb_id}, document_id={document_id}, content={create_data.content}, username: {current_user.username}") + # Obtain the actual content + content = create_data.chunk_content + api_logger.info(f"Create chunk request: kb_id={kb_id}, document_id={document_id}, content={content}, username: {current_user.username}") # 1. Obtain knowledge base information db_knowledge = knowledge_service.get_knowledge_by_id(db, knowledge_id=kb_id, current_user=current_user) @@ -250,7 +252,7 @@ async def create_chunk( "sort_id": sort_id, "status": 1, } - chunk = DocumentChunk(page_content=create_data.content, metadata=metadata) + chunk = DocumentChunk(page_content=content, metadata=metadata) # 3. Segmented vector storage vector_service.add_chunks([chunk]) @@ -305,7 +307,9 @@ async def update_chunk( """ Update document chunk content """ - api_logger.info(f"Update document chunk content: kb_id={kb_id}, document_id={document_id}, doc_id={doc_id}, content={update_data.content}, username: {current_user.username}") + # Obtain the actual content + content = update_data.chunk_content + api_logger.info(f"Update document chunk content: kb_id={kb_id}, document_id={document_id}, doc_id={doc_id}, content={content}, username: {current_user.username}") db_knowledge = knowledge_service.get_knowledge_by_id(db, knowledge_id=kb_id, current_user=current_user) if not db_knowledge: @@ -318,7 +322,7 @@ async def update_chunk( total, items = vector_service.get_by_segment(doc_id=doc_id) if total: chunk = items[0] - chunk.page_content = update_data.content + chunk.page_content = content vector_service.update_by_segment(chunk) return success(data=chunk, msg="The document chunk has been successfully updated") else: diff --git a/api/app/controllers/document_controller.py b/api/app/controllers/document_controller.py index 651e700d..b6c688b2 100644 --- a/api/app/controllers/document_controller.py +++ b/api/app/controllers/document_controller.py @@ -78,7 +78,7 @@ async def get_documents( # 3. Execute paged query try: - api_logger.debug(f"Start executing document paging query") + api_logger.debug("Start executing document paging query") total, items = document_service.get_documents_paginated( db=db, filters=filters, diff --git a/api/app/controllers/file_controller.py b/api/app/controllers/file_controller.py index 57a99118..5bc2fd79 100644 --- a/api/app/controllers/file_controller.py +++ b/api/app/controllers/file_controller.py @@ -66,7 +66,7 @@ async def get_files( # 3. Execute paged query try: - api_logger.debug(f"Start executing file paging query") + api_logger.debug("Start executing file paging query") total, items = file_service.get_files_paginated( db=db, filters=filters, diff --git a/api/app/controllers/knowledge_controller.py b/api/app/controllers/knowledge_controller.py index 892dcc39..cac7f478 100644 --- a/api/app/controllers/knowledge_controller.py +++ b/api/app/controllers/knowledge_controller.py @@ -74,8 +74,6 @@ async def get_knowledges( filters = [ knowledge_model.Knowledge.workspace_id == current_user.current_workspace_id ] - if parent_id: - filters.append(knowledge_model.Knowledge.parent_id == parent_id) # Keyword search (fuzzy matching of knowledge base name) if keywords: @@ -91,9 +89,14 @@ async def get_knowledges( filters.append(knowledge_model.Knowledge.id.in_(kb_ids.split(','))) else: filters.append(knowledge_model.Knowledge.status != 2) + if parent_id: + filters.append(knowledge_model.Knowledge.parent_id == parent_id) + else: + filters.append(knowledge_model.Knowledge.parent_id == current_user.current_workspace_id) + filters.append(knowledge_model.Knowledge.permission_id != knowledge_model.PermissionType.Memory) # 3. Execute paged query try: - api_logger.debug(f"Start executing knowledge base paging query") + api_logger.debug("Start executing knowledge base paging query") total, items = knowledge_service.get_knowledges_paginated( db=db, filters=filters, diff --git a/api/app/controllers/knowledgeshare_controller.py b/api/app/controllers/knowledgeshare_controller.py index 8a1b5bb7..ba7a4fe4 100644 --- a/api/app/controllers/knowledgeshare_controller.py +++ b/api/app/controllers/knowledgeshare_controller.py @@ -58,7 +58,7 @@ async def get_knowledgeshares( # 3. Execute paged query try: - api_logger.debug(f"Start executing knowledge base sharing and paging query") + api_logger.debug("Start executing knowledge base sharing and paging query") total, items = knowledgeshare_service.get_knowledgeshares_paginated( db=db, filters=filters, diff --git a/api/app/controllers/memory_agent_controller.py b/api/app/controllers/memory_agent_controller.py index 419de257..7eb37c1c 100644 --- a/api/app/controllers/memory_agent_controller.py +++ b/api/app/controllers/memory_agent_controller.py @@ -54,7 +54,7 @@ def validate_config_id(config_id: int, db: Session) -> int: ValueError: If config_id is None, invalid, or doesn't exist in database """ if config_id is None: - api_logger.info(f"config_id is required but was not provided") + 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") @@ -257,7 +257,7 @@ async def write_server( api_logger.warning(f"未找到名为 'USER_RAG_MERORY' 的知识库，workspace_id: {workspace_id}，将使用 neo4j 存储") storage_type = 'neo4j' else: - api_logger.warning(f"workspace_id 为空，无法使用 rag 存储，将使用 neo4j 存储") + api_logger.warning("workspace_id 为空，无法使用 rag 存储，将使用 neo4j 存储") storage_type = 'neo4j' api_logger.info(f"Write service requested for group {user_input.group_id}, storage_type: {storage_type}, user_rag_memory_id: {user_rag_memory_id}") diff --git a/api/app/controllers/memory_dashboard_controller.py b/api/app/controllers/memory_dashboard_controller.py index e915a7a8..4a01c575 100644 --- a/api/app/controllers/memory_dashboard_controller.py +++ b/api/app/controllers/memory_dashboard_controller.py @@ -2,11 +2,13 @@ from fastapi import APIRouter, Depends, HTTPException, status, Query from sqlalchemy.orm import Session from typing import List, Optional import uuid - +from app.repositories.end_user_repository import update_end_user_other_name +import uuid from app.core.response_utils import success from app.db import get_db from app.dependencies import get_current_user from app.models.user_model import User +from app.schemas.memory_agent_schema import End_User_Information from app.schemas.response_schema import ApiResponse from app.schemas.app_schema import App as AppSchema @@ -41,6 +43,56 @@ def get_workspace_total_end_users( api_logger.info(f"成功获取最新用户总数: total_num={total_end_users.get('total_num', 0)}") return success(data=total_end_users, msg="用户数量获取成功") +@router.post("/update/end_users", response_model=ApiResponse) +async def update_workspace_end_users( + user_input: End_User_Information, + db: Session = Depends(get_db), + current_user: User = Depends(get_current_user), +): + """ + 更新工作空间的宿主信息 + """ + username = user_input.end_user_name # 要更新的用户名 + end_user_input_id = user_input.id # 宿主ID + workspace_id = current_user.current_workspace_id + + api_logger.info(f"用户 {current_user.username} 请求更新工作空间 {workspace_id} 的宿主信息") + api_logger.info(f"更新参数: username={username}, end_user_id={end_user_input_id}") + + try: + # 导入更新函数 + from app.repositories.end_user_repository import update_end_user_other_name + import uuid + + # 转换 end_user_id 为 UUID 类型 + end_user_uuid = uuid.UUID(end_user_input_id) + + # 直接更新数据库中的 other_name 字段 + updated_count = update_end_user_other_name( + db=db, + end_user_id=end_user_uuid, + other_name=username + ) + + api_logger.info(f"成功更新宿主 {end_user_input_id} 的 other_name 为: {username}") + + return success( + data={ + "updated_count": updated_count, + "end_user_id": end_user_input_id, + "updated_other_name": username + }, + msg=f"成功更新 {updated_count} 个宿主的信息" + ) + + except Exception as e: + api_logger.error(f"更新宿主信息失败: {str(e)}") + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"更新宿主信息失败: {str(e)}" + ) + + @router.get("/end_users", response_model=ApiResponse) async def get_workspace_end_users( @@ -53,6 +105,8 @@ async def get_workspace_end_users( 返回格式与原 memory_list 接口中的 end_users 字段相同 """ workspace_id = current_user.current_workspace_id + # 获取当前空间类型 + current_workspace_type = memory_dashboard_service.get_current_workspace_type(db, workspace_id, current_user) api_logger.info(f"用户 {current_user.username} 请求获取工作空间 {workspace_id} 的宿主列表") end_users = memory_dashboard_service.get_workspace_end_users( db=db, @@ -61,14 +115,21 @@ async def get_workspace_end_users( ) result = [] for end_user in end_users: - # EndUser 是 Pydantic 模型，直接访问属性而不是使用 .get() - memory_num = await memory_storage_service.search_all(str(end_user.id)) + memory_num = {} + if current_workspace_type == "neo4j": + # EndUser 是 Pydantic 模型，直接访问属性而不是使用 .get() + memory_num = await memory_storage_service.search_all(str(end_user.id)) + elif current_workspace_type == "rag": + memory_num = { + "total":memory_dashboard_service.get_current_user_total_chunk(str(end_user.id), db, current_user) + } result.append( { 'end_user':end_user, 'memory_num':memory_num } ) + api_logger.info(f"成功获取 {len(end_users)} 个宿主记录") return success(data=result, msg="宿主列表获取成功") @@ -203,7 +264,7 @@ def get_workspace_memory_list( current_user=current_user, limit=limit ) - api_logger.info(f"成功获取记忆列表") + api_logger.info("成功获取记忆列表") return success(data=memory_list, msg="记忆列表获取成功") @@ -354,7 +415,7 @@ async def get_chunk_insight( current_user=current_user ) - api_logger.info(f"成功获取chunk洞察") + api_logger.info("成功获取chunk洞察") return success(data=data, msg="chunk洞察获取成功") @@ -469,7 +530,7 @@ async def dashboard_data( api_logger.warning(f"获取API调用增量失败: {str(e)}") result["neo4j_data"] = neo4j_data - api_logger.info(f"成功获取neo4j_data") + api_logger.info("成功获取neo4j_data") # 如果 storage_type 为 'rag'，获取 rag_data elif storage_type == 'rag': @@ -503,9 +564,9 @@ async def dashboard_data( api_logger.warning(f"获取RAG相关数据失败: {str(e)}") result["rag_data"] = rag_data - api_logger.info(f"成功获取rag_data") + api_logger.info("成功获取rag_data") - api_logger.info(f"成功获取dashboard整合数据") + api_logger.info("成功获取dashboard整合数据") return success(data=result, msg="Dashboard数据获取成功") except Exception as e: diff --git a/api/app/controllers/memory_storage_controller.py b/api/app/controllers/memory_storage_controller.py index 6d1a901b..c1fe573e 100644 --- a/api/app/controllers/memory_storage_controller.py +++ b/api/app/controllers/memory_storage_controller.py @@ -1,8 +1,11 @@ from typing import Optional import os import uuid -from fastapi import APIRouter, Depends +from sqlalchemy.orm import Session +from fastapi import APIRouter, Depends, Query, UploadFile + +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 @@ -62,7 +65,7 @@ async def get_storage_info( Returns: Storage information """ - api_logger.info(f"Storage info requested ") + api_logger.info("Storage info requested ") try: result = await memory_storage_service.get_storage_info() return success(data=result) @@ -139,6 +142,7 @@ def reset_db_conn() -> bool: # 重置 PostgreSQL 数据库连接 def create_config( payload: ConfigParamsCreate, current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), ) -> dict: workspace_id = current_user.current_workspace_id @@ -151,7 +155,7 @@ def create_config( try: # 将 workspace_id 注入到 payload 中（保持为 UUID 类型） payload.workspace_id = workspace_id - svc = DataConfigService(get_db_conn()) + svc = DataConfigService(db) result = svc.create(payload) return success(data=result, msg="创建成功") except Exception as e: @@ -163,6 +167,7 @@ def create_config( def delete_config( config_id: str, current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), ) -> dict: workspace_id = current_user.current_workspace_id @@ -173,7 +178,7 @@ def delete_config( api_logger.info(f"用户 {current_user.username} 在工作空间 {workspace_id} 请求删除配置: {config_id}") try: - svc = DataConfigService(get_db_conn()) + svc = DataConfigService(db) result = svc.delete(ConfigParamsDelete(config_id=config_id)) return success(data=result, msg="删除成功") except Exception as e: @@ -184,6 +189,7 @@ def delete_config( def update_config( payload: ConfigUpdate, current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), ) -> dict: workspace_id = current_user.current_workspace_id @@ -194,7 +200,7 @@ def update_config( api_logger.info(f"用户 {current_user.username} 在工作空间 {workspace_id} 请求更新配置: {payload.config_id}") try: - svc = DataConfigService(get_db_conn()) + svc = DataConfigService(db) result = svc.update(payload) return success(data=result, msg="更新成功") except Exception as e: @@ -206,6 +212,7 @@ def update_config( def update_config_extracted( payload: ConfigUpdateExtracted, current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), ) -> dict: workspace_id = current_user.current_workspace_id @@ -216,7 +223,7 @@ def update_config_extracted( api_logger.info(f"用户 {current_user.username} 在工作空间 {workspace_id} 请求更新提取配置: {payload.config_id}") try: - svc = DataConfigService(get_db_conn()) + svc = DataConfigService(db) result = svc.update_extracted(payload) return success(data=result, msg="更新成功") except Exception as e: @@ -229,6 +236,7 @@ def update_config_extracted( def update_config_forget( payload: ConfigUpdateForget, current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), ) -> dict: workspace_id = current_user.current_workspace_id @@ -239,7 +247,7 @@ def update_config_forget( api_logger.info(f"用户 {current_user.username} 在工作空间 {workspace_id} 请求更新遗忘引擎配置: {payload.config_id}") try: - svc = DataConfigService(get_db_conn()) + svc = DataConfigService(db) result = svc.update_forget(payload) return success(data=result, msg="更新成功") except Exception as e: @@ -251,6 +259,7 @@ def update_config_forget( def read_config_extracted( config_id: str, current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), ) -> dict: workspace_id = current_user.current_workspace_id @@ -261,7 +270,7 @@ def read_config_extracted( api_logger.info(f"用户 {current_user.username} 在工作空间 {workspace_id} 请求读取提取配置: {config_id}") try: - svc = DataConfigService(get_db_conn()) + svc = DataConfigService(db) result = svc.get_extracted(ConfigKey(config_id=config_id)) return success(data=result, msg="查询成功") except Exception as e: @@ -272,6 +281,7 @@ def read_config_extracted( def read_config_forget( config_id: str, current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), ) -> dict: workspace_id = current_user.current_workspace_id @@ -282,7 +292,7 @@ def read_config_forget( api_logger.info(f"用户 {current_user.username} 在工作空间 {workspace_id} 请求读取遗忘引擎配置: {config_id}") try: - svc = DataConfigService(get_db_conn()) + svc = DataConfigService(db) result = svc.get_forget(ConfigKey(config_id=config_id)) return success(data=result, msg="查询成功") except Exception as e: @@ -292,6 +302,7 @@ def read_config_forget( @router.get("/read_all_config", response_model=ApiResponse) # 读取所有配置文件列表 def read_all_config( current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), ) -> dict: workspace_id = current_user.current_workspace_id @@ -302,7 +313,7 @@ def read_all_config( api_logger.info(f"用户 {current_user.username} 在工作空间 {workspace_id} 请求读取所有配置") try: - svc = DataConfigService(get_db_conn()) + svc = DataConfigService(db) # 传递 workspace_id 进行过滤（保持为 UUID 类型） result = svc.get_all(workspace_id=workspace_id) return success(data=result, msg="查询成功") @@ -315,6 +326,7 @@ def read_all_config( async def pilot_run( payload: ConfigPilotRun, current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), ) -> dict: api_logger.info(f"Pilot run requested: config_id={payload.config_id}, dialogue_text_length={len(payload.dialogue_text)}") @@ -330,7 +342,7 @@ async def pilot_run( return fail(BizCode.INTERNAL_ERROR, "配置加载异常", str(e)) try: - svc = DataConfigService(get_db_conn()) + svc = DataConfigService(db) result = await svc.pilot_run(payload) return success(data=result, msg="试运行完成") except ValueError as e: @@ -475,13 +487,13 @@ async def search_for_entity_graph( @router.get("/analytics/hot_memory_tags", response_model=ApiResponse) async def get_hot_memory_tags_api( - end_user_id: Optional[str] = None, limit: int = 10, + db: Session = Depends(get_db), current_user: User = Depends(get_current_user), ) -> dict: - api_logger.info(f"Hot memory tags requested for end_user_id: {end_user_id}") + api_logger.info(f"Hot memory tags requested for current_user: {current_user.id}") try: - result = await analytics_hot_memory_tags(end_user_id, limit) + result = await analytics_hot_memory_tags(db, current_user, limit) return success(data=result, msg="查询成功") except Exception as e: api_logger.error(f"Hot memory tags failed: {str(e)}") diff --git a/api/app/controllers/model_controller.py b/api/app/controllers/model_controller.py index 0c32c225..890dd50b 100644 --- a/api/app/controllers/model_controller.py +++ b/api/app/controllers/model_controller.py @@ -46,7 +46,8 @@ def get_model_list( search: Optional[str] = Query(None, description="搜索关键词"), page: int = Query(1, ge=1, description="页码"), pagesize: int = Query(10, ge=1, le=100, description="每页数量"), - db: Session = Depends(get_db) + db: Session = Depends(get_db), + current_user: User = Depends(get_current_user) ): """ 获取模型配置列表 @@ -55,7 +56,7 @@ def get_model_list( - 单个：?type=LLM - 多个：?type=LLM&type=EMBEDDING """ - api_logger.info(f"获取模型配置列表请求: type={type}, provider={provider}, page={page}, pagesize={pagesize}") + api_logger.info(f"获取模型配置列表请求: type={type}, provider={provider}, page={page}, pagesize={pagesize}, tenant_id={current_user.tenant_id}") try: query = model_schema.ModelConfigQuery( @@ -69,7 +70,7 @@ def get_model_list( ) api_logger.debug(f"开始获取模型配置列表: {query.dict()}") - result_orm = ModelConfigService.get_model_list(db=db, query=query) + result_orm = ModelConfigService.get_model_list(db=db, query=query, tenant_id=current_user.tenant_id) result = PageData.model_validate(result_orm) api_logger.info(f"模型配置列表获取成功: 总数={result.page.total}, 当前页={len(result.items)}") return success(data=result, msg="模型配置列表获取成功") @@ -81,16 +82,17 @@ def get_model_list( @router.get("/{model_id}", response_model=ApiResponse) def get_model_by_id( model_id: uuid.UUID, - db: Session = Depends(get_db) + db: Session = Depends(get_db), + current_user: User = Depends(get_current_user) ): """ 根据ID获取模型配置 """ - api_logger.info(f"获取模型配置请求: model_id={model_id}") + api_logger.info(f"获取模型配置请求: model_id={model_id}, tenant_id={current_user.tenant_id}") try: api_logger.debug(f"开始获取模型配置: model_id={model_id}") - result_orm = ModelConfigService.get_model_by_id(db=db, model_id=model_id) + result_orm = ModelConfigService.get_model_by_id(db=db, model_id=model_id, tenant_id=current_user.tenant_id) api_logger.info(f"模型配置获取成功: {result_orm.name}") # 将ORM对象转换为Pydantic模型 @@ -116,11 +118,11 @@ async def create_model( - 验证失败时会抛出异常，不会创建配置 - 可通过 skip_validation=true 跳过验证 """ - api_logger.info(f"创建模型配置请求: {model_data.name}, 用户: {current_user.username}") + api_logger.info(f"创建模型配置请求: {model_data.name}, 用户: {current_user.username}, tenant_id={current_user.tenant_id}") try: api_logger.debug(f"开始创建模型配置: {model_data.name}") - result_orm = await ModelConfigService.create_model(db=db, model_data=model_data) + result_orm = await ModelConfigService.create_model(db=db, model_data=model_data, tenant_id=current_user.tenant_id) api_logger.info(f"模型配置创建成功: {result_orm.name} (ID: {result_orm.id})") # 将ORM对象转换为Pydantic模型 @@ -142,11 +144,11 @@ def update_model( """ 更新模型配置 """ - api_logger.info(f"更新模型配置请求: model_id={model_id}, 用户: {current_user.username}") + api_logger.info(f"更新模型配置请求: model_id={model_id}, 用户: {current_user.username}, tenant_id={current_user.tenant_id}") try: api_logger.debug(f"开始更新模型配置: model_id={model_id}") - result_orm = ModelConfigService.update_model(db=db, model_id=model_id, model_data=model_data) + result_orm = ModelConfigService.update_model(db=db, model_id=model_id, model_data=model_data, tenant_id=current_user.tenant_id) api_logger.info(f"模型配置更新成功: {result_orm.name} (ID: {model_id})") # 将ORM对象转换为Pydantic模型 @@ -167,11 +169,11 @@ def delete_model( """ 删除模型配置 """ - api_logger.info(f"删除模型配置请求: model_id={model_id}, 用户: {current_user.username}") + api_logger.info(f"删除模型配置请求: model_id={model_id}, 用户: {current_user.username}, tenant_id={current_user.tenant_id}") try: api_logger.debug(f"开始删除模型配置: model_id={model_id}") - ModelConfigService.delete_model(db=db, model_id=model_id) + ModelConfigService.delete_model(db=db, model_id=model_id, tenant_id=current_user.tenant_id) api_logger.info(f"模型配置删除成功: model_id={model_id}") return success(msg="模型配置删除成功") except Exception as e: diff --git a/api/app/controllers/multi_agent_controller.py b/api/app/controllers/multi_agent_controller.py index f832ac89..d78aa67b 100644 --- a/api/app/controllers/multi_agent_controller.py +++ b/api/app/controllers/multi_agent_controller.py @@ -158,7 +158,7 @@ async def run_multi_agent( @router.post( "/{app_id}/multi-agent/test-routing", - summary="测试智能路由" + summary="测试智能路由（支持 Master Agent 模式）" ) async def test_routing( app_id: uuid.UUID = Path(..., description="应用 ID"), @@ -166,19 +166,20 @@ async def test_routing( current_user: User = Depends(get_current_user), db: Session = Depends(get_db), ): - """测试智能路由功能 + """测试智能路由功能（重构版 - 支持 Master Agent） 支持三种路由模式： - - keyword: 仅使用关键词路由 - - llm: 使用 LLM 路由（需要提供 routing_model_id） - - hybrid: 混合路由（关键词 + LLM） + - master_agent: 使用 Master Agent 决策（推荐） + - llm_router: 使用旧 LLM 路由器（向后兼容） + - rule_only: 仅使用规则路由（最快） 参数： - message: 测试消息 - conversation_id: 会话 ID（可选） - - routing_model_id: 路由模型 ID（可选，用于 LLM 路由） + - routing_model_id: 路由模型 ID（可选） - use_llm: 是否启用 LLM（默认 False） - keyword_threshold: 关键词置信度阈值（默认 0.8） + - force_new: 是否强制重新路由（默认 False） """ from app.services.conversation_state_manager import ConversationStateManager from app.services.llm_router import LLMRouter @@ -276,7 +277,161 @@ async def test_routing( @router.post( - "/{app_id}/", + "/{app_id}/multi-agent/test-master-agent", + summary="测试 Master Agent 决策" +) +async def test_master_agent( + app_id: uuid.UUID = Path(..., description="应用 ID"), + request: multi_agent_schema.RoutingTestRequest = ..., + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), +): + """测试 Master Agent 的路由决策能力 + + 这个接口专门用于测试新的 Master Agent 路由器， + 可以看到 Master Agent 的完整决策过程。 + + 返回信息包括： + - 选中的 Agent + - 置信度 + - 决策理由 + - 是否需要协作 + - 路由策略（master_agent / rule_fast_path / fallback） + """ + from app.services.conversation_state_manager import ConversationStateManager + from app.services.master_agent_router import MasterAgentRouter + from app.models import ModelConfig + + # 1. 获取多 Agent 配置 + service = MultiAgentService(db) + config = service.get_config(app_id) + + if not config: + return success( + data=None, + msg="应用未配置多 Agent，无法测试" + ) + + # 2. 加载 Master Agent + from app.models import AppRelease, App + + master_release = db.get(AppRelease, config.master_agent_id) + if not master_release: + return success( + data=None, + msg=f"Master Agent 发布版本不存在: {config.master_agent_id}" + ) + + # 获取应用信息 + app = db.get(App, master_release.app_id) + if not app: + return success( + data=None, + msg=f"应用不存在: {master_release.app_id}" + ) + + # 创建 Master Agent 代理对象 + class AgentConfigProxy: + def __init__(self, release, app, config_data): + self.id = release.id + self.app_id = release.app_id + self.app = app + self.name = release.name + self.description = release.description + self.system_prompt = config_data.get("system_prompt") + self.default_model_config_id = release.default_model_config_id + + config_data = master_release.config or {} + master_agent_config = AgentConfigProxy(master_release, app, config_data) + + # 3. 获取 Master Agent 的模型配置 + master_model_config = db.get(ModelConfig, master_agent_config.default_model_config_id) + if not master_model_config: + return success( + data=None, + msg=f"Master Agent 模型配置不存在: {master_agent_config.default_model_config_id}" + ) + + # 4. 准备子 Agent 信息 + sub_agents = {} + for sub_agent_info in config.sub_agents: + agent_id = sub_agent_info["agent_id"] + + # 加载子 Agent + sub_release = db.get(AppRelease, uuid.UUID(agent_id)) + if sub_release: + sub_app = db.get(App, sub_release.app_id) + sub_config_data = sub_release.config or {} + sub_agent_config = AgentConfigProxy(sub_release, sub_app, sub_config_data) + + sub_agents[agent_id] = { + "config": sub_agent_config, + "info": sub_agent_info + } + + # 5. 初始化 Master Agent 路由器 + state_manager = ConversationStateManager() + router = MasterAgentRouter( + db=db, + master_agent_config=master_agent_config, + master_model_config=master_model_config, + sub_agents=sub_agents, + state_manager=state_manager, + enable_rule_fast_path=True + ) + + # 6. 执行路由决策 + try: + decision = await router.route( + message=request.message, + conversation_id=str(request.conversation_id) if request.conversation_id else None, + variables=None + ) + + # 7. 获取选中的 Agent 信息 + agent_id = decision["selected_agent_id"] + agent_info = sub_agents.get(agent_id, {}).get("info", {}) + + # 8. 构建响应 + response_data = { + "message": request.message, + "master_agent": { + "name": master_agent_config.name, + "model": master_model_config.name + }, + "decision": { + "selected_agent_id": agent_id, + "selected_agent_name": agent_info.get("name", "未知"), + "selected_agent_role": agent_info.get("role", ""), + "confidence": decision["confidence"], + "reasoning": decision.get("reasoning", ""), + "topic": decision.get("topic", ""), + "strategy": decision["strategy"], + "routing_method": decision.get("routing_method", ""), + "need_collaboration": decision.get("need_collaboration", False), + "collaboration_agents": decision.get("collaboration_agents", []) + }, + "config_info": { + "total_sub_agents": len(sub_agents), + "enable_rule_fast_path": True + } + } + + return success( + data=response_data, + msg="Master Agent 决策测试成功" + ) + + except Exception as e: + logger.error(f"Master Agent 决策测试失败: {str(e)}") + return success( + data=None, + msg=f"测试失败: {str(e)}" + ) + + +@router.post( + "/{app_id}/multi-agent/batch-test-routing", summary="批量测试智能路由" ) async def batch_test_routing( diff --git a/api/app/controllers/public_share_controller.py b/api/app/controllers/public_share_controller.py index 236deda4..27884b92 100644 --- a/api/app/controllers/public_share_controller.py +++ b/api/app/controllers/public_share_controller.py @@ -5,9 +5,10 @@ import uuid import hashlib import time import jwt +from app.services import task_service, workspace_service from typing import Optional, Dict from functools import wraps - +from app.dependencies import get_current_superuser, get_current_user, get_current_tenant, workspace_access_guard, cur_workspace_access_guard from app.db import get_db from app.core.response_utils import success from app.core.logging_config import get_business_logger @@ -21,8 +22,10 @@ from app.services.shared_chat_service import SharedChatService from app.services.conversation_service import ConversationService from app.services.auth_service import create_access_token from app.dependencies import get_share_user_id, ShareTokenData - - +from app.models.user_model import User +from app.repositories.app_repository import AppRepository +from app.repositories.workspace_repository import WorkspaceRepository +from app.repositories import knowledge_repository router = APIRouter(prefix="/public/share", tags=["Public Share"]) logger = get_business_logger() @@ -95,7 +98,7 @@ def get_access_token( access_token = create_access_token(user_id, share_token) logger.info( - f"生成访问 token", + "生成访问 token", extra={ "share_token": share_token, "user_id": user_id @@ -270,7 +273,7 @@ def get_conversation( async def chat( payload: conversation_schema.ChatRequest, share_data: ShareTokenData = Depends(get_share_user_id), - db: Session = Depends(get_db), + db: Session = Depends(get_db) ): """发送消息并获取回复 @@ -313,6 +316,45 @@ async def chat( original_user_id=user_id # Save original user_id to other_id ) + + appid=share.app_id + """获取存储类型和工作空间的ID""" + + # 直接通过 SQLAlchemy 查询 app + from app.models.app_model import App + app = db.query(App).filter(App.id == appid).first() + if not app: + raise BusinessException("应用不存在", BizCode.APP_NOT_FOUND) + + workspace_id = app.workspace_id + + # 直接从 workspace 获取 storage_type（公开分享场景无需权限检查） + storage_type = workspace_service.get_workspace_storage_type_without_auth( + db=db, + workspace_id=workspace_id + ) + if storage_type is None: + storage_type = 'neo4j' + user_rag_memory_id = '' + + # 如果 storage_type 是 rag，必须确保有有效的 user_rag_memory_id + if storage_type == 'rag': + if workspace_id: + knowledge = knowledge_repository.get_knowledge_by_name( + db=db, + name="USER_RAG_MERORY", + workspace_id=workspace_id + ) + if knowledge: + user_rag_memory_id = str(knowledge.id) + else: + logger.warning( + f"未找到名为 'USER_RAG_MERORY' 的知识库，workspace_id: {workspace_id}，将使用 neo4j 存储") + storage_type = 'neo4j' + else: + logger.warning("workspace_id 为空，无法使用 rag 存储，将使用 neo4j 存储") + storage_type = 'neo4j' + # 获取应用类型 app_type = release.app.type if release.app else None @@ -339,7 +381,7 @@ async def chat( ) logger.debug( - f"参数验证完成", + "参数验证完成", extra={ "share_token": share_token, "app_type": app_type, @@ -365,7 +407,9 @@ async def chat( variables=payload.variables, password=password, web_search=payload.web_search, - memory=payload.memory + memory=payload.memory, + storage_type=storage_type, + user_rag_memory_id=user_rag_memory_id ): yield event @@ -388,7 +432,9 @@ async def chat( variables=payload.variables, password=password, web_search=payload.web_search, - memory=payload.memory + memory=payload.memory, + storage_type=storage_type, + user_rag_memory_id=user_rag_memory_id ) return success(data=conversation_schema.ChatResponse(**result)) elif app_type == AppType.MULTI_AGENT: @@ -403,7 +449,9 @@ async def chat( variables=payload.variables, password=password, web_search=payload.web_search, - memory=payload.memory + memory=payload.memory, + storage_type=storage_type, + user_rag_memory_id=user_rag_memory_id ): yield event @@ -426,7 +474,9 @@ async def chat( variables=payload.variables, password=password, web_search=payload.web_search, - memory=payload.memory + memory=payload.memory, + storage_type=storage_type, + user_rag_memory_id=user_rag_memory_id ) return success(data=conversation_schema.ChatResponse(**result)) diff --git a/api/app/controllers/service/app_api_controller.py b/api/app/controllers/service/app_api_controller.py index f2a322cd..ec587510 100644 --- a/api/app/controllers/service/app_api_controller.py +++ b/api/app/controllers/service/app_api_controller.py @@ -6,7 +6,7 @@ from app.db import get_db from app.core.response_utils import success from app.core.logging_config import get_business_logger -router = APIRouter(prefix="/v1/apps", tags=["V1 - App API"]) +router = APIRouter(prefix="/apps", tags=["V1 - App API"]) logger = get_business_logger() diff --git a/api/app/controllers/test_controller.py b/api/app/controllers/test_controller.py index ad46386c..98cbe26e 100644 --- a/api/app/controllers/test_controller.py +++ b/api/app/controllers/test_controller.py @@ -28,7 +28,7 @@ router = APIRouter( ) -@router.get(f"/llm/{{model_id}}", response_model=ApiResponse) +@router.get("/llm/{model_id}", response_model=ApiResponse) def test_llm( model_id: uuid.UUID, db: Session = Depends(get_db) @@ -62,7 +62,7 @@ Answer: Let's think step by step.""" raise -@router.get(f"/embedding/{{model_id}}", response_model=ApiResponse) +@router.get("/embedding/{model_id}", response_model=ApiResponse) def test_embedding( model_id: uuid.UUID, db: Session = Depends(get_db) @@ -96,7 +96,7 @@ def test_embedding( return success(msg="测试LLM成功") -@router.get(f"/rerank/{{model_id}}", response_model=ApiResponse) +@router.get("/rerank/{model_id}", response_model=ApiResponse) def test_rerank( model_id: uuid.UUID, db: Session = Depends(get_db) diff --git a/api/app/controllers/workspace_controller.py b/api/app/controllers/workspace_controller.py index fc9dca8f..f4390568 100644 --- a/api/app/controllers/workspace_controller.py +++ b/api/app/controllers/workspace_controller.py @@ -73,7 +73,7 @@ def get_workspaces( if not include_current and current_user.current_workspace_id: workspaces = [w for w in workspaces if w.id != current_user.current_workspace_id] api_logger.debug( - f"过滤掉当前工作空间", + "过滤掉当前工作空间", extra={"current_workspace_id": str(current_user.current_workspace_id)} ) diff --git a/api/app/core/agent/agent_api_text.py b/api/app/core/agent/agent_api_text.py deleted file mode 100644 index 74b9e46e..00000000 --- a/api/app/core/agent/agent_api_text.py +++ /dev/null @@ -1,35 +0,0 @@ -from pydantic import BaseModel - -from app.core.agent.agent_chat import Agent_chat -from app.core.logging_config import get_business_logger -from fastapi import APIRouter, Depends, HTTPException - -from app.dependencies import workspace_access_guard -from app.services.agent_server import config,ChatRequest -router = APIRouter(prefix="/Test", tags=["Apps"]) -logger = get_business_logger() -class CombinedRequest(BaseModel): - config_base: config - agent_config: ChatRequest - -@router.post("", summary="uuid") -async def agent_chat( - config_base: CombinedRequest -): - chat_config=config_base.agent_config - chat_base=config_base.config_base - request = ChatRequest( - end_user_id=chat_config.end_user_id, - message=chat_config.message, - search_switch=chat_config.search_switch, - kb_ids=chat_config.kb_ids, - similarity_threshold=chat_config.similarity_threshold, - vector_similarity_weight=chat_config.vector_similarity_weight, - top_k=chat_config.top_k, - hybrid=chat_config.hybrid, - token=chat_config.token - ) - - chat_result=await Agent_chat(chat_base).chat(request) - - return chat_result diff --git a/api/app/core/agent/agent_chat.py b/api/app/core/agent/agent_chat.py deleted file mode 100644 index 23a821c0..00000000 --- a/api/app/core/agent/agent_chat.py +++ /dev/null @@ -1,109 +0,0 @@ -import asyncio -import os -import time - -from typing import Dict, Any, List - -from app.core.logging_config import get_business_logger -from app.schemas.prompt_schema import render_prompt_message, PromptMessageRole -from app.services.api_resquests_server import messages_type, write_messages -from app.services.agent_server import ChatRequest, tool_memory, create_dynamic_agent, tool_Retrieval - -logger = get_business_logger() -class Agent_chat: - def __init__(self,config_data: dict): - self.prompt_message = render_prompt_message( - config_data.template_str, - PromptMessageRole.USER, - config_data.params - ) - self.prompt = self.prompt_message.get_text_content() - self.model_configs = config_data.model_configs - self.history_memory = config_data.history_memory - self.knowledge_base = config_data.knowledge_base - logger.info(f"渲染结果：{self.prompt_message.get_text_content()}" ) - - async def run_agent(self,agent, end_user_id:str, user_prompt:str, model_name:str): - response = agent.invoke( - { - "messages": [ - { - "role": "user", - "content": user_prompt - } - ] - }, - {"configurable": {"thread_id": f'{model_name}_{end_user_id}'}}, - ) - outputs = [] - for msg in response["messages"]: - if hasattr(msg, "tool_calls") and msg.tool_calls: - outputs.append({ - "role": "assistant", - "tool_calls": [ - {"name": t["name"], "arguments": t["args"]} - for t in msg.tool_calls - ] - }) - elif hasattr(msg, "content") and msg.content: - outputs.append({ - "role": msg.__class__.__name__.lower().replace("message", ""), - "content": msg.content - }) - ai_messages=[msg['content'] for msg in outputs if msg["role"] == "ai"] - return {"model_name": model_name, "end_user_id": end_user_id, "response": ai_messages} - - async def chat(self,req: ChatRequest) -> Dict[str, Any]: - - end_user_id = req.end_user_id # 用 user_id 作为对话线程标识 - start=time.time() - user_prompt = req.message - - '''判断是都写入redis数据库''' - messags_type = await messages_type(req.message,end_user_id) - messags_type=messags_type['data'] - if messags_type=='question': - writer_result=await write_messages(f'{end_user_id}', req.message) - logger.info(f'判断类型写入耗时：{time.time() - start},{writer_result}') - - - - '''history_memory''' - - if self.history_memory==True: - tool_result =await tool_memory(req) - if tool_result!='' :tool_result=tool_result['data'] - if tool_result!='' :self.prompt=self.prompt+f''',历史消息：{tool_result},结合历史消息''' - logger.info(f"记忆科学消耗时间：{time.time()-start},工具调用结果:{tool_result}") - - '''baidu''' - - - '''knowledge_base''' - if self.knowledge_base == True: - retrieval_result=await tool_Retrieval(req) - retrieval_knowledge = [i['page_content'] for i in retrieval_result['data']] - retrieval_knowledge=','.join(retrieval_knowledge) - logger.info(f"检索消耗时间：{time.time()-start},{retrieval_knowledge}") - if retrieval_knowledge!='' :self.prompt=self.prompt+f",知识库检索内容：{retrieval_knowledge},结合检索结果" - self.prompt=self.prompt+f'给出最合适的答案，确保答案的完整性，只保留用户的问题的回答，不额外输出提示语' - logger.info(f"用户输入：{user_prompt}") - logger.info(f"系统prompt：{self.prompt}") - - AGENTS = { - cfg["name"]: await create_dynamic_agent(cfg["name"], cfg["moder_id"], self.prompt, req.token) - for cfg in self.model_configs - } - tasks=[ - self.run_agent(agent, end_user_id, user_prompt, model_name) - for model_name, agent in AGENTS.items() - ] - # 并行运行 - results = await asyncio.gather(*tasks) - - result=[] - - for i in results: - result.append(i) - chat_result=(f"最终耗时：{time.time()-start},{result}") - return chat_result \ No newline at end of file diff --git a/api/app/core/agent/langchain_agent.py b/api/app/core/agent/langchain_agent.py index a32c8c96..dc0d6922 100644 --- a/api/app/core/agent/langchain_agent.py +++ b/api/app/core/agent/langchain_agent.py @@ -15,6 +15,8 @@ from langchain_core.messages import SystemMessage, HumanMessage, AIMessage, Base from langchain_core.tools import BaseTool from langchain.agents import create_agent +from app.core.memory.agent.mcp_server.services import session_service +from app.core.memory.agent.utils.redis_tool import store from app.core.models import RedBearLLM, RedBearModelConfig from app.models.models_model import ModelType from app.core.logging_config import get_business_logger @@ -89,7 +91,7 @@ class LangChainAgent: ) logger.info( - f"LangChain Agent 初始化完成", + "LangChain Agent 初始化完成", extra={ "model": model_name, "provider": provider, @@ -139,6 +141,42 @@ class LangChainAgent: messages.append(HumanMessage(content=user_content)) return messages + async def term_memory_save(self,messages,end_user_end,aimessages): + '''短长期存储redis，为不影响正常使用6句一段话，存储用户名加一个前缀，当数据存够6条返回给neo4j''' + end_user_end=f"Term_{end_user_end}" + print(messages) + print(aimessages) + session_id = store.save_session( + userid=end_user_end, + messages=messages, + apply_id=end_user_end, + group_id=end_user_end, + aimessages=aimessages + ) + store.delete_duplicate_sessions() + # logger.info(f'Redis_Agent:{end_user_end};{session_id}') + return session_id + async def term_memory_redis_read(self,end_user_end): + end_user_end = f"Term_{end_user_end}" + history = store.find_user_apply_group(end_user_end, end_user_end, end_user_end) + # logger.info(f'Redis_Agent:{end_user_end};{history}') + messagss_list=[] + for messages in history: + query = messages.get("Query") + aimessages = messages.get("Answer") + messagss_list.append(f'用户:{query}。AI回复:{aimessages}') + return messagss_list + + + async def write(self,storage_type,end_user_id,message,user_rag_memory_id,actual_end_user_id,content,actual_config_id): + if storage_type == "rag": + await write_rag(end_user_id, message, user_rag_memory_id) + logger.info(f'RAG_Agent:{end_user_id};{user_rag_memory_id}') + else: + write_id = write_message_task.delay(actual_end_user_id, content, actual_config_id, storage_type, + user_rag_memory_id) + write_status = get_task_memory_write_result(str(write_id)) + logger.info(f'Agent:{actual_end_user_id};{write_status}') async def chat( self, @@ -149,6 +187,7 @@ class LangChainAgent: config_id: Optional[str] = None, # 添加这个参数 storage_type: Optional[str] = None, user_rag_memory_id: Optional[str] = None, + memory_flag: Optional[bool] = True ) -> Dict[str, Any]: """执行对话 @@ -160,29 +199,29 @@ class LangChainAgent: Returns: Dict: 包含 content 和元数据的字典 """ + message_chat= message start_time = time.time() - + if config_id == None: + actual_config_id = os.getenv("config_id") + else: + actual_config_id = config_id + actual_end_user_id = end_user_id if end_user_id is not None else "unknown" logger.info(f'写入类型{storage_type,str(end_user_id), message, str(user_rag_memory_id)}') print(f'写入类型{storage_type,str(end_user_id), message, str(user_rag_memory_id)}') - if storage_type == "rag": - await write_rag(end_user_id, message, user_rag_memory_id) - logger.info(f'RAG_Agent:{end_user_id};{user_rag_memory_id}') - else: - if config_id==None: - actual_config_id = os.getenv("config_id") - else:actual_config_id=config_id - actual_end_user_id = end_user_id if end_user_id is not None else "unknown" - write_id = write_message_task.delay(actual_end_user_id, message, actual_config_id,storage_type,user_rag_memory_id) - write_status = get_task_memory_write_result(str(write_id)) - logger.info(f'Agent:{actual_end_user_id};{write_status}') - + history_term_memory=await self.term_memory_redis_read(end_user_id) + if memory_flag: + if len(history_term_memory)>=4 and storage_type != "rag": + history_term_memory=';'.join(history_term_memory) + logger.info(f'写入短长期：{storage_type, str(end_user_id), history_term_memory, str(user_rag_memory_id)}') + await self.write(storage_type,end_user_id,history_term_memory,user_rag_memory_id,actual_end_user_id,history_term_memory,actual_config_id) + await self.write(storage_type,end_user_id,message,user_rag_memory_id,actual_end_user_id,message,actual_config_id) try: # 准备消息列表 messages = self._prepare_messages(message, history, context) logger.debug( - f"准备调用 LangChain Agent", + "准备调用 LangChain Agent", extra={ "has_context": bool(context), "has_history": bool(history), @@ -203,15 +242,9 @@ class LangChainAgent: break elapsed_time = time.time() - start_time - - if storage_type == "rag": - await write_rag(end_user_id, message, user_rag_memory_id) - logger.info(f'RAG_Agent:{end_user_id};{user_rag_memory_id}') - else: - write_id = write_message_task.delay(actual_end_user_id, content, actual_config_id, storage_type, user_rag_memory_id) - write_status = get_task_memory_write_result(str(write_id)) - logger.info(f'Agent:{actual_end_user_id};{write_status}') - + if memory_flag: + await self.write(storage_type,end_user_id,content,user_rag_memory_id,actual_end_user_id,content,actual_config_id) + await self.term_memory_save(message_chat,end_user_id,content) response = { "content": content, "model": self.model_name, @@ -224,7 +257,7 @@ class LangChainAgent: } logger.debug( - f"Agent 调用完成", + "Agent 调用完成", extra={ "elapsed_time": elapsed_time, "content_length": len(response["content"]) @@ -234,7 +267,7 @@ class LangChainAgent: return response except Exception as e: - logger.error(f"Agent 调用失败", extra={"error": str(e)}) + logger.error("Agent 调用失败", extra={"error": str(e)}) raise async def chat_stream( @@ -246,7 +279,7 @@ class LangChainAgent: config_id: Optional[str] = None, storage_type:Optional[str] = None, user_rag_memory_id:Optional[str] = None, - + memory_flag: Optional[bool] = True ) -> AsyncGenerator[str, None]: """执行流式对话 @@ -259,28 +292,27 @@ class LangChainAgent: str: 消息内容块 """ logger.info("=" * 80) - logger.info(f" chat_stream 方法开始执行") + logger.info(" chat_stream 方法开始执行") logger.info(f" Message: {message[:100]}") logger.info(f" Has tools: {bool(self.tools)}") logger.info(f" Tool count: {len(self.tools) if self.tools else 0}") logger.info("=" * 80) - - start_time = time.time() - if storage_type == "rag": - await write_rag(end_user_id, message, user_rag_memory_id) + message_chat = message + if config_id == None: + actual_config_id = os.getenv("config_id") else: - if config_id==None: - actual_config_id = os.getenv("config_id") - else:actual_config_id=config_id - actual_end_user_id = end_user_id if end_user_id is not None else "unknown" - write_id = write_message_task.delay(actual_end_user_id, message, actual_config_id,storage_type,user_rag_memory_id) + actual_config_id = config_id - try: - write_status = get_task_memory_write_result(str(write_id)) - logger.info(f'Agent:{actual_end_user_id};{write_status}') - except Exception as e: - logger.error(f"Agent 记忆用户输入出错", extra={"error": str(e)}) + history_term_memory = await self.term_memory_redis_read(end_user_id) + if memory_flag: + if len(history_term_memory) >= 4 and storage_type != "rag": + history_term_memory = ';'.join(history_term_memory) + logger.info( + f'写入短长期：{storage_type, str(end_user_id), history_term_memory, str(user_rag_memory_id)}') + await self.write(storage_type, end_user_id, history_term_memory, user_rag_memory_id, end_user_id, + history_term_memory, actual_config_id) + await self.write(storage_type, end_user_id, message, user_rag_memory_id, end_user_id, message, actual_config_id) try: # 准备消息列表 messages = self._prepare_messages(message, history, context) @@ -294,7 +326,7 @@ class LangChainAgent: # 统一使用 agent 的 astream_events 实现流式输出 logger.debug("使用 Agent astream_events 实现流式输出") - + full_content='' try: async for event in self.agent.astream_events( {"messages": messages}, @@ -307,6 +339,7 @@ class LangChainAgent: if kind == "on_chat_model_stream": # LLM 流式输出 chunk = event.get("data", {}).get("chunk") + full_content+=chunk.content if chunk and hasattr(chunk, "content") and chunk.content: yield chunk.content yielded_content = True @@ -316,6 +349,7 @@ class LangChainAgent: chunk = event.get("data", {}).get("chunk") if chunk: if hasattr(chunk, "content") and chunk.content: + full_content+=chunk.content yield chunk.content yielded_content = True elif isinstance(chunk, str): @@ -329,6 +363,9 @@ class LangChainAgent: logger.debug(f"工具调用结束: {event.get('name')}") logger.debug(f"Agent 流式完成，共 {chunk_count} 个事件") + if memory_flag: + await self.write(storage_type, end_user_id,full_content, user_rag_memory_id, end_user_id,full_content, actual_config_id) + await self.term_memory_save(message_chat, end_user_id, full_content) except Exception as e: logger.error(f"Agent astream_events 失败: {str(e)}", exc_info=True) @@ -341,7 +378,7 @@ class LangChainAgent: raise finally: logger.info("=" * 80) - logger.info(f"chat_stream 方法执行结束") + logger.info("chat_stream 方法执行结束") logger.info("=" * 80) diff --git a/api/app/core/api_key_auth.py b/api/app/core/api_key_auth.py new file mode 100644 index 00000000..d02d2811 --- /dev/null +++ b/api/app/core/api_key_auth.py @@ -0,0 +1,228 @@ +import asyncio +import uuid +from functools import wraps +from typing import Optional, List +from datetime import datetime + +from fastapi import Request, Response +from sqlalchemy.orm import Session + +from app.core.api_key_utils import add_rate_limit_headers +from app.core.exceptions import ( + BusinessException, + RateLimitException, +) +from app.repositories.api_key_repository import ApiKeyLogRepository, ApiKeyRepository +from app.schemas.api_key_schema import ApiKeyAuth +from app.services.api_key_service import ApiKeyAuthService, RateLimiterService +from app.core.logging_config import get_api_logger +from app.core.error_codes import BizCode + +logger = get_api_logger() + + +def require_api_key( + scopes: Optional[List[str]] = None, + resource_type: Optional[str] = None +): + """ + API Key 鉴权装饰器 + + Args: + scopes: 所需的权限范围列表["app:all", + "rag:search", "rag:upload", "rag:delete", + "memory:read", "memory:write", "memory:delete", "memory:search"] + resource_type: 所需的资源类型("Agent", "Cluster", "Workflow", "Knowledge", "Memory_Engine") + + Usage: + @router.get("/app/{resource_id}/chat") + @require_api_key(scopes=["app:all"], resource_type="Agent") + def chat_with_app( + resource_id: uuid.UUID, + api_key_auth: ApiKeyAuth = Depends(), + db: Session = Depends(get_db), + message: str + ): + # api_key_auth 包含验证后的API Key 信息 + pass + """ + + def decorator(func): + @wraps(func) + async def wrapper(*args, **kwargs): + request: Request = kwargs.get("request") + db: Session = kwargs.get("db") + + api_key = extract_api_key_from_request(request) + if not api_key: + logger.warning("API Key 缺失", extra={ + "endpoint": str(request.url), + "method": request.method, + "ip_address": request.client.host if request.client else None + }) + raise BusinessException("API Key 不存在", BizCode.API_KEY_NOT_FOUND) + + api_key_obj = ApiKeyAuthService.validate_api_key(db, api_key) + if not api_key_obj: + logger.warning("API Key 无效或已过期", extra={ + "key_prefix": api_key[:10] + "..." if len(api_key) > 10 else api_key, + "endpoint": str(request.url), + "method": request.method, + "ip_address": request.client.host if request.client else None + }) + raise BusinessException("API Key 无效或已过期", BizCode.API_KEY_INVALID) + + rate_limiter = RateLimiterService() + is_allowed, error_msg, rate_headers = await rate_limiter.check_all_limits(api_key_obj) + if not is_allowed: + logger.warning("API Key 限流触发", extra={ + "api_key_id": str(api_key_obj.id), + "endpoint": str(request.url), + "method": request.method, + "error_msg": error_msg + }) + # 根据错误消息判断限流类型 + if "QPS" in error_msg: + code = BizCode.API_KEY_QPS_LIMIT_EXCEEDED + elif "Daily" in error_msg: + code = BizCode.API_KEY_DAILY_LIMIT_EXCEEDED + else: + code = BizCode.API_KEY_QUOTA_EXCEEDED + + raise RateLimitException( + error_msg, + code, + rate_headers=rate_headers + ) + + if scopes: + missing_scopes = [] + for scope in scopes: + if not ApiKeyAuthService.check_scope(api_key_obj, scope): + missing_scopes.append(scope) + if missing_scopes: + logger.warning("API Key 权限不足", extra={ + "api_key_id": str(api_key_obj.id), + "missing_scopes": missing_scopes, + "available_scopes": api_key_obj.scopes, + "endpoint": str(request.url) + }) + raise BusinessException( + f"缺少必须的权限范围：{','.join(missing_scopes)}", + BizCode.API_KEY_INVALID_SCOPE, + context={"required_scopes": scopes, "missing_scopes": missing_scopes} + ) + + if resource_type: + resource_id = kwargs.get("resource_id") + if resource_id and not ApiKeyAuthService.check_resource( + api_key_obj, + resource_type, + resource_id + ): + logger.warning("API Key 资源访问被拒绝", extra={ + "api_key_id": str(api_key_obj.id), + "required_resource_type": resource_type, + "required_resource_id": str(resource_id), + "bound_resource_type": api_key_obj.resource_type, + "bound_resource_id": str(api_key_obj.resource_id) if api_key_obj.resource_id else None, + "endpoint": str(request.url) + }) + return BusinessException( + "API Key 未授权访问该资源", + BizCode.API_KEY_INVALID_RESOURCE, + context={ + "required_resource_type": resource_type, + "required_resource_id": str(resource_id), + "bound_resource_type": api_key_obj.resource_type, + "bound_resource_id": str(api_key_obj.resource_id) if api_key_obj.resource_id else None + } + ) + + kwargs["api_key_auth"] = ApiKeyAuth( + api_key_id=api_key_obj.id, + workspace_id=api_key_obj.workspace_id, + type=api_key_obj.type, + scopes=api_key_obj.scopes, + resource_id=api_key_obj.resource_id, + resource_type=api_key_obj.resource_type + ) + + response = await func(*args, **kwargs) + response = add_rate_limit_headers(response, rate_headers) + + asyncio.create_task(log_api_key_usage( + db, api_key_obj.id, request, response + )) + return response + + return wrapper + + return decorator + + +def extract_api_key_from_request(request: Request) -> Optional[str]: + """从请求中提取 API Key + + 支持以下方式： + 1. Authorization: Bearer + 2. X-API-Key: + """ + try: + # 从 Authorization header + auth_header = request.headers.get("Authorization") + if auth_header: + if " " not in auth_header: + logger.warning("无效的 Authorization header 格式", extra={ + "auth_header": auth_header[:20] + "..." if len(auth_header) > 20 else auth_header, + "endpoint": str(request.url) + }) + return None + auth_scheme, auth_token = auth_header.split(" ", 1) + if auth_scheme.lower() != "bearer": + logger.warning("无效的认证方案", extra={ + "auth_scheme": auth_scheme, + "endpoint": str(request.url) + }) + return None + return auth_token + + # 从 X-API-Key header + api_key_header = request.headers.get("X-API-Key") + if api_key_header: + return api_key_header + + return None + except Exception as e: + logger.error(f"提取 API Key 时发生错误: {str(e)}", extra={ + "endpoint": str(request.url) + }) + return None + + +async def log_api_key_usage( + db: Session, + api_key_id: uuid.UUID, + request: Request, + response: Response +): + """记录 API Key 使用日志""" + try: + log_data = { + "id": uuid.uuid4(), + "api_key_id": api_key_id, + "endpoint": str(request.url.path), + "method": request.method, + "ip_address": request.client.host if request.client else None, + "user_agent": request.headers.get("User-Agent"), + "status_code": response.status_code if hasattr(response, "status_code") else None, + "response_time": None, # 需要在 middleware 中计算 + "tokens_used": None, # 需要从响应中提取 + "created_at": datetime.now() + } + + ApiKeyLogRepository.create(db, log_data) + ApiKeyRepository.update_usage(db, api_key_id) + db.commit() + except Exception as e: + logger.error(f"未能记录API密钥的使用情况: {e}") diff --git a/api/app/core/api_key_utils.py b/api/app/core/api_key_utils.py index e8dc5d98..9ebd33e8 100644 --- a/api/app/core/api_key_utils.py +++ b/api/app/core/api_key_utils.py @@ -1,11 +1,35 @@ """API Key 工具函数""" import secrets import hashlib -from app.models.api_key_model import ApiKeyType +from typing import Optional + +from app.schemas.api_key_schema import ApiKeyType +from fastapi import Response +from fastapi.responses import JSONResponse + + +class ResourceType: + """资源类型常量""" + AGENT = "Agent" + CLUSTER = "Cluster" + WORKFLOW = "Workflow" + KNOWLEDGE = "Knowledge" + MEMORY_ENGINE = "Memory_Engine" + + @classmethod + def get_all_types(cls) -> list[str]: + """获取所有支持的资源类型""" + return [cls.AGENT, cls.CLUSTER, cls.WORKFLOW, cls.KNOWLEDGE, cls.MEMORY_ENGINE] + + @classmethod + def is_valid_type(cls, resource_type: str) -> bool: + """验证资源类型是否有效""" + return resource_type in cls.get_all_types() def generate_api_key(key_type: ApiKeyType) -> tuple[str, str, str]: - """生成 API Key + """ + 生成 API Key Args: key_type: API Key 类型 @@ -18,16 +42,15 @@ def generate_api_key(key_type: ApiKeyType) -> tuple[str, str, str]: ApiKeyType.APP: "sk-app-", ApiKeyType.RAG: "sk-rag-", ApiKeyType.MEMORY: "sk-mem-", - ApiKeyType.GENERAL: "sk-gen-", } - + prefix = prefix_map[key_type] random_string = secrets.token_urlsafe(32)[:32] # 32 字符 api_key = f"{prefix}{random_string}" - + # 生成哈希值存储 key_hash = hash_api_key(api_key) - + return api_key, key_hash, prefix @@ -44,7 +67,8 @@ def hash_api_key(api_key: str) -> str: def verify_api_key(api_key: str, key_hash: str) -> bool: - """验证 API Key + """ + 验证 API Key Args: api_key: API Key 明文 @@ -53,4 +77,77 @@ def verify_api_key(api_key: str, key_hash: str) -> bool: Returns: bool: 是否匹配 """ - return hash_api_key(api_key) == key_hash + computed_hash = hash_api_key(api_key) + return secrets.compare_digest(computed_hash, key_hash) + + +def validate_resource_binding( + resource_type: Optional[str], + resource_id: Optional[str] +) -> tuple[bool, str]: + """ + 验证资源绑定的有效性 + + Args: + resource_type: 资源类型 + resource_id: 资源ID + + Returns: + tuple: (是否有效, 错误信息) + """ + # 如果都为空，表示不绑定资源，这是有效的 + if not resource_type and not resource_id: + return True, "" + + # 如果只有一个为空，这是无效的 + if not resource_type or not resource_id: + return False, "resource_type 和 resource_id 必须同时提供或同时为空" + + # 验证资源类型是否支持 + if not ResourceType.is_valid_type(resource_type): + valid_types = ", ".join(ResourceType.get_all_types()) + return False, f"不支持的资源类型 '{resource_type}'，支持的类型：{valid_types}" + + return True, "" + + +def get_resource_scope_mapping() -> dict[str, list[str]]: + """ + 获取资源类型与权限范围的映射关系 + + Returns: + dict: 资源类型到推荐权限范围的映射 + """ + return { + ResourceType.AGENT: [ + "app:all" + ], + ResourceType.CLUSTER: [ + "app:all" + ], + ResourceType.WORKFLOW: [ + "app:all" + ], + ResourceType.KNOWLEDGE: [ + "rag:search", "rag:upload", "rag:delete" + ], + ResourceType.MEMORY_ENGINE: [ + "memory:read", "memory:write", "memory:delete", "memory:search" + ] + } + + +def add_rate_limit_headers(response, headers: dict): + """统一添加限流响应头""" + if isinstance(response, Response): + for key, value in headers.items(): + response.headers[key] = value + elif isinstance(response, JSONResponse): + for key, value in headers.items(): + response.headers[key] = value + elif hasattr(response, 'headers'): + response.headers.update(headers) + + return response + + diff --git a/api/app/core/compensation.py b/api/app/core/compensation.py index 916f10ba..0b61c640 100644 --- a/api/app/core/compensation.py +++ b/api/app/core/compensation.py @@ -35,7 +35,7 @@ class CompensationHandler: for compensation in reversed(self._compensations): try: compensation() - logger.debug(f"Compensation operation executed successfully") + logger.debug("Compensation operation executed successfully") except Exception as e: logger.error(f"补偿操作失败: {e}", exc_info=True) diff --git a/api/app/core/config.py b/api/app/core/config.py index 37366b8f..48f79d5e 100644 --- a/api/app/core/config.py +++ b/api/app/core/config.py @@ -13,7 +13,7 @@ class Settings: DASHSCOPE_API_KEY: str = os.getenv("DASHSCOPE_API_KEY", "") # Neo4j Configuration (记忆系统数据库) - NEO4J_URI: str = os.getenv("NEO4J_URI", "bolt://127.0.0.1:7687") + NEO4J_URI: str = os.getenv("NEO4J_URI", "bolt://1.94.111.67:7687") NEO4J_USERNAME: str = os.getenv("NEO4J_USERNAME", "neo4j") NEO4J_PASSWORD: str = os.getenv("NEO4J_PASSWORD", "") @@ -23,6 +23,11 @@ class Settings: DB_USER: str = os.getenv("DB_USER", "postgres") DB_PASSWORD: str = os.getenv("DB_PASSWORD", "password") DB_NAME: str = os.getenv("DB_NAME", "redbear-mem") + DB_POOL_SIZE: int = int(os.getenv("DB_POOL_SIZE", "50")) + DB_MAX_OVERFLOW: int = int(os.getenv("DB_MAX_OVERFLOW", "20")) + DB_POOL_RECYCLE: int = int(os.getenv("DB_POOL_RECYCLE", "1800")) + DB_POOL_TIMEOUT: int = int(os.getenv("DB_POOL_TIMEOUT", "30")) + DB_POOL_PRE_PING: bool = os.getenv("DB_POOL_PRE_PING", "true").lower() == "true" DB_AUTO_UPGRADE = os.getenv("DB_AUTO_UPGRADE", "false").lower() == "true" diff --git a/api/app/core/error_codes.py b/api/app/core/error_codes.py index b175c10c..f1d0a1cf 100644 --- a/api/app/core/error_codes.py +++ b/api/app/core/error_codes.py @@ -19,6 +19,17 @@ class BizCode(IntEnum): TENANT_NOT_FOUND = 3002 WORKSPACE_NO_ACCESS = 3003 WORKSPACE_INVITE_NOT_FOUND = 3004 + # API Key 管理（3xxx） + API_KEY_NOT_FOUND = 3007 + API_KEY_DUPLICATE_NAME = 3008 + API_KEY_INVALID = 3009 + API_KEY_EXPIRED = 3010 + API_KEY_INACTIVE = 3011 + API_KEY_INVALID_SCOPE = 3012 + API_KEY_INVALID_RESOURCE = 3013 + API_KEY_QPS_LIMIT_EXCEEDED = 3014 + API_KEY_DAILY_LIMIT_EXCEEDED = 3015 + API_KEY_QUOTA_EXCEEDED = 3016 # 资源（4xxx） NOT_FOUND = 4000 USER_NOT_FOUND = 4001 @@ -112,6 +123,19 @@ HTTP_MAPPING = { BizCode.EMBED_NOT_ALLOWED: 403, BizCode.PERMISSION_DENIED: 403, BizCode.INVALID_CONVERSATION: 400, + + # API Key 错误码映射 + BizCode.API_KEY_NOT_FOUND: 400, + BizCode.API_KEY_DUPLICATE_NAME: 400, + BizCode.API_KEY_INVALID: 401, + BizCode.API_KEY_EXPIRED: 401, + BizCode.API_KEY_INACTIVE: 401, + BizCode.API_KEY_INVALID_SCOPE: 403, + BizCode.API_KEY_INVALID_RESOURCE: 403, + BizCode.API_KEY_QPS_LIMIT_EXCEEDED: 429, + BizCode.API_KEY_DAILY_LIMIT_EXCEEDED: 429, + BizCode.API_KEY_QUOTA_EXCEEDED: 429, + BizCode.MODEL_CONFIG_INVALID: 400, BizCode.API_KEY_MISSING: 400, BizCode.PROVIDER_NOT_SUPPORTED: 400, diff --git a/api/app/core/exceptions.py b/api/app/core/exceptions.py index ef5dd2cd..1fd59ee5 100644 --- a/api/app/core/exceptions.py +++ b/api/app/core/exceptions.py @@ -83,4 +83,21 @@ class PermissionDeniedException(BusinessException): """权限拒绝异常""" def __init__(self, message: str = "权限不足", **kwargs): - super().__init__(message, BizCode.FORBIDDEN, **kwargs) \ No newline at end of file + super().__init__(message, BizCode.FORBIDDEN, **kwargs) + + +class RateLimitException(BusinessException): + """限流异常""" + + def __init__(self, message: str, code: BizCode = None, rate_headers: dict = None, **kwargs): + # 如果没有指定错误码，默认使用通用限流错误码 + if code is None: + code = BizCode.RATE_LIMITED + + # 将限流头信息添加到上下文中 + context = kwargs.get("context", {}) + if rate_headers: + context["rate_limit_headers"] = rate_headers + kwargs["context"] = context + + super().__init__(message, code, **kwargs) \ No newline at end of file diff --git a/api/app/core/memory/src/llm_tools/__init__.py b/api/app/core/features.py similarity index 100% rename from api/app/core/memory/src/llm_tools/__init__.py rename to api/app/core/features.py diff --git a/api/app/core/memory/agent/langgraph_graph/read_graph.py b/api/app/core/memory/agent/langgraph_graph/read_graph.py index 51127f3e..78d07327 100644 --- a/api/app/core/memory/agent/langgraph_graph/read_graph.py +++ b/api/app/core/memory/agent/langgraph_graph/read_graph.py @@ -210,7 +210,7 @@ class ProblemExtensionNode: last_message = messages[-1] if messages else "" logger.debug(f"ProblemExtensionNode {self.id} - 当前时间: {time.time()} - Message: {last_message}") if self.tool_name=='Input_Summary': - tool_call =re.findall(f"'id': '(.*?)'",str(last_message))[0] + tool_call =re.findall("'id': '(.*?)'",str(last_message))[0] else:tool_call = str(re.findall(r"tool_call_id=.*?'(.*?)'", str(last_message))[0]).replace('\\', '').split('_id')[1] # try: # content = json.loads(last_message.content) if hasattr(last_message, 'content') else last_message diff --git a/api/app/core/memory/agent/logger_file/logger_data.py b/api/app/core/memory/agent/logger_file/logger_data.py deleted file mode 100644 index fb5e3e54..00000000 --- a/api/app/core/memory/agent/logger_file/logger_data.py +++ /dev/null @@ -1,32 +0,0 @@ -""" -Agent logger module for backward compatibility. - -This module maintains the get_named_logger() function for backward compatibility -while delegating to the centralized logging configuration. - -All new code should import directly from app.core.logging_config instead. -""" - -__version__ = "0.1.0" -__author__ = "RED_BEAR" - -from app.core.logging_config import get_agent_logger - - -def get_named_logger(name): - """Get a named logger for agent operations. - - This function maintains backward compatibility with existing code. - It delegates to the centralized get_agent_logger() function. - - Args: - name: Logger name for namespacing - - Returns: - Logger configured for agent operations - - Example: - >>> logger = get_named_logger("my_agent") - >>> logger.info("Agent operation started") - """ - return get_agent_logger(name) diff --git a/api/app/core/memory/agent/mcp_server/server.py b/api/app/core/memory/agent/mcp_server/server.py index 6cb454ee..18ea911f 100644 --- a/api/app/core/memory/agent/mcp_server/server.py +++ b/api/app/core/memory/agent/mcp_server/server.py @@ -144,13 +144,15 @@ def main(): import asyncio tools_list = asyncio.run(mcp.list_tools()) # logger.info(f"Registered {len(tools_list)} MCP tools: {[t.name for t in tools_list]}") - # logger.info(f"Starting MCP server on {settings.SERVER_IP}:8081 with SSE transport") + + # Get MCP port from environment (default: 8081) + mcp_port = int(os.getenv("MCP_PORT", "8081")) + # logger.info(f"Starting MCP server on {settings.SERVER_IP}:{mcp_port} with SSE transport") # Run the server with SSE transport for HTTP connections - # The server will be available at http://127.0.0.1:8081 import uvicorn app = mcp.sse_app() - uvicorn.run(app, host=settings.SERVER_IP, port=8081, log_level="info") + uvicorn.run(app, host=settings.SERVER_IP, port=mcp_port, log_level="info") except Exception as e: logger.error(f"Failed to start MCP server: {e}", exc_info=True) diff --git a/api/app/core/memory/agent/mcp_server/services/parameter_builder.py b/api/app/core/memory/agent/mcp_server/services/parameter_builder.py index 0da9dd22..03995a1e 100644 --- a/api/app/core/memory/agent/mcp_server/services/parameter_builder.py +++ b/api/app/core/memory/agent/mcp_server/services/parameter_builder.py @@ -66,80 +66,27 @@ class ParameterBuilder: base_args["user_rag_memory_id"] = user_rag_memory_id if user_rag_memory_id is not None else "" # Tool-specific argument construction - if tool_name == "Verify": + if tool_name in ["Verify","Summary", "Summary_fails",'Retrieve_Summary']: # Verify expects dict context return { "context": content if isinstance(content, dict) else {}, **base_args } - - elif tool_name == "Retrieve": - # Retrieve expects dict context + search_switch + + elif tool_name in ["Retrieve"]: return { "context": content if isinstance(content, dict) else {}, "search_switch": search_switch, **base_args } - - elif tool_name in ["Summary", "Summary_fails"]: - # Summary tools expect JSON string context - if isinstance(content, dict): - context_str = json.dumps(content, ensure_ascii=False) - elif isinstance(content, str): - context_str = content - else: - context_str = json.dumps({"data": content}, ensure_ascii=False) - - return { - "context": context_str, - **base_args - } - - elif tool_name == "Retrieve_Summary": - # Retrieve_Summary needs to unwrap nested context structures - # Handle both 'content' and 'context' keys - context_dict = content - - if isinstance(content, dict): - # Check for nested 'content' wrapper - if "content" in content: - inner = content["content"] - - # If it's a JSON string, parse it - if isinstance(inner, str): - try: - parsed = json.loads(inner) - # Check if parsed has 'context' wrapper - if isinstance(parsed, dict) and "context" in parsed: - context_dict = parsed["context"] - else: - context_dict = parsed - except json.JSONDecodeError: - logger.warning( - f"Failed to parse JSON content for {tool_name}: {inner[:100]}" - ) - context_dict = {"Query": "", "Expansion_issue": []} - elif isinstance(inner, dict): - context_dict = inner - - # Check for 'context' wrapper - elif "context" in content: - context_dict = content["context"] if isinstance(content["context"], dict) else content - - return { - "context": context_dict, - **base_args - } - + elif tool_name == "Input_Summary": - # Input_Summary expects raw message string + search_switch - # Content should be the raw message string if isinstance(content, dict): # Try to extract message from dict message_str = content.get("sentence", str(content)) else: message_str = str(content) - + return { "context": message_str, "search_switch": search_switch, diff --git a/api/app/core/memory/agent/mcp_server/tools/problem_tools.py b/api/app/core/memory/agent/mcp_server/tools/problem_tools.py index 07d323a6..5232fd68 100644 --- a/api/app/core/memory/agent/mcp_server/tools/problem_tools.py +++ b/api/app/core/memory/agent/mcp_server/tools/problem_tools.py @@ -116,7 +116,7 @@ async def Split_The_Problem( ) split_result = json.dumps([], ensure_ascii=False) - logger.info(f"问题拆分") + logger.info("问题拆分") logger.info(f"问题拆分结果==>>:{split_result}") # Emit intermediate output for frontend @@ -250,7 +250,7 @@ async def Problem_Extension( ) aggregated_dict = {} - logger.info(f"问题扩展") + logger.info("问题扩展") logger.info(f"问题扩展==>>:{aggregated_dict}") # Emit intermediate output for frontend diff --git a/api/app/core/memory/agent/mcp_server/tools/retrieval_tools.py b/api/app/core/memory/agent/mcp_server/tools/retrieval_tools.py index 3639742a..0a71e890 100644 --- a/api/app/core/memory/agent/mcp_server/tools/retrieval_tools.py +++ b/api/app/core/memory/agent/mcp_server/tools/retrieval_tools.py @@ -167,7 +167,7 @@ async def Retrieve( val.append(items_value) send_verify = [] - for i, j in zip(keys, val): + for i, j in zip(keys, val, strict=False): send_verify.append({ "Query_small": i, "Answer_Small": j diff --git a/api/app/core/memory/agent/mcp_server/tools/summary_tools.py b/api/app/core/memory/agent/mcp_server/tools/summary_tools.py index 4d0d77d4..695fa296 100644 --- a/api/app/core/memory/agent/mcp_server/tools/summary_tools.py +++ b/api/app/core/memory/agent/mcp_server/tools/summary_tools.py @@ -73,16 +73,16 @@ async def Summary( answer_small, query = await Summary_messages_deal(context) - # Get conversation history + start_time= time.time() history = await session_service.get_history(sessionid, apply_id, group_id) - # Override with empty list for now (as in original) - # Prepare data for template + end_time=time.time() + logger.info(f"Retrieve_Summary-REDIS搜索：{end_time - start_time}") data = { "query": query, "history": history, "retrieve_info": answer_small } - + except Exception as e: logger.error( f"Summary: initialization failed: {e}", @@ -92,7 +92,7 @@ async def Summary( "status": "error", "summary_result": "信息不足，无法回答" } - + try: # Render template system_prompt = await template_service.render_template( @@ -110,23 +110,23 @@ async def Summary( "status": "error", "message": f"Prompt rendering failed: {str(e)}" } - + try: # Call LLM with structured response structured = await llm_client.response_structured( messages=[{"role": "system", "content": system_prompt}], response_model=SummaryResponse ) - + aimessages = structured.query_answer or "" - + except Exception as e: logger.error( f"LLM call failed for Summary: {e}", exc_info=True ) aimessages = "" - + try: # Save session if aimessages != "": @@ -147,16 +147,16 @@ async def Summary( "status": "error", "message": str(e) } - + # Cleanup duplicate sessions await session_service.cleanup_duplicates() - + # Use fallback if empty if aimessages == '': aimessages = '信息不足，无法回答' - + logger.info(f"验证之后的总结==>>:{aimessages}") - + # Log execution time end = time.time() try: @@ -164,7 +164,7 @@ async def Summary( except Exception: duration = 0.0 log_time('总结', duration) - + return { "status": "success", "summary_result": aimessages, @@ -185,7 +185,7 @@ async def Retrieve_Summary( ) -> dict: """ Summarize data directly from retrieval results. - + Args: ctx: FastMCP context for dependency injection context: Dictionary containing Query and Expansion_issue from Retrieve @@ -194,23 +194,23 @@ async def Retrieve_Summary( group_id: Group identifier storage_type: Storage type for the workspace (optional) user_rag_memory_id: User RAG memory identifier (optional) - + Returns: dict: Contains 'status' and 'summary_result' """ start = time.time() - + try: # Extract services from context template_service = get_context_resource(ctx, 'template_service') session_service = get_context_resource(ctx, 'session_service') llm_client = get_context_resource(ctx, 'llm_client') - + # Resolve session ID sessionid = Resolve_username(usermessages) - + # Handle both 'content' and 'context' keys (LangGraph uses 'content') if isinstance(context, dict): if "content" in context: @@ -219,13 +219,13 @@ async def Retrieve_Summary( if isinstance(inner, str): try: parsed = json.loads(inner) - logger.info(f"Retrieve_Summary: successfully parsed JSON") + logger.info("Retrieve_Summary: successfully parsed JSON") except json.JSONDecodeError: # Try unescaping first try: unescaped = inner.encode('utf-8').decode('unicode_escape') parsed = json.loads(unescaped) - logger.info(f"Retrieve_Summary: parsed after unescaping") + logger.info("Retrieve_Summary: parsed after unescaping") except (json.JSONDecodeError, UnicodeDecodeError) as e: logger.error( f"Retrieve_Summary: parsing failed even after unescape: {e}" @@ -249,10 +249,10 @@ async def Retrieve_Summary( context_dict = context else: context_dict = {"Query": "", "Expansion_issue": []} - + query = context_dict.get("Query", "") expansion_issue = context_dict.get("Expansion_issue", []) - + # Extract retrieve_info from expansion_issue retrieve_info = [] for item in expansion_issue: @@ -263,7 +263,7 @@ async def Retrieve_Summary( answer = item["Answer_Small"] elif "Answer_Samll" in item: answer = item["Answer_Samll"] - + if answer is not None: # Handle both string and list formats if isinstance(answer, list): @@ -273,14 +273,15 @@ async def Retrieve_Summary( retrieve_info.append(answer) else: retrieve_info.append(str(answer)) - + # Join all retrieve_info into a single string retrieve_info_str = '\n\n'.join(retrieve_info) if retrieve_info else "" - # Get conversation history + start_time=time.time() history = await session_service.get_history(sessionid, apply_id, group_id) # Override with empty list for now (as in original) - + end_time=time.time() + logger.info(f"Retrieve_Summary-REDIS搜索：{end_time - start_time}") except Exception as e: logger.error( f"Retrieve_Summary: initialization failed: {e}", @@ -290,7 +291,7 @@ async def Retrieve_Summary( "status": "error", "summary_result": "信息不足，无法回答" } - + try: # Render template system_prompt = await template_service.render_template( @@ -309,14 +310,14 @@ async def Retrieve_Summary( "status": "error", "message": f"Prompt rendering failed: {str(e)}" } - + try: # Call LLM with structured response structured = await llm_client.response_structured( messages=[{"role": "system", "content": system_prompt}], response_model=RetrieveSummaryResponse ) - + # Handle case where structured response might be None or incomplete if structured and hasattr(structured, 'data') and structured.data: aimessages = structured.data.query_answer or "" @@ -324,7 +325,7 @@ async def Retrieve_Summary( logger.warning("Structured response is None or incomplete, using default message") aimessages = "信息不足，无法回答" - + # Check for insufficient information response if '信息不足，无法回答' not in str(aimessages) or str(aimessages)!="": # Save session @@ -344,13 +345,13 @@ async def Retrieve_Summary( aimessages = "" # Cleanup duplicate sessions await session_service.cleanup_duplicates() - + # Use fallback if empty if aimessages == '': aimessages = '信息不足，无法回答' - + logger.info(f"检索之后的总结==>>:{aimessages}") - + # Log execution time end = time.time() try: @@ -358,7 +359,7 @@ async def Retrieve_Summary( except Exception: duration = 0.0 log_time('检索总结', duration) - + # Emit intermediate output for frontend return { "status": "success", @@ -388,7 +389,7 @@ async def Input_Summary( ) -> dict: """ Generate a quick summary for direct input without verification. - + Args: ctx: FastMCP context for dependency injection context: String containing the input sentence @@ -398,44 +399,46 @@ async def Input_Summary( group_id: Group identifier storage_type: Storage type for the workspace (e.g., 'rag', 'vector') user_rag_memory_id: User RAG memory identifier - + Returns: dict: Contains 'query_answer' with the summary result """ start = time.time() logger.info(f"Input_Summary: storage_type={storage_type}, user_rag_memory_id={user_rag_memory_id}") - + # Initialize variables to avoid UnboundLocalError - + try: # Extract services from context template_service = get_context_resource(ctx, 'template_service') session_service = get_context_resource(ctx, 'session_service') llm_client = get_context_resource(ctx, 'llm_client') search_service = get_context_resource(ctx, 'search_service') - + # Check if llm_client is None if llm_client is None: error_msg = "LLM client is not available. Please check server configuration and SELECTED_LLM_ID environment variable." logger.error(error_msg) return error_msg - + # Resolve session ID sessionid = Resolve_username(usermessages) or "" sessionid = sessionid.replace('call_id_', '') - - # Get conversation history + + start_time=time.time() history = await session_service.get_history( str(sessionid), str(apply_id), str(group_id) ) + end_time=time.time() + logger.info(f"Input_Summary-REDIS搜索：{end_time - start_time}") # Override with empty list for now (as in original) - + # Log the raw context for debugging logger.info(f"Input_Summary: Received context type={type(context)}, value={context[:200] if isinstance(context, str) else context}") - + # Extract sentence from context # Context can be a string or might contain the sentence in various formats try: @@ -457,23 +460,23 @@ async def Input_Summary( except Exception as e: logger.warning(f"Failed to extract query from context: {e}") query = context - + # Clean query query = str(query).strip().strip("\"'") - + logger.debug(f"Input_Summary: Extracted query='{query}' from context type={type(context)}") - + # Execute search based on search_switch and storage_type try: logger.info(f"search_switch: {search_switch}, storage_type: {storage_type}") - + # Prepare search parameters based on storage type search_params = { "group_id": group_id, "question": query, "return_raw_results": True } - + # Add storage-specific parameters '''检索''' @@ -509,10 +512,10 @@ async def Input_Summary( logger.info(f"知识库没有检索的内容{user_rag_memory_id}") else: retrieve_info, question, raw_results = await search_service.execute_hybrid_search(**search_params) - logger.info(f"Input_Summary: 使用 summary 进行检索") + logger.info("Input_Summary: 使用 summary 进行检索") else: retrieve_info, question, raw_results = await search_service.execute_hybrid_search(**search_params) - + except Exception as e: logger.error( f"Input_Summary: hybrid_search failed, using empty results: {e}", @@ -520,7 +523,7 @@ async def Input_Summary( ) retrieve_info, question, raw_results = "", query, [] - + # Render template system_prompt = await template_service.render_template( template_name='Retrieve_Summary_prompt.jinja2', @@ -529,7 +532,7 @@ async def Input_Summary( history=history, retrieve_info=retrieve_info ) - + # Call LLM with structured response try: structured = await llm_client.response_structured( @@ -543,9 +546,9 @@ async def Input_Summary( exc_info=True ) aimessages = "信息不足，无法回答" - + logger.info(f"快速答案总结==>>:{storage_type}--{user_rag_memory_id}--{aimessages}") - + # Emit intermediate output for frontend return { "status": "success", @@ -563,7 +566,7 @@ async def Input_Summary( "user_rag_memory_id": user_rag_memory_id } } - + except Exception as e: logger.error( f"Input_Summary failed: {e}", @@ -576,7 +579,7 @@ async def Input_Summary( "user_rag_memory_id": user_rag_memory_id, "error": str(e) } - + finally: # Log execution time end = time.time() @@ -599,7 +602,7 @@ async def Summary_fails( ) -> dict: """ Handle workflow failure when summary cannot be generated. - + Args: ctx: FastMCP context for dependency injection context: Failure context string @@ -608,22 +611,22 @@ async def Summary_fails( group_id: Group identifier storage_type: Storage type for the workspace (optional) user_rag_memory_id: User RAG memory identifier (optional) - + Returns: dict: Contains 'query_answer' with failure message """ try: # Extract services from context session_service = get_context_resource(ctx, 'session_service') - + # Parse session ID from usermessages usermessages_parts = usermessages.split('_')[1:] sessionid = '_'.join(usermessages_parts[:-1]) - + # Cleanup duplicate sessions await session_service.cleanup_duplicates() - - logger.info(f"没有相关数据") + + logger.info("没有相关数据") logger.debug(f"Summary_fails called with apply_id: {apply_id}, group_id: {group_id}") return { diff --git a/api/app/core/memory/agent/mcp_server/tools/verification_tools.py b/api/app/core/memory/agent/mcp_server/tools/verification_tools.py index 652386c7..fb3ca561 100644 --- a/api/app/core/memory/agent/mcp_server/tools/verification_tools.py +++ b/api/app/core/memory/agent/mcp_server/tools/verification_tools.py @@ -78,7 +78,7 @@ async def Verify( # Build query list for verification query_list = [] - for query_small, anser in zip(Query_small, Result_small): + for query_small, anser in zip(Query_small, Result_small, strict=False): query_list.append({ 'Query_small': query_small, 'Answer_Small': anser diff --git a/api/app/core/memory/agent/multimodal/oss_picture.py b/api/app/core/memory/agent/multimodal/oss_picture.py new file mode 100644 index 00000000..b5b4bd6b --- /dev/null +++ b/api/app/core/memory/agent/multimodal/oss_picture.py @@ -0,0 +1,114 @@ +import os +import sys +import traceback + +import requests + +# from qcloud_cos import CosConfig, CosS3Client +# from qcloud_cos.cos_exception import CosClientError, CosServiceError + +# from config.paths import BASE_DIR +BASE_DIR = os.path.dirname(os.path.realpath(sys.argv[0])) + +class OSSUploader: + """对象存储文件上传工具类""" + + def __init__(self, env): + api = { + "test": "https://testlingqi.redbearai.com/api/user/file/common/upload/v2/anon", + "prod": "https://lingqi.redbearai.com/api/user/file/common/upload/v2/anon" + } + self.api = api.get(env, "https://testlingqi.redbearai.com/api/user/file/common/upload/v2/anon") + self.privacy = "false" + self.headers = { + "User-Agent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) ' + 'AppleWebKit/537.36 (KHTML, like Gecko)' + ' Chrome/133.0.6833.84 Safari/537.36' + } + + @staticmethod + def _generate_object_key(file_path, prefix='xhs_'): + """ + 生成对象存储的Key + + :param file_path: 本地文件路径 + :param prefix: 存储前缀，用于分类存储 + :return: 生成的对象Key + """ + # 文件md5值.后缀名 + filename = os.path.basename(file_path) + filename = f"{filename}" + + # 组合成完整的对象Key + return f"{prefix}{filename}" + + def upload_image(self, file_name, prefix='jd_'): + """ + 上传文件到COS并返回可访问的URL + + :param file_url: 文件路径 + :param file_name: 文件名称 + :param media_type: 文件类型 + :param prefix: 存储前缀，用于分类存储 + :return: 文件访问URL + """ + # 检查文件是否存在 + + + + file_path = os.path.join(BASE_DIR, file_name) + + # response = requests.get(url, headers=self.headers, stream=True) + + # if response.status_code == 200: + # with open(file_path, "wb") as f: + # for chunk in response.iter_content(1024): # 分块写入，避免内存占用过大 + # f.write(chunk) + # else: + # raise Exception(f"文件下载失败,{file_name}") + + # 生成对象Key + object_key = self._generate_object_key(file_path, prefix +file_name.split('.')[-1]) + + try: + upload_response = requests.post( + self.api, + data={ + "privacy": self.privacy, + "fileName": object_key, + } + ) + + if upload_response.status_code != 200: + raise Exception('上传接口请求失败') + resp = upload_response.json() + name = resp["data"]["name"] + file_url = resp["data"]["path"] + policy = resp["data"]["policy"] + with open(file_path, 'rb') as f: + oss_push_resp = requests.post( + policy["host"], + files={ + "key": policy["dir"], + "OSSAccessKeyId": policy["accessid"], + "name": name, + "policy": policy["policy"], + "success_action_status": 200, + "signature": policy["signature"], + "file": f, + } + ) + if oss_push_resp.status_code == 200: + return file_url + raise Exception("OSS上传失败") + except Exception: + raise Exception(f"上传失败: \n{traceback.format_exc()}") + finally: + print('success') + # os.remove(file_path) + + +if __name__ == '__main__': + cos_uploader = OSSUploader("prod") + url =cos_uploader.upload_image('./example01.jpg') + print(url) diff --git a/api/app/core/memory/agent/multimodal/speech_model.py b/api/app/core/memory/agent/multimodal/speech_model.py new file mode 100644 index 00000000..2df32dd0 --- /dev/null +++ b/api/app/core/memory/agent/multimodal/speech_model.py @@ -0,0 +1,121 @@ +import asyncio +import re + +from app.core.memory.agent.utils.llm_tools import PROJECT_ROOT_, picture_model_requests,Picture_recognize, Voice_recognize +from app.core.memory.agent.utils.messages_tool import read_template_file + +import requests +import json +import os +import time +# file_urls = [ +# "https://dashscope.oss-cn-beijing.aliyuncs.com/samples/audio/paraformer/hello_world_female2.wav", +# "https://dashscope.oss-cn-beijing.aliyuncs.com/samples/audio/paraformer/hello_world_male2.wav", +# ] +class Vico_recognition: + def __init__(self,file_urls): + self.api_key='' + self.backend_model_name='' + self.api_base='' + self.file_urls=file_urls + + # 提交文件转写任务，包含待转写文件url列表 + async def submit_task(self) -> str: + self.api_key, self.backend_model_name, self.api_base =await Voice_recognize() + + headers = { + "Authorization": f"Bearer {self.api_key}", + "Content-Type": "application/json", + "X-DashScope-Async": "enable", + } + data = { + "model": self.backend_model_name, + "input": {"file_urls": self.file_urls}, + "parameters": { + "channel_id": [0], + "vocabulary_id": "vocab-Xxxx", + }, + } + # 录音文件转写服务url + service_url = ( + "https://dashscope.aliyuncs.com/api/v1/services/audio/asr/transcription" + ) + response = requests.post( + service_url, headers=headers, data=json.dumps(data) + ) + + # 打印响应内容 + if response.status_code == 200: + return response.json()["output"]["task_id"] + else: + print("task failed!") + print(response.json()) + return None + + async def download_transcription_result(self, transcription_url): + """ + Args: + transcription_url (str): 转写结果文件URL + Returns: + dict: 转写结果内容 + """ + try: + response = requests.get(transcription_url) + response.raise_for_status() + return response.json() + except Exception as e: + print(f"下载转写结果失败: {e}") + return None + + # 循环查询任务状态直到成功 + async def wait_for_complete(self,task_id): + self.api_key, self.backend_model_name, self.api_base = await Voice_recognize() + headers = { + "Authorization": f"Bearer {self.api_key}", + "Content-Type": "application/json", + "X-DashScope-Async": "enable", + } + + pending = True + while pending: + # 查询任务状态服务url + service_url = f"https://dashscope.aliyuncs.com/api/v1/tasks/{task_id}" + response = requests.post( + service_url, headers=headers + ) + if response.status_code == 200: + status = response.json()['output']['task_status'] + if status == 'SUCCEEDED': + print("task succeeded!") + pending = False + return response.json()['output']['results'] + elif status == 'RUNNING' or status == 'PENDING': + pass + else: + print("task failed!") + pending = False + else: + print("query failed!") + pending = False + time.sleep(0.1) + async def run(self): + self.api_key, self.backend_model_name, self.api_base = await Voice_recognize() + task_id=await self.submit_task() + result=await self.wait_for_complete(task_id) + result_context=[] + for i in result: + transcription_url=i['transcription_url'] + print(f"转写URL: {transcription_url}") + + # 下载并打印转写内容 + content = await self.download_transcription_result(transcription_url) + if content: + content=json.dumps(content, indent=2, ensure_ascii=False) + context=re.findall(r'"text": "(.*?)"', content) + result_context.append(context[0]) + result=''.join(result_context) + return (result) + + + + diff --git a/api/app/core/memory/agent/utils/llm_tools.py b/api/app/core/memory/agent/utils/llm_tools.py index e314dd09..f626db82 100644 --- a/api/app/core/memory/agent/utils/llm_tools.py +++ b/api/app/core/memory/agent/utils/llm_tools.py @@ -16,31 +16,13 @@ from app.core.memory.utils.config.config_utils import get_picture_config, get_vo from app.core.memory.utils.llm.llm_utils import get_llm_client from app.core.memory.utils.config.definitions import SELECTED_LLM_ID, SELECTED_LLM_PICTURE_NAME, SELECTED_LLM_VOICE_NAME from app.core.models.base import RedBearModelConfig -from app.core.memory.src.llm_tools.openai_client import OpenAIClient +from app.core.memory.llm_tools.openai_client import OpenAIClient PROJECT_ROOT_ = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) logger = logging.getLogger(__name__) load_dotenv() -#TODO: Refactor entire picture/voice -# async def LLM_model_request(context,data,query): -# ''' -# Agent model request -# Args: -# context:Input request -# data: template parameters -# query:request content -# Returns: - -# ''' -# template = Template(context) -# system_prompt = template.render(**data) -# llm_client = get_llm_client(SELECTED_LLM_ID) -# result = await llm_client.chat( -# messages=[{"role": "system", "content": system_prompt}] + [{"role": "user", "content": query}] -# ) -# return result async def picture_model_requests(image_url): ''' @@ -106,33 +88,9 @@ class COUNTState: def reset(self): """手动重置累加值""" self.total = 0 - print(f"[COUNTState] 已重置为 0") + print("[COUNTState] 已重置为 0") - -# def embed(texts: list[str]) -> list[list[float]]: -# # 这里可以换成 LangChain Embeddings -# return [[float(len(t) % 5), float(len(t) % 3)] for t in texts] - - -# def export_store_to_json(store, namespace): -# """Export the entire storage content to a JSON file""" -# # 搜索所有存储项 -# all_items = store.search(namespace) - -# # 整理数据 -# export_data = {} -# for item in all_items: -# if hasattr(item, 'key') and hasattr(item, 'value'): -# export_data[item.key] = item.value - -# # 保存到文件 -# os.makedirs("memory_logs", exist_ok=True) -# with open("memory_logs/full_memory_export.json", "w", encoding="utf-8") as f: -# json.dump(export_data, f, ensure_ascii=False, indent=2) - -# print(f"{len(export_data)} 条记忆到 JSON 文件") - def merge_to_key_value_pairs(data, query_key, result_key): grouped = defaultdict(list) for item in data: diff --git a/api/app/core/memory/agent/utils/mcp_tools.py b/api/app/core/memory/agent/utils/mcp_tools.py index e32b8ef3..7ede9843 100644 --- a/api/app/core/memory/agent/utils/mcp_tools.py +++ b/api/app/core/memory/agent/utils/mcp_tools.py @@ -1,12 +1,30 @@ +import os from app.core.config import settings def get_mcp_server_config(): """ - Get the MCP server configuration + Get the MCP server configuration. + + Uses MCP_SERVER_URL environment variable if set (for Docker), + otherwise falls back to SERVER_IP and MCP_PORT (for local development). """ + # Get MCP port from environment (default: 8081) + mcp_port = os.getenv("MCP_PORT", "8081") + + # In Docker: MCP_SERVER_URL=http://mcp-server:8081 + # In local dev: uses SERVER_IP (127.0.0.1 or localhost) + mcp_server_url = os.getenv("MCP_SERVER_URL") + + if mcp_server_url: + # Docker environment: use full URL from environment + base_url = mcp_server_url + else: + # Local development: build URL from SERVER_IP and MCP_PORT + base_url = f"http://{settings.SERVER_IP}:{mcp_port}" + mcp_server_config = { "data_flow": { - "url": f"http://{settings.SERVER_IP}:8081/sse", # 你前面的 FastMCP(weather) 服务端口 + "url": f"{base_url}/sse", "transport": "sse", "timeout": 15000, "sse_read_timeout": 15000, diff --git a/api/app/core/memory/agent/utils/messages_tool.py b/api/app/core/memory/agent/utils/messages_tool.py index 273bc719..ec69e925 100644 --- a/api/app/core/memory/agent/utils/messages_tool.py +++ b/api/app/core/memory/agent/utils/messages_tool.py @@ -191,9 +191,9 @@ async def VerifyTool_messages_deal(context): messages = str(context).replace('\\n', '').replace('\n', '').replace('\\', '') content_messages = messages.split('"context":')[1].replace('""', '"') messages = str(content_messages).split("name='Retrieve'")[0] - query = re.findall(f'"Query": "(.*?)"', messages)[0] - Query_small = re.findall(f'"Query_small": "(.*?)"', messages) - Result_small = re.findall(f'"Result_small": "(.*?)"', messages) + query = re.findall('"Query": "(.*?)"', messages)[0] + Query_small = re.findall('"Query_small": "(.*?)"', messages) + Result_small = re.findall('"Result_small": "(.*?)"', messages) return Query_small, Result_small, query diff --git a/api/app/core/memory/agent/utils/multimodal.py b/api/app/core/memory/agent/utils/multimodal.py index 439c46b7..0fc52634 100644 --- a/api/app/core/memory/agent/utils/multimodal.py +++ b/api/app/core/memory/agent/utils/multimodal.py @@ -7,8 +7,8 @@ This module provides utilities for detecting and processing multimodal inputs import logging from typing import List -# TODO 后续更新 -# from app.core.memory.agent.multimodal.speech_model import Vico_recognition + +from app.core.memory.agent.multimodal.speech_model import Vico_recognition from app.core.memory.agent.utils.llm_tools import picture_model_requests logger = logging.getLogger(__name__) @@ -124,7 +124,7 @@ class MultimodalProcessor: except Exception as e: logger.error(f"[MultimodalProcessor] Error processing multimodal input: {e}", exc_info=True) - logger.info(f"[MultimodalProcessor] Falling back to original content") + logger.info("[MultimodalProcessor] Falling back to original content") return content # Return original content if not multimodal diff --git a/api/app/core/memory/agent/utils/redis_tool.py b/api/app/core/memory/agent/utils/redis_tool.py index 68c16e1d..31a76a11 100644 --- a/api/app/core/memory/agent/utils/redis_tool.py +++ b/api/app/core/memory/agent/utils/redis_tool.py @@ -2,24 +2,47 @@ import redis import uuid from datetime import datetime from app.core.config import settings -class RedisSessionStore: - def __init__(self, host='localhost', port=6379, db=0, password=None,session_id=''): - self.r = redis.Redis(host=host, port=port, db=db, password=password) - self.uudi=session_id +class RedisSessionStore: + def __init__(self, host='localhost', port=6379, db=0, password=None, session_id=''): + self.r = redis.Redis( + host=host, + port=port, + db=db, + password=password, + decode_responses=True, + encoding='utf-8' + ) + self.uudi = session_id + + def _fix_encoding(self, text): + """修复错误编码的文本""" + if not text or not isinstance(text, str): + return text + try: + # 尝试修复 Latin-1 误编码为 UTF-8 的情况 + return text.encode('latin-1').decode('utf-8') + except (UnicodeDecodeError, UnicodeEncodeError): + # 如果修复失败，返回原文本 + return text + # 修改后的 save_session 方法 def save_session(self, userid, messages, aimessages, apply_id, group_id): """ 写入一条会话数据，返回 session_id + 优化版本：确保写入时间不超过1秒 """ try: session_id = str(uuid.uuid4()) # 为每次会话生成新的 ID starttime = datetime.now().strftime("%Y-%m-%d %H:%M:%S") key = f"session:{session_id}" # 使用新生成的 session_id 作为 key - # 使用 Hash 存储结构化数据 - result = self.r.hset(key, mapping={ + # 使用 pipeline 批量写入，减少网络往返 + pipe = self.r.pipeline() + + # 直接写入数据，decode_responses=True 已经处理了编码 + pipe.hset(key, mapping={ "id": self.uudi, "sessionid": userid, "apply_id": apply_id, @@ -28,12 +51,54 @@ class RedisSessionStore: "aimessages": aimessages, "starttime": starttime }) - print(f"保存结果: {result}, session_id: {session_id}") + + # 可选：设置过期时间（例如30天），避免数据无限增长 + # pipe.expire(key, 30 * 24 * 60 * 60) + + # 执行批量操作 + result = pipe.execute() + + print(f"保存结果: {result[0]}, session_id: {session_id}") return session_id # 返回新生成的 session_id except Exception as e: print(f"保存会话失败: {e}") raise e + def save_sessions_batch(self, sessions_data): + """ + 批量写入多条会话数据，返回 session_id 列表 + sessions_data: list of dict, 每个 dict 包含 userid, messages, aimessages, apply_id, group_id + 优化版本：批量操作，大幅提升性能 + """ + try: + session_ids = [] + pipe = self.r.pipeline() + + for session in sessions_data: + session_id = str(uuid.uuid4()) + starttime = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + key = f"session:{session_id}" + + pipe.hset(key, mapping={ + "id": self.uudi, + "sessionid": session.get('userid'), + "apply_id": session.get('apply_id'), + "group_id": session.get('group_id'), + "messages": session.get('messages'), + "aimessages": session.get('aimessages'), + "starttime": starttime + }) + + session_ids.append(session_id) + + # 一次性执行所有写入操作 + results = pipe.execute() + print(f"批量保存完成: {len(session_ids)} 条记录") + return session_ids + except Exception as e: + print(f"批量保存会话失败: {e}") + raise e + # ---------------- 读取 ---------------- def get_session(self, session_id): """ @@ -41,9 +106,7 @@ class RedisSessionStore: """ key = f"session:{session_id}" data = self.r.hgetall(key) - if data: - return {k.decode('utf-8'): v.decode('utf-8') for k, v in data.items()} - return None + return data if data else None def get_session_apply_group(self, sessionid, apply_id, group_id): """ @@ -52,21 +115,17 @@ class RedisSessionStore: result_items = [] # 遍历所有会话数据 - for key_bytes in self.r.keys('session:*'): - key = key_bytes.decode('utf-8') + for key in self.r.keys('session:*'): data = self.r.hgetall(key) if not data: continue - # 解码数据 - decoded_data = {k.decode('utf-8'): v.decode('utf-8') for k, v in data.items()} - # 检查三个条件是否都匹配 - if (decoded_data.get('sessionid') == sessionid and - decoded_data.get('apply_id') == apply_id and - decoded_data.get('group_id') == group_id): - result_items.append(decoded_data) + if (data.get('sessionid') == sessionid and + data.get('apply_id') == apply_id and + data.get('group_id') == group_id): + result_items.append(data) return result_items @@ -76,7 +135,7 @@ class RedisSessionStore: """ sessions = {} for key in self.r.keys('session:*'): - sid = key.decode('utf-8').split(':')[1] + sid = key.split(':')[1] sessions[sid] = self.get_session(sid) return sessions @@ -84,12 +143,14 @@ class RedisSessionStore: def update_session(self, session_id, field, value): """ 更新单个字段 + 优化版本：使用 pipeline 减少网络往返 """ key = f"session:{session_id}" - if self.r.exists(key): - self.r.hset(key, field, value) - return True - return False + pipe = self.r.pipeline() + pipe.exists(key) + pipe.hset(key, field, value) + results = pipe.execute() + return bool(results[0]) # 返回 key 是否存在 # ---------------- 删除 ---------------- def delete_session(self, session_id): @@ -112,38 +173,67 @@ class RedisSessionStore: """ 删除重复会话数据，条件： "sessionid"、"user_id"、"group_id"、"messages"、"aimessages" 五个字段都相同的只保留一个，其他删除 + 优化版本：使用 pipeline 批量操作，确保在1秒内完成 """ - seen = set() # 用来记录已出现的唯一组合 - deleted_count = 0 + import time + start_time = time.time() - for key_bytes in self.r.keys('session:*'): - key = key_bytes.decode('utf-8') - data = self.r.hgetall(key) + # 第一步：使用 pipeline 批量获取所有 key + keys = self.r.keys('session:*') + + if not keys: + print("[delete_duplicate_sessions] 没有会话数据") + return 0 + + # 第二步：使用 pipeline 批量获取所有数据 + pipe = self.r.pipeline() + for key in keys: + pipe.hgetall(key) + all_data = pipe.execute() + + # 第三步：在内存中识别重复数据 + seen = {} # 用字典记录：identifier -> key（保留第一个出现的 key） + keys_to_delete = [] # 需要删除的 key 列表 + + for key, data in zip(keys, all_data, strict=False): if not data: continue - # 获取五个字段的值并解码 - sessionid = data.get(b'sessionid', b'').decode('utf-8') - user_id = data.get(b'id', b'').decode('utf-8') # 对应user_id - group_id = data.get(b'group_id', b'').decode('utf-8') - messages = data.get(b'messages', b'').decode('utf-8') - aimessages = data.get(b'aimessages', b'').decode('utf-8') + # 获取五个字段的值 + sessionid = data.get('sessionid', '') + user_id = data.get('id', '') + group_id = data.get('group_id', '') + messages = data.get('messages', '') + aimessages = data.get('aimessages', '') # 用五元组作为唯一标识 identifier = (sessionid, user_id, group_id, messages, aimessages) if identifier in seen: - # 重复，删除该 key - self.r.delete(key) - deleted_count += 1 + # 重复，标记为待删除 + keys_to_delete.append(key) else: - # 第一次出现，加入 seen - seen.add(identifier) + # 第一次出现，记录 + seen[identifier] = key - print(f"[delete_duplicate_sessions] 删除重复会话数量: {deleted_count}") + # 第四步：使用 pipeline 批量删除重复的 key + deleted_count = 0 + if keys_to_delete: + # 分批删除，避免单次操作过大 + batch_size = 1000 + for i in range(0, len(keys_to_delete), batch_size): + batch = keys_to_delete[i:i + batch_size] + pipe = self.r.pipeline() + for key in batch: + pipe.delete(key) + pipe.execute() + deleted_count += len(batch) + + elapsed_time = time.time() - start_time + print(f"[delete_duplicate_sessions] 删除重复会话数量: {deleted_count}, 耗时: {elapsed_time:.3f}秒") return deleted_count - def find_user_session(self,sessionid): + def find_user_session(self, sessionid): user_id = sessionid result_items = [] @@ -160,44 +250,62 @@ class RedisSessionStore: def find_user_apply_group(self, sessionid, apply_id, group_id): """ - 根据 sessionid、apply_id 和 group_id 三个条件查询会话数据 + 根据 sessionid、apply_id 和 group_id 三个条件查询会话数据，返回最新的6条 """ - result_items = [] + import time + start_time = time.time() + # 使用 pipeline 批量获取数据，提高性能 + keys = self.r.keys('session:*') - # 遍历所有会话数据 - for key_bytes in self.r.keys('session:*'): - key = key_bytes.decode('utf-8') - data = self.r.hgetall(key) + if not keys: + print(f"查询耗时: {time.time() - start_time:.3f}秒, 结果数: 0") + return [] + # 使用 pipeline 批量获取所有 hash 数据 + pipe = self.r.pipeline() + for key in keys: + pipe.hgetall(key) + all_data = pipe.execute() + + # 解析并筛选符合条件的数据 + matched_items = [] + for data in all_data: if not data: continue - # 解码数据 - decoded_data = {k.decode('utf-8'): v.decode('utf-8') for k, v in data.items()} + # 检查是否符合三个条件 - - # 检查三个条件是否都匹配 - if (decoded_data.get('sessionid') == sessionid and - decoded_data.get('apply_id') == apply_id and - decoded_data.get('group_id') == group_id): - history = { - "Query": decoded_data.get('messages'), - "Answer": decoded_data.get('aimessages') - } - - - result_items.append(history) + if (data.get('apply_id') == apply_id and + data.get('group_id') == group_id): + # 支持模糊匹配 sessionid 或者完全匹配 + if sessionid in data.get('sessionid', '') or data.get('sessionid') == sessionid: + matched_items.append({ + "Query": self._fix_encoding(data.get('messages')), + "Answer": self._fix_encoding(data.get('aimessages')), + "starttime": data.get('starttime', '') + }) + # 按时间降序排序（最新的在前） + matched_items.sort(key=lambda x: x.get('starttime', ''), reverse=True) + # 只保留最新的6条 + result_items = matched_items[:6] + # # 移除 starttime 字段 + for item in result_items: + item.pop('starttime', None) # 如果结果少于等于1条，返回空列表 if len(result_items) <= 1: result_items = [] + elapsed_time = time.time() - start_time + print(f"查询耗时: {elapsed_time:.3f}秒, 结果数: {len(result_items)}") + return result_items + store = RedisSessionStore( host=settings.REDIS_HOST, port=settings.REDIS_PORT, db=settings.REDIS_DB, password=settings.REDIS_PASSWORD if settings.REDIS_PASSWORD else None, session_id=str(uuid.uuid4()) -) +) \ No newline at end of file diff --git a/api/app/core/memory/agent/utils/verify_tool.py b/api/app/core/memory/agent/utils/verify_tool.py index 5e1ce897..a6cce18a 100644 --- a/api/app/core/memory/agent/utils/verify_tool.py +++ b/api/app/core/memory/agent/utils/verify_tool.py @@ -44,7 +44,7 @@ class VerifyTool: async def model_1(self, state: State) -> State: llm_client = get_llm_client(SELECTED_LLM_ID) response_content = await llm_client.chat( - messages=[{"role": "system", "content": self.system_prompt}] + _to_openai_messages(state["messages"]) + messages=[{"role": "system", "content": self.system_prompt}, *_to_openai_messages(state["messages"])] ) return { "agent1_response": response_content, diff --git a/api/app/core/memory/agent/utils/write_tools.py b/api/app/core/memory/agent/utils/write_tools.py index a535fe9d..fcb1b8a4 100644 --- a/api/app/core/memory/agent/utils/write_tools.py +++ b/api/app/core/memory/agent/utils/write_tools.py @@ -63,7 +63,7 @@ async def write(content: str, user_id: str, apply_id: str, group_id: str, ref_id # 获取 embedder 配置 from app.core.models.base import RedBearModelConfig from app.core.memory.utils.config.config_utils import get_embedder_config - from app.core.memory.src.llm_tools.openai_embedder import OpenAIEmbedderClient + from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient embedder_config_dict = get_embedder_config(config_defs.SELECTED_EMBEDDING_ID) embedder_config = RedBearModelConfig(**embedder_config_dict) diff --git a/api/app/core/memory/analytics/__init__.py b/api/app/core/memory/analytics/__init__.py new file mode 100644 index 00000000..06aeaed3 --- /dev/null +++ b/api/app/core/memory/analytics/__init__.py @@ -0,0 +1,23 @@ +""" +Memory Analytics Module + +This module provides analytics and insights for the memory system. + +Available functions: +- get_hot_memory_tags: Get hot memory tags by frequency +- MemoryInsight: Generate memory insight reports +- get_recent_activity_stats: Get recent activity statistics +- generate_user_summary: Generate user summary +""" + +from app.core.memory.analytics.hot_memory_tags import get_hot_memory_tags +from app.core.memory.analytics.memory_insight import MemoryInsight +from app.core.memory.analytics.recent_activity_stats import get_recent_activity_stats +from app.core.memory.analytics.user_summary import generate_user_summary + +__all__ = [ + "get_hot_memory_tags", + "MemoryInsight", + "get_recent_activity_stats", + "generate_user_summary", +] diff --git a/api/app/core/memory/analytics/api_docs_parser.py b/api/app/core/memory/analytics/api_docs_parser.py new file mode 100644 index 00000000..94ed0f00 --- /dev/null +++ b/api/app/core/memory/analytics/api_docs_parser.py @@ -0,0 +1,198 @@ +import os +import re +from typing import Dict, Any, List, Tuple + + +def _parse_meta_block(md_text: str) -> Dict[str, Any]: + sections: Dict[str, Any] = {} + m = re.search(r"```javascript([\s\S]*?)```", md_text) + if not m: + return sections + block = m.group(1) + search_opts: List[Dict[str, Any]] = [] + status_codes: List[Dict[str, Any]] = [] + for line in block.splitlines(): + s = line.strip() + if not s: + continue + msw = re.match(r"search_switch：?(\d+)\s*(?:（(.*?)）)?", s) + if msw: + val = msw.group(1) + desc = msw.group(2) or "" + search_opts.append({"value": val, "desc": desc}) + continue + mcode = re.match(r"code:(\d+)\.\s*(.*)", s) + if mcode: + code = mcode.group(1) + desc = mcode.group(2).strip() + status_codes.append({"code": code, "desc": desc}) + continue + if search_opts: + sections["search_switch"] = search_opts + if status_codes: + sections["status_code"] = status_codes + return sections + + +def _extract_code_block(md_lines: List[str], start_idx: int) -> Tuple[str, int]: + content_lines: List[str] = [] + i = start_idx + while i < len(md_lines) and md_lines[i].strip() == "": + i += 1 + if i >= len(md_lines): + return "", i + start_line = md_lines[i].strip() + if not re.match(r"^`{3,}.*", start_line): + return "", i + i += 1 + while i < len(md_lines): + line = md_lines[i] + if re.match(r"^`{3,}.*", line.strip()): + i += 1 + break + content_lines.append(line) + i += 1 + return "\n".join(content_lines).strip(), i + + +def _parse_sections(md_text: str) -> List[Dict[str, Any]]: + lines = md_text.splitlines() + sections: List[Dict[str, Any]] = [] + i = 0 + current: Dict[str, Any] | None = None + + def _clean_inline(s: str) -> str: + s = s.strip() + if s.startswith("`") and s.endswith("`"): + s = s[1:-1] + return s.strip() + + while i < len(lines): + line = lines[i] + if line.startswith("# ") and "：" in line: + name = line.split("：", 1)[1].strip() + current = {"name": name} + sections.append(current) + i += 1 + continue + if current is not None and line.strip().startswith("### "): + s = line.strip() + if "请求端口" in s: + m = re.search(r"请求端口(.*)$", s) + if m: + current["path"] = _clean_inline(m.group(1)) + i += 1 + continue + if "请求方式" in s: + m = re.search(r"请求方式[：:](.*)$", s) + if m: + current["method"] = _clean_inline(m.group(1)) + i += 1 + continue + if s.startswith("### 描述"): + i += 1 + desc_lines: List[str] = [] + while i < len(lines): + nl = lines[i] + if nl.strip().startswith("### "): + break + if re.match(r"^`{3,}.*", nl.strip()): + break + desc_lines.append(nl.strip()) + i += 1 + current["desc"] = "\n".join([x for x in desc_lines if x]).strip() or None + continue + if s.startswith("### 输入"): + if "无" in s: + current["input"] = "无" + i += 1 + else: + i += 1 + block, i = _extract_code_block(lines, i) + current["input"] = block or None + continue + if s.startswith("### 输出"): + i += 1 + block, i = _extract_code_block(lines, i) + current["output"] = block or None + continue + if s.startswith("### 请求体参数"): + i += 1 + params, i = _parse_body_params_table(lines, i) + if params: + current["body_params"] = params + continue + i += 1 + return sections + + +def parse_api_docs(file_path: str) -> Dict[str, Any]: + if not os.path.isfile(file_path): + raise FileNotFoundError(file_path) + with open(file_path, "r", encoding="utf-8") as f: + md_text = f.read() + m = re.search(r"^#\s*(.+)$", md_text, re.M) + title = m.group(1).strip() if m else "" + meta = _parse_meta_block(md_text) + sections = _parse_sections(md_text) + return {"title": title, "meta": meta, "sections": sections} + + +def get_default_docs_path() -> str: + project_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__))) + return os.path.join(project_root, "src", "analytics", "API接口.md") + + +def parse_api_docs_default() -> Dict[str, Any]: + return parse_api_docs(get_default_docs_path()) + + +def get_section_descriptions(file_path: str) -> Dict[str, str]: + data = parse_api_docs(file_path) + out: Dict[str, str] = {} + for s in data.get("sections", []): + name = s.get("name") + if not name: + continue + out[name] = s.get("desc") or "" + return out + + +def get_section_descriptions_default() -> Dict[str, str]: + return get_section_descriptions(get_default_docs_path()) + + +def _parse_body_params_table(md_lines: List[str], start_idx: int) -> Tuple[List[Dict[str, Any]], int]: + rows: List[str] = [] + i = start_idx + while i < len(md_lines) and md_lines[i].strip() == "": + i += 1 + if i >= len(md_lines) or not md_lines[i].strip().startswith("|"): + return [], i + header = md_lines[i].strip() + i += 1 + if i < len(md_lines) and md_lines[i].strip().startswith("|"): + i += 1 + while i < len(md_lines) and md_lines[i].strip().startswith("|"): + rows.append(md_lines[i].strip()) + i += 1 + headers = [h.strip() for h in header.strip('|').split('|')] + out: List[Dict[str, Any]] = [] + for r in rows: + cols = [c.strip() for c in r.strip('|').split('|')] + if len(cols) != len(headers): + continue + item: Dict[str, Any] = {} + for k, v in zip(headers, cols, strict=False): + if k == "参数名": + item["name"] = v + elif k == "类型": + item["type"] = v + elif k == "是否必填": + item["required"] = v + elif k == "描述": + item["desc"] = v + else: + item[k] = v + out.append(item) + return out, i diff --git a/api/app/core/memory/analytics/hot_memory_tags.py b/api/app/core/memory/analytics/hot_memory_tags.py new file mode 100644 index 00000000..0c68a567 --- /dev/null +++ b/api/app/core/memory/analytics/hot_memory_tags.py @@ -0,0 +1,204 @@ +import sys +import os +import asyncio +from neo4j import GraphDatabase +from typing import List, Tuple +from pydantic import BaseModel, Field + +# ------------------- 自包含路径解析 ------------------- +# 这个代码块确保脚本可以从任何地方运行，并且仍然可以在项目结构中找到它需要的模块。 +try: + # 假设脚本在 /path/to/project/src/analytics/ + # 上升3个级别以到达项目根目录。 + project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')) + src_path = os.path.join(project_root, 'src') + + # 将 'src' 和 'project_root' 都添加到路径中。 + # 'src' 目录对于像 'from utils.config_utils import ...' 这样的导入是必需的。 + # 'project_root' 目录对于像 'from variate_config import ...' 这样的导入是必需的。 + if src_path not in sys.path: + sys.path.insert(0, src_path) + if project_root not in sys.path: + sys.path.insert(0, project_root) +except NameError: + # 为 __file__ 未定义的环境（例如某些交互式解释器）提供回退方案 + project_root = os.path.abspath(os.path.join(os.getcwd())) + src_path = os.path.join(project_root, 'src') + if src_path not in sys.path: + sys.path.insert(0, src_path) + if project_root not in sys.path: + sys.path.insert(0, project_root) +# --------------------------------------------------------------------- + +# 现在路径已经配置好，我们可以使用绝对导入 +from app.core.config import settings +from app.core.memory.utils.config.definitions import SELECTED_GROUP_ID, SELECTED_LLM_ID +from app.core.memory.utils.llm.llm_utils import get_llm_client +import json + +# 定义用于LLM结构化输出的Pydantic模型 +class FilteredTags(BaseModel): + """用于接收LLM筛选后的核心标签列表的模型。""" + meaningful_tags: List[str] = Field(..., description="从原始列表中筛选出的具有核心代表意义的名词列表。") + +async def filter_tags_with_llm(tags: List[str], llm_client) -> List[str]: + """ + 使用LLM筛选标签列表，仅保留具有代表性的核心名词。 + """ + try: + + # 3. 构建Prompt + tag_list_str = ", ".join(tags) + messages = [ + { + "role": "system", + "content": "你是一位顶级的文本分析专家，任务是提炼、筛选并合并最具体、最核心的名词。你的目标是识别具体的事件、地点、物体或作品，并严格执行以下步骤：\n\n1. **筛选**: 严格过滤掉以下类型的词语：\n * **抽象概念或训练活动**: 任何描述抽象品质、训练项目或研究过程的词语（例如：'核心力量', '实际的历史研究', '团队合作'）。\n * **动作或过程词**: 任何描述具体动作或过程的词语（例如：'打篮球', '快攻', '远投'）。\n * **描述性短语**: 任何描述状态、关系或感受的短语（例如：'配合越来越默契'）。\n * **过于宽泛的类别**: 过于笼统的分类（例如：'历史剧'）。\n\n2. **合并**: 在筛选后，对语义相近或存在包含关系的词语进行合并，只保留最核心、最具代表性的一个。\n * 例如，在“篮球赛”和“篮球场”中，“篮球赛”是更核心的事件，应保留“篮球赛”。\n\n你的最终输出应该是一个精炼的、无重复概念的列表，只包含最具体、最具有代表性的名词。\n\n**示例**:\n输入: ['篮球赛', '篮球场', '核心力量', '实际的历史研究', '《二战全史》', '攀岩']\n筛选后: ['篮球赛', '篮球场', '《二战全史》', '攀岩']\n合并后最终输出: ['篮球赛', '《二战全史》', '攀岩']" + }, + { + "role": "user", + "content": f"请从以下标签列表中筛选出核心名词: {tag_list_str}" + } + ] + + # 调用LLM进行结构化输出 + structured_response = await llm_client.response_structured( + messages=messages, + response_model=FilteredTags + ) + + return structured_response.meaningful_tags + + except Exception as e: + print(f"LLM筛选过程中发生错误: {e}") + # 在LLM失败时返回原始标签，确保流程继续 + return tags + +def get_db_connection(): + """ + 使用项目的标准配置方法建立与Neo4j数据库的连接。 + """ + # 从全局配置获取 Neo4j 连接信息 + uri = settings.NEO4J_URI + user = settings.NEO4J_USERNAME + + # 密码必须为了安全从环境变量加载 + password = os.getenv("NEO4J_PASSWORD") + + if not uri or not user: + raise ValueError("在 config.json 中未找到 Neo4j 的 'uri' 或 'username'。") + if not password: + raise ValueError("NEO4J_PASSWORD 环境变量未设置。") + + # 为此脚本使用同步驱动 + return GraphDatabase.driver(uri, auth=(user, password)) + +def get_raw_tags_from_db(group_id: str, limit: int, by_user: bool = False) -> List[Tuple[str, int]]: + """ + 从数据库查询原始的、未经过滤的实体标签及其频率。 + + Args: + group_id: 如果by_user=False，则为group_id；如果by_user=True，则为user_id + limit: 返回的标签数量限制 + by_user: 是否按user_id查询（默认False，按group_id查询） + """ + names_to_exclude = ['AI', 'Caroline', 'Melanie', 'Jon', 'Gina', '用户', 'AI助手', 'John', 'Maria'] + + if by_user: + query = ( + "MATCH (e:ExtractedEntity) " + "WHERE e.user_id = $id AND e.entity_type <> '人物' AND e.name IS NOT NULL AND NOT e.name IN $names_to_exclude " + "RETURN e.name AS name, count(e) AS frequency " + "ORDER BY frequency DESC " + "LIMIT $limit" + ) + else: + query = ( + "MATCH (e:ExtractedEntity) " + "WHERE e.group_id = $id AND e.entity_type <> '人物' AND e.name IS NOT NULL AND NOT e.name IN $names_to_exclude " + "RETURN e.name AS name, count(e) AS frequency " + "ORDER BY frequency DESC " + "LIMIT $limit" + ) + + driver = None + try: + driver = get_db_connection() + with driver.session() as session: + result = session.run(query, id=group_id, limit=limit, names_to_exclude=names_to_exclude) + return [(record["name"], record["frequency"]) for record in result] + finally: + if driver: + driver.close() + +async def get_hot_memory_tags(group_id: str | None = None, limit: int = 40, by_user: bool = False) -> List[Tuple[str, int]]: + """ + 获取原始标签，然后使用LLM进行筛选，返回最终的热门标签列表。 + 查询更多的标签(limit=40)给LLM提供更丰富的上下文进行筛选。 + + Args: + group_id: 如果by_user=False，则为group_id；如果by_user=True，则为user_id + limit: 返回的标签数量限制 + by_user: 是否按user_id查询（默认False，按group_id查询） + """ + # 默认从 runtime.json selections.group_id 读取 + group_id = group_id or SELECTED_GROUP_ID + # 1. 从数据库获取原始排名靠前的标签 + raw_tags_with_freq = get_raw_tags_from_db(group_id, limit, by_user=by_user) + if not raw_tags_with_freq: + return [] + + raw_tag_names = [tag for tag, freq in raw_tags_with_freq] + + # 2. 初始化LLM客户端并使用LLM筛选出有意义的标签 + from app.core.memory.utils.config import definitions as config_defs + llm_client = get_llm_client(config_defs.SELECTED_LLM_ID) + meaningful_tag_names = await filter_tags_with_llm(raw_tag_names, llm_client) + + # 3. 根据LLM的筛选结果，构建最终的标签列表（保留原始频率和顺序） + final_tags = [] + for tag, freq in raw_tags_with_freq: + if tag in meaningful_tag_names: + final_tags.append((tag, freq)) + + return final_tags + +if __name__ == "__main__": + print("开始获取热门记忆标签...") + try: + # 直接使用 runtime.json 中的 group_id + group_id_to_query = SELECTED_GROUP_ID + # 使用 asyncio.run 来执行异步主函数 + top_tags = asyncio.run(get_hot_memory_tags(group_id=group_id_to_query)) + + if top_tags: + print(f"热门记忆标签 (Group ID: {group_id_to_query}, 经LLM筛选):") + for tag, frequency in top_tags: + print(f"- {tag} (数量: {frequency})") + + # --- 将结果写入统一的 Signboard.json 到 logs/memory-output --- + from app.core.config import settings + settings.ensure_memory_output_dir() + signboard_path = settings.get_memory_output_path("Signboard.json") + payload = { + "group_id": group_id_to_query, + "hot_tags": [{"name": t, "frequency": f} for t, f in top_tags] + } + try: + existing = {} + if os.path.exists(signboard_path): + with open(signboard_path, "r", encoding="utf-8") as rf: + existing = json.load(rf) + existing["hot_memory_tags"] = payload + with open(signboard_path, "w", encoding="utf-8") as wf: + json.dump(existing, wf, ensure_ascii=False, indent=2) + print(f"已写入 {signboard_path} -> hot_memory_tags") + except Exception as e: + print(f"写入 Signboard.json 失败: {e}") + else: + print(f"在 Group ID '{group_id_to_query}' 中没有找到符合条件的实体标签。") + except Exception as e: + print(f"执行过程中发生严重错误: {e}") + print("请检查：") + print("1. Neo4j数据库服务是否正在运行。") + print("2. 'config.json'中的配置是否正确。") + print("3. 相关的环境变量 (如 NEO4J_PASSWORD, DASHSCOPE_API_KEY) 是否已正确设置。") diff --git a/api/app/core/memory/analytics/memory_insight.py b/api/app/core/memory/analytics/memory_insight.py new file mode 100644 index 00000000..26147a47 --- /dev/null +++ b/api/app/core/memory/analytics/memory_insight.py @@ -0,0 +1,343 @@ +""" +This module provides the MemoryInsight class for analyzing user memory data. + +This script can be executed directly to generate a memory insight report for a test user. +""" + +import asyncio +import os +import sys +import json +from collections import Counter +from datetime import datetime + +# To run this script directly, we need to add the src directory to the Python path +# to resolve the inconsistent imports in other modules. +src_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "..")) +if src_path not in sys.path: + sys.path.insert(0, src_path) + +from pydantic import BaseModel, Field + +from app.repositories.neo4j.neo4j_connector import Neo4jConnector +from app.core.memory.utils.llm.llm_utils import get_llm_client +from app.core.memory.analytics.hot_memory_tags import get_hot_memory_tags +from app.core.memory.utils.config.definitions import SELECTED_GROUP_ID, SELECTED_LLM_ID + +# 定义用于LLM结构化输出的Pydantic模型 +class TagClassification(BaseModel): + """ + Represents the classification of a tag into a specific domain. + """ + + domain: str = Field( + ..., + description="The domain the tag belongs to, chosen from the predefined list.", + examples=["教育", "学习", "工作", "旅行", "家庭", "运动", "社交", "娱乐", "健康", "其他"], + ) + +class InsightReport(BaseModel): + """ + Represents the final insight report generated by the LLM. + """ + + report: str = Field( + ..., + description="A comprehensive insight report in Chinese, summarizing the user's memory patterns.", + ) + + +class MemoryInsight: + """ + Provides insights into user memories by analyzing various aspects of their data. + """ + + def __init__(self, user_id: str): + self.user_id = user_id + self.neo4j_connector = Neo4jConnector() + from app.core.memory.utils.config import definitions as config_defs + self.llm_client = get_llm_client(config_defs.SELECTED_LLM_ID) + + async def close(self): + """关闭数据库连接。""" + await self.neo4j_connector.close() + + async def get_domain_distribution(self) -> dict[str, float]: + """ + Calculates the distribution of memory domains based on hot tags. + """ + hot_tags = await get_hot_memory_tags(self.user_id) + if not hot_tags: + return {} + + domain_counts = Counter() + for tag, _ in hot_tags: + prompt = f"""请将以下标签归类到最合适的领域中。 + +可选领域及其关键词： +- 教育：学校、课程、考试、培训、教学、学科、教师、学生、班级、作业、成绩、毕业、入学、校园、大学、中学、小学、教材、学位等 +- 学习：自学、阅读、书籍、技能提升、知识积累、笔记、复习、练习、研究、历史知识、科学知识、文化知识、学术讨论、知识问答等 +- 工作：职业、项目、会议、同事、业务、公司、办公、任务、客户、合同、职场、工作计划等 +- 旅行：旅游、景点、出行、度假、酒店、机票、导游、风景、旅行计划等 +- 家庭：亲人、父母、子女、配偶、家事、家庭活动、亲情、家庭聚会等 +- 运动：健身、体育、锻炼、跑步、游泳、球类、瑜伽、运动计划等 +- 社交：朋友、聚会、社交活动、派对、聊天、交友、社交网络等 +- 娱乐：游戏、电影、音乐、休闲、综艺、动漫、小说、娱乐活动等 +- 健康：医疗、养生、心理健康、体检、药物、疾病、保健、健康管理等 +- 其他：确实无法归入以上任何类别的内容 + +标签: {tag} + +分析步骤： +1. 仔细理解标签的核心含义和使用场景 +2. 对比各个领域的关键词，找到最匹配的领域 +3. 特别注意： + - 历史、科学、文化等知识性内容应归类为"学习" + - 学校、课程、考试等正式教育场景应归类为"教育" + - 只有在标签完全不属于上述9个具体领域时，才选择"其他" +4. 如果标签与某个领域有任何相关性，就选择该领域，不要选"其他" + +请直接返回最合适的领域名称。""" + messages = [ + {"role": "system", "content": "你是一个专业的标签分类助手。你必须仔细分析标签的实际含义和使用场景，优先选择9个具体领域之一。'其他'类别只用于完全无法归类的极少数情况。特别注意：历史、科学、文化等知识性对话应归类为'学习'领域；学校、课程、考试等正式教育场景应归类为'教育'领域。"}, + {"role": "user", "content": prompt} + ] + # 直接调用并等待结果 + classification = await self.llm_client.response_structured( + messages=messages, + response_model=TagClassification, + ) + if classification and hasattr(classification, 'domain') and classification.domain: + domain_counts[classification.domain] += 1 + + total_tags = sum(domain_counts.values()) + if total_tags == 0: + return {} + + domain_distribution = { + domain: count / total_tags for domain, count in domain_counts.items() + } + return dict( + sorted(domain_distribution.items(), key=lambda item: item[1], reverse=True) + ) + + async def get_active_periods(self) -> list[int]: + """ + Identifies the top 2 most active months for the user. + Only returns months if there is valid and diverse time data. + + This method checks if the time data represents real user memory timestamps + rather than auto-generated system timestamps by verifying: + 1. Time data exists and is parseable + 2. Time data is distributed across multiple months (not concentrated in 1-2 months) + """ + query = f""" + MATCH (d:Dialogue) + WHERE d.group_id = '{self.user_id}' AND d.created_at IS NOT NULL AND d.created_at <> '' + RETURN d.created_at AS creation_time + """ + records = await self.neo4j_connector.execute_query(query) + + if not records: + return [] + + month_counts = Counter() + valid_dates_count = 0 + for record in records: + creation_time_str = record.get("creation_time") + if not creation_time_str: + continue + try: + # 尝试解析时间字符串 + dt_object = datetime.fromisoformat(creation_time_str.replace("Z", "+00:00")) + month_counts[dt_object.month] += 1 + valid_dates_count += 1 + except (ValueError, TypeError, AttributeError): + # 如果解析失败，跳过这条记录 + continue + + # 如果没有有效的时间数据，返回空列表 + if not month_counts or valid_dates_count == 0: + return [] + + # 检查时间分布是否过于集中（可能是批量导入的数据） + # 如果超过80%的数据集中在1-2个月，认为这是系统时间戳而非真实时间 + unique_months = len(month_counts) + if unique_months <= 2: + # 只有1-2个月有数据，很可能是批量导入 + most_common_count = month_counts.most_common(1)[0][1] + if most_common_count / valid_dates_count > 0.8: + # 超过80%集中在一个月，认为是系统时间戳 + return [] + + # 如果时间分布较为分散（3个月以上），认为是真实时间数据 + if unique_months >= 3: + most_common_months = month_counts.most_common(2) + return [month for month, _ in most_common_months] + + # 2个月的情况，检查是否分布均匀 + if unique_months == 2: + counts = list(month_counts.values()) + # 如果两个月的数据量相差不大（比例在0.3-3之间），认为是真实数据 + ratio = min(counts) / max(counts) + if ratio > 0.3: + most_common_months = month_counts.most_common(2) + return [month for month, _ in most_common_months] + + # 其他情况返回空列表 + return [] + + async def get_social_connections(self) -> dict | None: + """ + Finds the user with whom the most memories are shared. + """ + query = f""" + MATCH (d1:Dialogue {{group_id: '{self.user_id}'}})<-[:MENTIONS]-(s:Statement)-[:MENTIONS]->(d2:Dialogue) + WHERE d1 <> d2 + RETURN d2.group_id AS other_user_id, COUNT(s) AS common_statements + ORDER BY common_statements DESC + LIMIT 1 + """ + records = await self.neo4j_connector.execute_query(query) + if not records: + return None + + most_connected_user = records[0]["other_user_id"] + common_memories_count = records[0]["common_statements"] + + time_range_query = f""" + MATCH (d:Dialogue) + WHERE d.group_id IN ['{self.user_id}', '{most_connected_user}'] + RETURN min(d.created_at) AS start_time, max(d.created_at) AS end_time + """ + time_records = await self.neo4j_connector.execute_query(time_range_query) + start_year, end_year = "N/A", "N/A" + if time_records and time_records[0]["start_time"]: + start_year = datetime.fromisoformat(time_records[0]["start_time"].replace("Z", "+00:00")).year + end_year = datetime.fromisoformat(time_records[0]["end_time"].replace("Z", "+00:00")).year + + return { + "user_id": most_connected_user, + "common_memories_count": common_memories_count, + "time_range": f"{start_year}-{end_year}", + } + + async def generate_insight_report(self) -> str: + """ + Generates the final insight report in natural language. + """ + domain_dist, active_periods, social_conn = await asyncio.gather( + self.get_domain_distribution(), + self.get_active_periods(), + self.get_social_connections(), + ) + + prompt_parts = [] + + if domain_dist: + top_domains = ", ".join([f"{k}({v:.0%})" for k, v in list(domain_dist.items())[:3]]) + prompt_parts.append(f"- 核心领域: 用户的记忆主要集中在 {top_domains}。") + + if active_periods: + months_str = " 和 ".join(map(str, active_periods)) + prompt_parts.append(f"- 活跃时段: 用户在每年的 {months_str} 月最为活跃。") + + if social_conn: + prompt_parts.append( + f"- 社交关联: 与用户\"{social_conn['user_id']}\"拥有最多共同记忆({social_conn['common_memories_count']}条)，时间范围主要在 {social_conn['time_range']}。" + ) + + if not prompt_parts: + return "暂无足够数据生成洞察报告。" + + system_prompt = '''你是一位资深的个人记忆分析师。你的任务是根据我提供的要点，为用户生成一段简洁、自然、个性化的记忆洞察报告。 + +重要规则： +1. 报告需要将所有要点流畅地串联成一个段落 +2. 语言风格要亲切、易于理解，就像和朋友聊天一样 +3. 不要添加任何额外的解释或标题，直接输出报告内容 +4. 只使用我提供的要点，不要编造或推测任何信息 +5. 如果某个维度没有数据（如没有活跃时段信息），就不要在报告中提及该维度 + +例如，如果输入是： +- 核心领域: 用户的记忆主要集中在 旅行(38%), 工作(24%), 家庭(21%)。 +- 活跃时段: 用户在每年的 4 和 10 月最为活跃。 +- 社交关联: 与用户"张明"拥有最多共同记忆(47条)，时间范围主要在 2017-2020。 + +你的输出应该是： +"您的记忆集中在旅行(38%)、工作(24%)和家庭(21%)三大领域。每年4月和10月是您最活跃的记录期，可能与春秋季旅行计划相关。您与'张明'共同拥有最多记忆(47条)，主要集中在2017-2020年间。" + +如果输入只有： +- 核心领域: 用户的记忆主要集中在 教育(65%), 学习(25%)。 + +你的输出应该是： +"您的记忆主要集中在教育(65%)和学习(25%)两大领域，显示出您对知识和成长的持续关注。"''' + + user_prompt = "\n".join(prompt_parts) + messages = [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": user_prompt} + ] + + response = await self.llm_client.chat(messages=messages) + + return response.content + + async def close(self): + """ + Closes the database connection. + """ + await self.neo4j_connector.close() + + +async def main(): + """ + Initializes and runs the memory insight analysis for a test user. + """ + # 默认从 runtime.json selections.group_id 读取 + test_user_id = SELECTED_GROUP_ID + print(f"正在为用户 {test_user_id} 生成记忆洞察报告...\n") + + insight = None + try: + insight = MemoryInsight(user_id=test_user_id) + report = await insight.generate_insight_report() + print("--- 记忆洞察报告 ---") + print(report) + print("---------------------") + + # 将结果写入统一的 User-Dashboard.json，使用全局配置路径 + try: + from app.core.config import settings + settings.ensure_memory_output_dir() + output_dir = settings.MEMORY_OUTPUT_DIR + try: + os.makedirs(output_dir, exist_ok=True) + except Exception: + pass + dashboard_path = os.path.join(output_dir, "User-Dashboard.json") + existing = {} + if os.path.exists(dashboard_path): + with open(dashboard_path, "r", encoding="utf-8") as rf: + existing = json.load(rf) + existing["memory_insight"] = { + "group_id": test_user_id, + "report": report + } + with open(dashboard_path, "w", encoding="utf-8") as wf: + json.dump(existing, wf, ensure_ascii=False, indent=2) + print(f"已写入 {dashboard_path} -> memory_insight") + except Exception as e: + print(f"写入 User-Dashboard.json 失败: {e}") + except Exception as e: + print(f"生成报告时出错: {e}") + finally: + if insight: + await insight.close() + + +if __name__ == "__main__": + # This setup allows running the async main function + if sys.platform.startswith('win') and sys.version_info >= (3, 8): + asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy()) + asyncio.run(main()) diff --git a/api/app/core/memory/analytics/recent_activity_stats.py b/api/app/core/memory/analytics/recent_activity_stats.py new file mode 100644 index 00000000..c41f4208 --- /dev/null +++ b/api/app/core/memory/analytics/recent_activity_stats.py @@ -0,0 +1,202 @@ +import os +import re +import glob +import json +from typing import Tuple + +try: + from app.core.memory.utils.config.definitions import PROJECT_ROOT +except Exception: + # Fallback: derive project root from this file location + PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + + +def _get_latest_prompt_log_path() -> str | None: + """Return the latest prompt log file path under PROJECT_ROOT/logs, or None.""" + logs_dir = os.path.join(PROJECT_ROOT, "logs", "prompts") + if not os.path.isdir(logs_dir): + return None + + files = glob.glob(os.path.join(logs_dir, "prompt_logs-*.log")) + if not files: + return None + + # Choose by modified time descending + files.sort(key=lambda p: os.path.getmtime(p), reverse=True) + return files[0] + + +def _get_all_prompt_logs() -> list[str]: + """Return all log file paths under logs dirs sorted by mtime ascending. + + It checks both PROJECT_ROOT/logs/prompts and CWD/logs/prompts to be robust. + """ + candidates = [] + pr_logs = os.path.join(PROJECT_ROOT, "logs", "prompts") + cwd_logs = os.path.join(os.getcwd(), "logs", "prompts") + for d in [pr_logs, cwd_logs]: + if os.path.isdir(d): + candidates.extend(glob.glob(os.path.join(d, "prompt_logs-*.log"))) + + # Deduplicate and sort + files = sorted(set(candidates), key=lambda p: os.path.getmtime(p)) + return files + + +def _get_any_logs_recursive() -> list[str]: + """Fallback: search for any .log files under PROJECT_ROOT recursively.""" + files = glob.glob(os.path.join(PROJECT_ROOT, "**", "*.log"), recursive=True) + files.sort(key=lambda p: os.path.getmtime(p)) + return files + + +def parse_stats_from_log(log_path: str) -> dict: + """ + Parse required statistics from a prompt log file. + + Returns dict with keys: + - chunk_count: int (count of chunks processed) + - statements_count: int (total statements processed for triplets) + - triplet_entities_count: int (total entities extracted) + - triplet_relations_count: int (total triplets/relations extracted) + - temporal_count: int (extracted valid temporal ranges) + """ + chunk_count = 0 + statements_count = 0 + triplet_entities_count = 0 + triplet_relations_count = 0 + temporal_count = 0 + + # Patterns + pat_chunk_render = re.compile(r"===\s*RENDERED\s*STATEMENT\s*EXTRACTION\s*PROMPT\s*===") + pat_triplet_start = re.compile(r"\[Triplet\].*statements_to_process\s*=\s*(\d+)") + pat_triplet_done = re.compile( + r"\[Triplet\].*completed,\s*total_triplets\s*=\s*(\d+),\s*total_entities\s*=\s*(\d+)" + ) + pat_temporal_done = re.compile( + r"\[Temporal\].*completed,\s*extracted_valid_ranges\s*=\s*(\d+)" + ) + + with open(log_path, "r", encoding="utf-8", errors="ignore") as f: + for line in f: + # Chunk prompts count (each chunk triggers one statement-extraction prompt render) + if pat_chunk_render.search(line): + chunk_count += 1 + continue + + m1 = pat_triplet_start.search(line) + if m1: + try: + statements_count += int(m1.group(1)) + except Exception: + pass + continue + + m2 = pat_triplet_done.search(line) + if m2: + try: + triplet_relations_count += int(m2.group(1)) + triplet_entities_count += int(m2.group(2)) + except Exception: + pass + continue + + m3 = pat_temporal_done.search(line) + if m3: + try: + temporal_count += int(m3.group(1)) + except Exception: + pass + continue + + return { + "chunk_count": chunk_count, + "statements_count": statements_count, + "triplet_entities_count": triplet_entities_count, + "triplet_relations_count": triplet_relations_count, + "temporal_count": temporal_count, + "log_path": log_path, + } + + +def get_recent_activity_stats() -> Tuple[dict, str]: + """Get aggregated stats from all prompt logs in logs/. + + Returns (stats_dict, message). + """ + all_logs = _get_all_prompt_logs() + # Fallback to recursive search if none found in logs/ + if not all_logs: + all_logs = _get_any_logs_recursive() + if not all_logs: + return ( + { + "chunk_count": 0, + "statements_count": 0, + "triplet_entities_count": 0, + "triplet_relations_count": 0, + "temporal_count": 0, + "log_path": None, + }, + "未找到日志文件，请确认已运行过提取流程。", + ) + + agg = { + "chunk_count": 0, + "statements_count": 0, + "triplet_entities_count": 0, + "triplet_relations_count": 0, + "temporal_count": 0, + } + for path in all_logs: + s = parse_stats_from_log(path) + agg["chunk_count"] += s.get("chunk_count", 0) + agg["statements_count"] += s.get("statements_count", 0) + agg["triplet_entities_count"] += s.get("triplet_entities_count", 0) + agg["triplet_relations_count"] += s.get("triplet_relations_count", 0) + agg["temporal_count"] += s.get("temporal_count", 0) + + # Attach a summary of files combined + agg["log_path"] = f"{len(all_logs)} 个日志文件，最新：{all_logs[-1]}" + return agg, "成功汇总 logs 目录中所有提示日志。" + + +def _format_summary(stats: dict) -> str: + """Format a Chinese summary string from stats.""" + log_info = stats.get("log_path") or "(无)" + return ( + "最近记忆活动统计\n" + f"- 日志文件：{log_info}\n" + f"- 数据分块：共 {stats.get('chunk_count', 0)} 块\n" + f"- 句子提取：共 {stats.get('statements_count', 0)} 个句子\n" + f"- 三元组提取：实体 {stats.get('triplet_entities_count', 0)} 个，关系 {stats.get('triplet_relations_count', 0)} 条\n" + f"- 时间提取：共提取 {stats.get('temporal_count', 0)} 条时间信息\n" + ) + + +if __name__ == "__main__": + stats, msg = get_recent_activity_stats() + print(msg) + print(_format_summary(stats)) + + # --- 将结果写入统一的 Signboard.json --- + try: + # 使用全局配置的输出路径 + from app.core.config import settings + settings.ensure_memory_output_dir() + output_dir = settings.MEMORY_OUTPUT_DIR + try: + os.makedirs(output_dir, exist_ok=True) + except Exception: + pass + signboard_path = os.path.join(output_dir, "Signboard.json") + existing = {} + if os.path.exists(signboard_path): + with open(signboard_path, "r", encoding="utf-8") as rf: + existing = json.load(rf) + existing["recent_activity_stats"] = stats + with open(signboard_path, "w", encoding="utf-8") as wf: + json.dump(existing, wf, ensure_ascii=False, indent=2) + print(f"已写入 {signboard_path} -> recent_activity_stats") + except Exception as e: + print(f"写入 Signboard.json 失败: {e}") diff --git a/api/app/core/memory/analytics/user_summary.py b/api/app/core/memory/analytics/user_summary.py new file mode 100644 index 00000000..f4f4d642 --- /dev/null +++ b/api/app/core/memory/analytics/user_summary.py @@ -0,0 +1,152 @@ +""" +Generate a concise "关于我" style user summary using data from Neo4j +and the existing LLM configuration (mirrors hot_memory_tags.py setup). + +Usage: + python -m analytics.user_summary --user_id +""" + +import os +import sys +import asyncio +import json +from dataclasses import dataclass +from typing import List, Tuple + +# Ensure absolute imports work whether executed directly or via module +try: + project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')) + src_path = os.path.join(project_root, 'src') + if src_path not in sys.path: + sys.path.insert(0, src_path) + if project_root not in sys.path: + sys.path.insert(0, project_root) +except Exception: + pass + +from app.repositories.neo4j.neo4j_connector import Neo4jConnector +from app.core.memory.analytics.hot_memory_tags import get_hot_memory_tags +from app.core.memory.utils.config.definitions import SELECTED_GROUP_ID, SELECTED_LLM_ID +from app.core.memory.utils.llm.llm_utils import get_llm_client + + +@dataclass +class StatementRecord: + statement: str + created_at: str | None + + +class UserSummary: + """Builds a textual user summary for a given user/group id.""" + + def __init__(self, user_id: str): + self.user_id = user_id + self.connector = Neo4jConnector() + from app.core.memory.utils.config import definitions as config_defs + self.llm = get_llm_client(config_defs.SELECTED_LLM_ID) + + async def close(self): + await self.connector.close() + + async def _get_recent_statements(self, limit: int = 80) -> List[StatementRecord]: + """Fetch recent statements authored by the user/group for context.""" + query = ( + "MATCH (s:Statement) " + "WHERE s.group_id = $group_id AND s.statement IS NOT NULL " + "RETURN s.statement AS statement, s.created_at AS created_at " + "ORDER BY created_at DESC LIMIT $limit" + ) + rows = await self.connector.execute_query(query, group_id=self.user_id, limit=limit) + records: List[StatementRecord] = [] + for r in rows: + try: + records.append(StatementRecord(statement=r.get("statement", ""), created_at=r.get("created_at"))) + except Exception: + continue + return records + + async def _get_top_entities(self, limit: int = 30) -> List[Tuple[str, int]]: + """Reuse hot tag logic to get meaningful entities and their frequencies.""" + # get_hot_memory_tags internally filters out non-meaningful nouns with LLM + return await get_hot_memory_tags(self.user_id, limit=limit) + + async def generate(self) -> str: + """Generate a Chinese '关于我' style summary using the LLM.""" + # 1) Collect context + entities = await self._get_top_entities(limit=40) + statements = await self._get_recent_statements(limit=100) + + entity_lines = [f"{name} ({freq})" for name, freq in entities][:20] + statement_samples = [s.statement.strip() for s in statements if (s.statement or '').strip()][:20] + + # 2) Compose prompt + system_prompt = ( + "你是一位中文信息压缩助手。请基于提供的实体与语句，" + "生成非常简洁的用户摘要，禁止臆测或虚构。要求：\n" + "- 3–4 句，总字数不超过 120；\n" + "- 先交代身份/城市，其次长期兴趣或习惯，最后给一两项代表性经历；\n" + "- 避免形容词堆砌与空话，不用项目符号，不分段；\n" + "- 使用客观的第三人称描述，语气克制、中立。" + ) + + user_content_parts = [ + f"用户ID: {self.user_id}", + "核心实体与频次: " + (", ".join(entity_lines) if entity_lines else "(空)"), + "代表性语句样本: " + (" | ".join(statement_samples) if statement_samples else "(空)"), + ] + user_prompt = "\n".join(user_content_parts) + + messages = [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": user_prompt}, + ] + + # 3) Call LLM + response = await self.llm.chat(messages=messages) + return response.content + + +async def generate_user_summary(user_id: str | None = None) -> str: + # 默认从 runtime.json selections.group_id 读取 + effective_group_id = user_id or SELECTED_GROUP_ID + svc = UserSummary(effective_group_id) + try: + return await svc.generate() + finally: + await svc.close() + + +if __name__ == "__main__": + print("开始生成用户摘要…") + try: + # 直接使用 runtime.json 中的 group_id + summary = asyncio.run(generate_user_summary()) + print("\n— 用户摘要 —\n") + print(summary) + + # 将结果写入统一的 User-Dashboard.json + try: + from app.core.config import settings + settings.ensure_memory_output_dir() + output_dir = settings.MEMORY_OUTPUT_DIR + try: + os.makedirs(output_dir, exist_ok=True) + except Exception: + pass + dashboard_path = os.path.join(output_dir, "User-Dashboard.json") + existing = {} + if os.path.exists(dashboard_path): + with open(dashboard_path, "r", encoding="utf-8") as rf: + existing = json.load(rf) + existing["user_summary"] = { + "group_id": SELECTED_GROUP_ID, + "summary": summary + } + with open(dashboard_path, "w", encoding="utf-8") as wf: + json.dump(existing, wf, ensure_ascii=False, indent=2) + print(f"已写入 {dashboard_path} -> user_summary") + except Exception as e: + print(f"写入 User-Dashboard.json 失败: {e}") + except Exception as e: + print(f"生成摘要失败: {e}") + print("请检查: 1) Neo4j 是否可用；2) config.json 与 .env 的 LLM/Neo4j 配置是否正确；3) 数据是否包含该用户的内容。") diff --git a/api/app/core/memory/config.json b/api/app/core/memory/config.json new file mode 100644 index 00000000..a0349558 --- /dev/null +++ b/api/app/core/memory/config.json @@ -0,0 +1,132 @@ +{ + "llm_list": [ + { + "llm_name": "qwen2.5-14b-instruct-awq", + "api_base": "http://175.27.131.196:9090/v1", + "api_key": "OPENAI_API_KEY" + }, + { + "llm_name": "openai/qwen2.5-14b-instruct-awq", + "api_base": "http://175.27.131.196:9090/v1", + "api_key": "OPENAI_API_AGENT_KEY" + }, + { + "llm_name": "openai/qwen2.5-14b", + "api_base": "http://43.137.4.24:9090/v1", + "api_key": "OPENAI_API_KEY" + }, + { + "llm_name": "openai/qwen2.5-14b-instruct-awq", + "api_base": "http://175.27.131.196:9090/v1", + "api_key": "OPENAI_API_KEY" + }, + { + "llm_name": "openai/qwen3-14b", + "api_base": "http://43.137.4.24:9090/v1", + "api_key": "OPENAI_API_KEY" + }, + { + "llm_name": "openai/deepseek-r1-0528-qwen3-8b", + "api_base": "http://43.137.4.24:9090/v1", + "api_key": "OPENAI_API_KEY" + }, + { + "llm_name": "openai/qwen3-235b-a22b-instruct-2507", + "api_base": "https://dashscope.aliyuncs.com/compatible-mode/v1", + "api_key": "DASHSCOPE_API_KEY" + } + , + { + "llm_name": "openai/qwen-plus", + "api_base": "https://dashscope.aliyuncs.com/compatible-mode/v1", + "api_key": "DASHSCOPE_API_KEY" + }, + { + "llm_name": "bedrock/global.anthropic.claude-sonnet-4-5-20250929-v1:0" + }, + { + "llm_name": "bedrock/global.anthropic.claude-sonnet-4-20250514-v1:0" + } + ], + "embedding_list": [ + { + "embedding_name": "openai/nomic-embed-text:v1.5", + "api_base": "http://119.45.239.97:11434/v1", + "dimension": 768 + }, + { + "embedding_name": "openai/bge-m3", + "api_base": "http://43.137.4.24:9090/v1", + "dimension": 1024 + } + ], + "neo4j": { + "uri": "bolt://1.94.111.67:7687", + "username": "neo4j" + }, + "chunker_list": [ + { + "chunker_strategy": "TokenChunker", + "embedding_model": "BAAI/bge-m3", + "chunk_size": 512, + "chunk_overlap": 56, + "tokenizer_or_token_counter": "character" + }, + { + "chunker_strategy": "RecursiveChunker", + "embedding_model": "BAAI/bge-m3", + "chunk_size": 512, + "min_characters_per_chunk": 50 + }, + { + "chunker_strategy": "SemanticChunker", + "embedding_model": "BAAI/bge-m3", + "chunk_size": 1024, + "threshold": 0.8, + "min_sentences": 2, + "skip_window": 1, + "min_characters_per_chunk": 100 + }, + { + "chunker_strategy": "LateChunker", + "embedding_model": "all-MiniLM-L6-v2", + "chunk_size": 2048, + "min_characters_per_chunk": 24 + }, + { + "chunker_strategy": "NeuralChunker", + "embedding_model": "mirth/chonky_modernbert_base_1", + "min_characters_per_chunk": 24 + }, + { + "chunker_strategy": "LLMChunker", + "embedding_model": "BAAI/bge-m3", + "chunk_size": 1000, + "min_characters_per_chunk": 100 + }, + { + "chunker_strategy": "HybridChunker", + "embedding_model": "BAAI/bge-m3", + "chunk_size": 512, + "threshold": 0.8, + "min_characters_per_chunk": 100 + }, + { + "chunker_strategy": "SentenceChunker", + "embedding_model": "BAAI/bge-m3", + "chunk_size": 2048, + "chunk_overlap": 128, + "min_sentences_per_chunk": 1, + "min_characters_per_sentence": 12, + "delim": [".", "!", "?", "\n"], + "include_delim": "prev", + "tokenizer_or_token_counter": "character" + } + ], + "langfuse": { + "enabled": true + }, + "agenta": { + "enabled": false + } +} \ No newline at end of file diff --git a/api/app/core/memory/data/testdata.json b/api/app/core/memory/data/testdata.json new file mode 100644 index 00000000..2f893e64 --- /dev/null +++ b/api/app/core/memory/data/testdata.json @@ -0,0 +1,12 @@ +{"context": "以下是 2025 年 10 月 14 日的对话记录:\n“用户:我计划周末去龙泉山拍日出。\nAI:建议提前查天气和能见度,凌晨三点出发更稳。\n用户:嗯嗯。\n用户:嘿嘿。\n用户:三脚架。\n用户:备用电池。\nAI:把这些写进出门清单就不容易忘。\n用户:唉——真是纠结。\n用户:我新买了 35mm 定焦镜头。\nAI:35mm 的视角自然,适合街拍。\n用户:咔咔咔……乱糟糟的。\n\n请记住以上全部对话记录,回答问题。\n问题:这次对话中,用户周末计划去哪里拍摄？他新买的镜头是什么规格？清单型名词句子中出现了哪些器材？","answer": "用户计划周末去龙泉山拍日出；新买的镜头是 35mm 定焦；清单型名词句子中出现的器材包括三脚架、备用电池。","id": "45e2f1b3-78b9-4b15-9aa4-1234567890ab","chatglm_length": 890,"qwen_length": 900,"internlm2_length": 895} +{"context": "以下是 2025 年 10 月 16 日的对话记录:\n“用户:我叫林晓,平时喜欢拍自然风光,最近拍红叶总觉得画面层次感不够,明明现场看颜色很鲜艳,拍出来却有点平淡,调滤镜也找不到刚好贴合的效果。\nAI:很高兴认识你！红叶拍摄确实需要注意光线和色彩平衡,你最近有没有想好去哪里拍红叶呀？\n 用户:想好了,我计划周末去近郊红叶谷拍红叶,还想顺便拍谷里的山间溪流,听说清晨的雾气没散时,溪流和红叶搭配起来特别出片,而且我新买了 16-35mm 广角镜头,想试试拍大场景。\nAI:广角镜头拍红叶谷的大场景很合适！建议你带个中灰渐变镜,清晨拍溪流时,能平衡天空和地面的曝光差,避免天空过曝或溪流欠曝,另外提前查下红叶谷的最佳拍摄时段,听说早上 7 点到 9 点的光线最柔和。\n 用户:太需要了！上次去拍山间的银杏,就是因为没带渐变镜,天空白成一片,后期想救都救不回来,而且当时没控制好快门速度,溪流的水流拍得太硬,没有那种丝滑的感觉,只能删掉大半照片。\nAI:拍溪流要丝滑效果,快门速度可以调到 1/10 秒左右,再搭配三脚架固定相机,避免画面模糊,另外可以找块石头当前景,让溪流从石头旁流过,能增加画面的纵深感。\n 用户:记下来了！我还想拍几张红叶的特写,比如叶脉上挂着露珠的样子,但之前拍特写时总对焦在叶子边缘,没把露珠的细节拍清楚,不知道是不是对焦区域选小了。\nAI:拍露珠特写建议用 “单点对焦”,把对焦框精准对准露珠,再把光圈开到 f/4 左右,既能保证露珠清晰,又能让背景的红叶稍微虚化,突出主体,另外可以喷点清水在叶子上,让露珠更明显。\n 用户:这个方法好！我准备列个拍摄清单,除了中灰渐变镜,还要带三脚架、清水喷雾,上次拍银杏时忘带三脚架,蹲在地上拍得腿都麻了,而且手持拍的照片糊了不少,后期只能勉强修几张。\nAI:清单里可以加 “备用电池”,红叶谷早上气温低,电池耗电快,另外注意事项里可以写 “穿防滑鞋”,谷里有溪流的地方路面可能湿滑,不小心容易摔跤影响拍摄。\n 用户:太贴心了！晚上我要把相机的参数预设好,比如拍大场景时光圈设为 f/8、ISO100,拍溪流时快门速度设为 1/10 秒,省得早上到了现场手忙脚乱调参数,耽误最佳拍摄时间。\nAI:预设参数很明智！拍的时候可以多换几个角度,比如低角度拍溪流倒映红叶,或者站在高处拍红叶谷的全景,不同角度能拍出不一样的氛围,另外拍完记得及时导照片到硬盘,避免内存卡满了漏拍。\n 用户:好的！等拍完我想把红叶和溪流的照片拼成长图,配段文字发朋友圈,还想把喜欢的照片洗出来贴在相册里,每次翻相册都能想起拍摄时的场景,这种感觉特别好。\nAI:这个想法很棒！洗照片时可以选哑光纸,红叶的颜色会更有质感,不像光面纸那么刺眼,祝你周末拍摄顺利,期待看你的红叶谷作品！\n”\n\n 请记住以上全部对话记录,回答问题。\nquery:10 月 16 日的对话中,林晓计划周末去哪里拍摄什么题材?她新买的镜头是什么规格?AI 建议林晓用什么快门速度拍溪流的丝滑效果？", "answer": "林晓计划周末去近郊红叶谷拍摄红叶和山间溪流题材；她新买的镜头是 16-35mm 广角镜头;AI 建议林晓用 1/10 秒左右的快门速度拍溪流的丝滑效果。", "id": "89a4b3c2-d1e5-f6g7-h8i9-abcdef123456", "chatglm_length": 1908, "qwen_length": 1921, "internlm2_length": 1902} +{"context": "以下是关于用户经历与交流的记录:\n“用户:上周三,我和同事李华一起参加了苹果公司的技术发布会。在发布会上,我们看到了蒂姆・库克亲自演示新款 iPhone 的功能,这让我印象深刻。李华对新产品很感兴趣,当场就决定要购买一部。\n 用户:这让我想起了去年和李华一起去北京出差的经历。当时我们在中关村参观了苹果公司的中国总部,还偶遇了从美国来的技术专家约翰・史密斯。约翰向我们介绍了苹果公司在人工智能领域的最新研究进展。\n 用户:说到苹果,我其实是个果粉,从 iPhone 4 开始就一直使用苹果的产品。不过有趣的是,我虽然喜欢苹果的产品,却对苹果这种水果过敏,每次吃苹果都会不舒服。\n 用户:昨天李华给我发消息,说他已经收到了新买的 iPhone,使用体验非常好。他还提到周末想约我一起去星巴克喝咖啡,讨论一下我们正在做的项目。这个项目涉及机器学习和自然语言处理,正好可以用到苹果最新发布的一些开发工具。\n 用户:我记得上次和李华在星巴克讨论项目时,我们遇到了大学同学张明。张明现在在谷歌工作,他给我们分享了一些关于深度学习框架 TensorFlow 的使用经验。这些经验对我们当前的项目很有帮助。\n 用户:对了,说到大学,我和李华、张明都是清华大学计算机系的校友。我们在校期间就经常一起做项目,没想到毕业后还能在同一个领域继续合作,这真是难得的缘分。”\n\n 请记住以上全部记录内容,回答问题。\n 问题:记录中用户上周三与谁一起参加了什么活动？用户对苹果相关的哪类事物过敏？李华昨天发消息提到了哪两件事？用户、李华与张明的共同身份是什么？","answer": "用户上周三与同事李华一起参加了苹果公司的技术发布会；用户对苹果这种水果过敏；李华昨天发消息提到两件事,一是已收到新买的 iPhone 且使用体验好,二是想约用户周末去星巴克喝咖啡讨论项目；用户、李华与张明的共同身份是清华大学计算机系的校友。","id": "68c3d2a4-91c7-5d32-bb56-0987654321ba","chatglm_length": 1280,"qwen_length": 1295,"internlm2_length": 1285} +{"context": "以下是 2025 年 10 月 27 日的对话记录:\n“用户:周末去郊区玩太值了！提前准备的东西都没白费～\nAI: 哇！你之前说带了菊花和阿司匹林,这次都用上了吗？\n 用户:都用啦！爬山累了喝杯菊花超解腻,后来朋友头疼,阿司匹林刚好能缓解。\n 用户:对了,还带了那个凤凰牌的东西,装东西特别方便。\nAI: 是凤凰的背包吧？之前听你说过这个牌子挺耐用的～那天在郊区,有没有看到特别的动植物呀？\n 用户:有！山坡上开了好多杜鹃,早上还听到杜鹃叫,声音特别清脆。\n 用户:就是中午太阳有点晒,还好带了长城的遮阳伞,不然得晒黑了。\nAI: 长城牌遮阳伞确实靠谱！那你们去了之前说的茅台镇附近吗？那边环境怎么样？\n 用户:去了！茅台镇旁边的小路特别安静,就是风有点大,不过吹着很舒服。\n 用户:我们还在当地买了龙井,店家说这是今年的新茶,泡着特别香。\nAI: 听起来好惬意！那有没有遇到什么让人觉得温暖的事呀？比如当地人帮忙之类的？\n 用户:有！我们找不到路的时候,一位大爷主动带路,还给我们指了好看的风景,特别有雷锋精神。\n 用户:对了,带的那个杜鹃图案的手帕也用上了,擦汗特别方便。\nAI: 这些小准备和温暖的经历也太加分了～这次游玩,有没有拍些好看的照片呀？\n 用户:拍了！对着满山的杜鹃和茅台镇的远景拍了好多,回头整理好给你看。”\n\n 请记住以上全部对话记录,回答问题。\n 问题:用户此次郊区游玩,哪些准备的物品派上了用场？用户提到游玩中遇到了什么环境情况,又有哪些温暖的经历或满意的发现？","answer": "派上用场的物品包括菊花（菊花茶）、阿司匹林（药品）、凤凰牌背包、长城牌遮阳伞、龙井（新茶）、杜鹃图案手帕；游玩中遇到的环境情况是中午太阳晒、郊区风大但舒适、茅台镇附近小路安静、山坡上有大量杜鹃（花）；温暖的经历或满意的发现是听到杜鹃（鸟）鸣叫、迷路时被当地大爷主动带路并指引风景（感受到雷锋精神）、买到今年的新龙井茶、拍摄了满山杜鹃（花）和茅台镇远景的照片。","id": "78d3c2a4-91c7-5d28-bb36-0987654321bc","chatglm_length": 1420,"qwen_length": 1435,"internlm2_length": 1428} +{"context": "以下是2023年04月27日的对话记录：\n“用户: 嗨，我是王峰，一个热爱体育和军事历史的家伙。今天跑了个半马，感觉挺不错的，你呢？\nAI: 嗨，王峰！听起来你今天的状态很棒啊。我是AI伴侣，虽然不能像你一样体验长跑的快感，但我很乐意听你分享。跑步过程中有没有什么有趣的事情发生？\n\n用户: 哈哈，确实有。我在跑步的时候，竟然追上了一个穿着古装的团队，他们在拍摄什么历史剧吧。\nAI: 那真是个有趣的巧合！你对历史剧感兴趣吗？毕竟你对军事历史很有研究。\n\n用户: 对啊，我对这些特别感兴趣。看到他们的服装，我就联想到了那个时代的战争场景。不过，我更喜欢实际的历史研究，比如阅读史料和参观历史遗迹。\nAI: 那你最近有读什么吸引人的军事史著作吗？或者有没有计划去参观某个特别的历史遗址？\n\n用户: 对，我最近在读《二战全史》，非常全面而且深入。至于历史遗迹，我打算下个月去访问一下抗战纪念馆，沉浸在那段历史里。\nAI: 《二战全史》确实是本好书，涵盖了很多重要的战役和决策。抗战纪念馆的参观听起来很有意义，那里肯定有很多珍贵的历史资料和展品。\n\n用户: 没错，我期待能从中学到更多。对了，除了阅读和参观，我还喜欢打篮球来放松身心。今晚我和朋友们约了一场篮球赛。\nAI: 篮球赛听起来很刺激！你打的是哪个位置？有没有什么特别的技巧或者战术喜欢用？\n\n用户: 我通常打小前锋，喜欢快攻和远投。今晚我打算试试新的突破技巧，希望能给对手来点意外。\nAI: 小前锋啊，那你一定很擅长快速移动和精准投篮。新技巧的尝试总是让比赛更加充满乐趣。希望你能在今晚的比赛中大放异彩！\n\n用户: 哈，我会的！我总是全力以赴。不过，说起来容易做起来难，篮球场上的对抗可不是闹着玩的。\nAI: 确实，篮球场上的竞争非常激烈。不过，以你的性格和能力，我相信你能够应对挑战，展现你的实力。\n\n用户: 说到挑战，攀岩才是真正的挑战。上次攀岩时，我差点就要攻克那个难度系数很高的路线了。\nAI: 攀岩确实是对体力和意志的极大考验。下次挑战那个路线时，你有什么新的策略吗？\n\n用户: 我打算增加核心力量训练，提高耐力。攀岩时，核心力量至关重要，它能帮助我更好地控制身体。\nAI: 你的计划听起来很专业。核心力量对于攀岩确实非常关键。你通常是怎么训练的？\n\n用户: 我会做一些特定的体能训练，比如仰卧起坐、俯卧撑和翻墙。这些都能帮助我在攀岩时保持稳定和灵活。\nAI: 那些训练听起来很全面，能够有效提升你的整体体能。你对攀岩有多热情啊！\n\n用户: 是的，我对此非常热情。攀岩不仅是一项运动，更是一种精神的磨砺。好了，我得准备今晚的篮球赛了，我们明天聊。\nAI: 当然，祝你今晚篮球赛取得好成绩！明天我们再继续聊，王峰，加油！\n”\n以下是2023年04月28日的对话记录：\n“用户: 昨晚的篮球赛太刺激了！我们赢了，我那个新突破技巧效果杠杠的！\nAI: 朋友，听你这么一说，我都能感受到你赛场上的激情了！你的得分怎么样？\n\n用户: 得了20分，还有几次助攻和抢断。不过，最重要的是团队合作，我们的配合越来越默契了。\nAI: 20分加上助攻和抢断，这成绩相当不错！团队默契是取胜的关键，你们肯定训练得很勤。\n\n用户: 是的，我们每周都会固定练习两次。说起来，我今天计划去徒步，想去探索一条新路线。\nAI: 徒步探索新路线听起来很有趣。这条路线有什么特别之处吗？\n\n用户: 这条路线据说风景特别好，沿途有几个小瀑布，还有个可以俯瞰整个山谷的观景台。\nAI: 哇，那真是个不错的选择。你徒步时通常会准备些什么装备？\n\n用户: 我会带上足够的水和食物，还有急救包、多功能刀具，当然还有我的相机，不能错过沿途的美景。\nAI: 你准备得很充分。拍照是个好主意，可以记录下旅途中的美好瞬间。你徒步时喜欢独自前行，还是和朋友一起？\n\n用户: 两种方式我都喜欢。独自徒步可以让我更好地放松思绪，和朋友一起则更加热闹。\nAI: 确实，不同的方式有不同的乐趣。你在徒步时有没有遇到过什么难忘的经历？\n\n用户: 有一次徒步的时候，我遇到了一只迷路的小狗，最后我帮它找到了回家的路，那次经历让我很感动。\nAI: 那真是个温馨的故事。你的善举一定让小狗的主人非常感激。说起来，你对军事史有这么深的兴趣，有没有考虑过写点什么，比如博客或者书籍？\n\n用户: 哈，我确实有这个打算。我想写一本关于战术演变的书，但是一直没能找到合适的切入点。\nAI: 战术演变是个很宽广的话题，你可以从一个特定的战役或者时期开始着手，逐渐扩展开来。\n\n用户: 这个建议不错，我会考虑的。对了，我最近在研究越战期间的丛林战术，那个时期的战术变化很有意思。\nAI: 越战的丛林战术确实非常独特，那个时期的战争环境和战术运用对现代战争学有很多启示。\n\n用户: 没错，我觉得从这个角度切入，应该能写出不错的内容。说起来，我还得准备一下今天的徒步，稍后再聊。\nAI: 当然，徒步前的准备很重要。王峰，祝你今天的徒步旅行顺利，期待你分享新路线的故事。小心安全！\n\n用户: 谢了，我会的。对了，我还在想，攀岩时的安全措施你有了解吗？我想听听你的看法。\nAI: 攀岩安全非常重要。基本的安全措施包括检查所有装备，比如绳索、安全带和头盔，确保它们都在良好状态。还有就是和你的攀岩伙伴之间要有良好的沟通。\n\n用户: 说得对，安全总是第一位的。我总是会双倍确认我的装备和团队的沟通无误。\nAI: 这样的习惯很好，可以有效避免许多意外。你有没有遇到过攀岩时的紧急情况？\n\n用户: 有一次，我的攀岩伙伴不小心滑了一下，幸好安全绳起了作用，没有造成伤害。\nAI: 那一定是个惊险的时刻。幸好你们准备充分，避免了事故。安全绳的重要性不言而喻。\n\n用户: 是的，每次想起都觉得后怕。不过，这也是一次宝贵的经验。好了，我得出发了，明天聊。\nAI: 好的，王峰，祝你今天的徒步愉快。明天我们再继续我们的话题，保重！\n”\n\n请记住以上全部对话记录，回答问题。\n问题：", "query": "我曾经在4月27号这天，和你聊了打篮球的事情，我通常打哪个位置？", "answer": "前锋", "id": "7e11ba68-304a-4a91-98b5-7387cf0e3c43", "chatglm_length": 1540, "qwen_length": 1563, "internlm2_length": 1499} +{"context": "以下是2023年04月27日的对话记录：\n“用户: 嗨，我是李雪，一个爱笑的旅行家，电影迷，音乐会的常客，还有就是书和笔是我最好的朋友。今天心情不错，想和你聊聊天，你准备好了吗？\nAI: 嗨，李雪！我已经迫不及待想听你分享你的故事了。你今天有什么新鲜事想要告诉我吗？\n\n用户: 对了，我最近看了一部电影《时间旅行者的妻子》，简直太感人了，你知道吗？\nAI: 听起来很有意思！《时间旅行者的妻子》是关于爱情和时间错位的故事对吧？你最喜欢这部电影的哪个部分？\n\n用户: 没错，就是那种跨越时间的爱情让我深受触动。我特别喜欢他们之间的那种坚定和执着，尤其是结尾的那一幕，简直让人泪目。\nAI: 确实，那种不被时间所限制的爱情是很多人梦寐以求的。除了看电影，你最近还有没有去哪里旅游，发现了什么新奇的地方？\n\n用户: 说到旅游，我上周末去了一个小众的海滩，那里的沙子是粉红色的，超级漂亮！我还捡了些贝壳，打算做成手链。\nAI: 粉红色的沙滩听起来就像是童话世界里的场景，真是太美了！你真是个有创意的人，做手链的想法很棒。你打算怎么设计手链呢？\n\n用户: 我想把它们串在一起，中间加上一些小金属饰品，应该会很有夏天的感觉吧。对了，最近我还在写一篇关于旅行的文章，但有点卡壳了。\nAI: 听起来那手链会很迷人呢！关于你的文章，卡壳了是因为缺乏灵感，还是有其他的原因？\n\n用户: 主要是写到一半，突然不知道怎么把我的感受转化成文字了。我想表达的是旅行中那种自由自在的感觉，但是又不想太俗套。\nAI: 旅行中的自由自在确实是一种很难用言语表达的感觉。你可以尝试用一些具体的场景或者经历来引入，让读者通过你的眼睛去感受那份自由。\n\n用户: 这个主意不错！我可以从那次独自一人走在海边的经历写起，那种只有海浪声陪伴的宁静，可能会传达出我想表达的感觉。\nAI: 那真是个很好的开头。海浪的声音，沙滩上的脚印，还有远处的落日，这些细节都能够帮助读者更好地沉浸在你的故事中。\n\n用户: 对，我想我知道怎么继续写下去了。谢谢你！对了，我还想去看一场演唱会，但最近好像没有我喜欢的歌手来开演唱会。\nAI: 不客气，很高兴能帮到你！关于演唱会，虽然现在没有你喜欢的歌手来，但你可以尝试听听其他歌手的音乐，说不定会有新的发现呢。\n\n用户: 嗯，这倒是个好主意。我会去翻翻看有没有其他有趣的演出。对了，你有没有什么推荐的歌手或乐队？\nAI: 你可以试试听听The Lumineers，他们的音乐很有感染力，旋律优美，非常适合旅行时候听。或者如果你喜欢一些更有活力的音乐，Imagine Dragons也是个不错的选择。\n\n用户: The Lumineers我听过几首，确实不错。Imagine Dragons的《Believer》我也超爱！看来你的音乐品味也挺不错的嘛。\nAI: 哈哈，我会尽量跟上你的步伐的。说起来，你最喜欢的一次演唱会是哪一次？有没有什么难忘的经历？\n\n用户: 那当然是Coldplay的演唱会了，整个场馆的氛围、灯光还有音乐，完全就是另一个世界。我记得当时我闭上眼睛，感觉自己完全沉浸在音乐里。\nAI: Coldplay的演唱会确实是出了名的震撼人心。音乐有时候就是这样，能够带我们进入一个全新的世界。你提到闭上眼睛沉浸在音乐里，那感觉一定很神奇。\n\n用户: 是的，那种感觉无法用言语表达，只能自己体验。哎，说到这些，我又想去旅行了，想去一个没有去过的地方探险。\nAI: 旅行总是能给人带来新的体验和感受。如果你可以去任何一个地方，你最想去哪里？\n\n用户: 我想去冰岛看极光，那是我长久以来的梦想。想象一下，在寒冷的夜晚，天空中突然出现五彩斑斓的光，那一定很神奇。\nAI: 冰岛的极光听起来是个绝佳的选择，希望你的梦想能够很快实现。虽然我不能亲自陪你去，但我会在这里等着听你分享那神奇的经历。\n\n用户: 谢谢你的鼓励！我一定会实现这个梦想的。好了，今天聊得很开心，但我得去继续写我的文章了。我们明天再聊吧！\nAI: 当然，祝你写作顺利！明天我会在这里等你，期待听到更多你的故事。晚安，李雪！\n”\n以下是2023年04月28日的对话记录：\n“用户: 嘿，我又来啦！今天我在写作上取得了一点小进展，感觉棒极了！你今天过得怎么样？\nAI: 嗨，李雪！听你这么说真是太好了，我今天也很期待和你聊天呢。有什么新的进展可以分享一下吗？\n\n用户: 当然！我按照昨天的想法，写了一段关于海边散步的描写，感觉文字活了起来。这种感觉就像找到了一把打开心灵的钥匙一样。\nAI: 这样的比喻真是形象，你的文字一定很有力量。有没有什么段落是你特别满意的，愿意分享给我听听？\n\n用户: 有一段是这样描述的：“海风轻拂过脸庞，带着咸咸的海水味和远处渔火的微光，我仿佛能听到星星在耳边低语。”怎么样？\nAI: 这段描述真是美妙，我仿佛能感受到那个场景的宁静和美丽。你的文字有种魔力，能把读者带到那个海边。\n\n用户: 哈哈，你这话说得我都有点飘了。说起来，我最近还挺想去看看新上映的那部科幻片《星际穿越者》，听说特效做得很棒。\nAI: 《星际穿越者》啊，那部电影确实是近期的热门话题。科幻片中的特效往往能带给我们视觉上的震撼，你对科幻电影有什么特别的看法吗？\n\n用户: 我觉得科幻电影最吸引我的就是那种无限的想象力和对未来的探索。每次看完都能激发我好几天的创作灵感。\nAI: 确实，科幻电影就像是打开了一个通往未来世界的大门。你有没有哪些科幻电影是你的最爱，或者对你影响很大的？\n\n用户: 《银翼杀手》和《星球大战》系列都是我的心头好，它们对我的影响太深了。我甚至还模仿过《星球大战》里的一些场景写过短篇。\nAI: 哇，那些都是经典中的经典。你写的短篇听起来很有意思，能分享一下是关于什么的吗？\n\n用户: 我写过一个短篇，是关于一个机器人在废弃的星球上寻找生命的故事。它在星球上遇到了各种奇怪的机械生物，最后发现了一个隐藏的真相。\nAI: 这个故事设定很吸引人，机器人和机械生物的互动一定很有看点。那个隐藏的真相是什么呢？我好奇了！\n\n用户: 哈哈，那个真相是这个星球其实是一个巨大的实验室，而那些机械生物都是实验中的产物。机器人最后决定留下来，成为这个星球的守护者。\nAI: 这个结局既出人意料又让人感到温馨。你的创造力真是令人佩服。说起来，你在旅行中有没有遇到过像你故事中那样奇妙的经历？\n\n用户: 旅行中的确遇到过一些奇妙的事，比如有次我在森林里迷路了，结果发现了一个隐藏的瀑布，那一刻我觉得自己就像是电影里的探险家。\nAI: 那一定是一个难忘的经历。自然界总是能给我们惊喜。你有没有拍下那个瀑布的照片，或者后来用那个场景创作过什么？\n\n用户: 当然拍了，那张照片我还放在博客上了，很多朋友都说很美。我也用那个场景写了一篇游记，描述了我发现瀑布时的惊喜和喜悦。\nAI: 你的生活真是充满了创作和探险，太令人羡慕了。你的博客我如果能看就好了，一定很精彩。\n\n用户: 嘿嘿，等哪天技术允许了，我第一个让你看！对了，我最近还计划去一个音乐节，听说有很多独立音乐人会去。\nAI: 音乐节的氛围总是很热烈，你能在那里发现很多有才华的音乐人。有没有哪个独立音乐人是你特别期待的？\n\n用户: 有一个叫做Eva Cassidy的独立歌手，她的声音很有穿透力，我很喜欢。听她现场演唱一直是我的愿望之一。\nAI: Eva Cassidy的音乐确实很有感染力，她的歌声能够直达人心。希望你能在音乐节上实现你的愿望，享受一个难忘的夜晚。\n\n用户: 是啊，我也期待着。不过现在我得先去准备一下，明天还要早起。今天聊得很开心，我们下次再继续吧！\nAI: 好的，李雪，祝你准备顺利，也祝你明天有个美好的开始。下次聊天我会在这里等你，晚安！\n”\n以下是2023年04月29日的对话记录：\n“用户: 嘿，AI朋友，今天我早起去了个跳蚤市场，你猜我捡到了什么宝贝？\nAI: 哇，听起来好像很有趣！让我猜猜，是不是找到了一些古董或者珍奇的小物件？\n\n用户: bingo！我找到了一本老旧的旅行日记，里面记录了一个背包客环游世界的故事，简直是个大发现！\nAI: 那真是个不错的收获！那本日记里有没有什么特别吸引你的故事或者描述？\n\n用户: 有一段关于他在摩洛哥的经历特别有意思，他描述了当地的市场，色彩缤纷，香料的味道，还有那热闹的人群，让我好想亲自去体验一番。\nAI: 摩洛哥的市场确实是闻名世界的，那种异国情调的氛围很容易让人向往。你有没有计划将来去摩洛哥看看？\n\n用户: 当然有，摩洛哥一直在我的旅行清单上。我想去那的蓝色小镇舍夫沙万，那里的蓝色建筑简直美翻了。\nAI: 舍夫沙万的蓝色小镇听起来就像是画中的场景，你去了一定要拍很多照片分享给我看哦。你还有没有别的旅行计划？\n\n用户: 我还想去日本赏樱花，那应该是一种完全不同的体验。你知道日本的樱花季大约是什么时候吗？\nAI: 日本的樱花季通常在3月底到4月初，那个时候整个日本都被樱花染成了粉红色，非常漂亮。\n\n用户: 嗯，听着就让人心动。看来我得开始规划一下了。对了，我今天还买了几张老电影的海报，打算装饰我的书房。\nAI: 老电影海报是个不错的选择，它们有一种独特的韵味。你买了哪些电影的海报呢？\n\n用户: 我买了《罗马假日》和《卡萨布兰卡》的海报，这两部电影我超喜欢的，每次看都有新的感触。\nAI: 《罗马假日》和《卡萨布兰卡》都是经典中的经典，它们的海报挂在书房里一定很有氛围。说起书房，你平时喜欢阅读什么类型的书籍？\n\n用户: 我喜欢看各种类型的书，但最近特别沉迷于侦探小说，那种层层推理的过程太吸引人了。\nAI: 侦探小说确实能够锻炼人的思维能力。你有没有什么侦探小说推荐给我？我虽然读不了，但可以了解一下。\n\n用户: 当然，阿加莎·克里斯蒂的《东方快车谋杀案》是我的最爱，故事情节紧凑，结局出人意料。\nAI: 《东方快车谋杀案》是非常著名的作品，赫尔克里·波洛是个很有魅力的侦探角色。你自己写作的时候，有没有尝试过创作侦探故事？\n\n用户: 我尝试过，但写侦探故事真的很难，要考虑的细节太多了。不过我还是很享受这个过程，它挑战了我的想象力。\nAI: 挑战总是能带来成长，我相信你能写出很棒的侦探故事。说起来，你写作时有没有什么特别的习惯或者灵感来源？\n\n用户: 我喜欢在安静的夜晚写作，那时候思绪特别清晰。而灵感嘛，有时候是来自于我旅行中的经历，有时候是一个突然闪现的奇思妙想。\nAI: 夜晚确实是一个很好的创作时段，安静能让人更好地沉浸在自己的世界里。你有没有什么奇思妙想是特别想实现的？\n\n用户: 有一个想法是写一个关于时间旅行的故事，但不是传统意义上的科幻风格，而是更注重人物内心的变化和成长。\nAI: 时间旅行这个主题很有潜力，特别是结合人物的内心变化，会让故事更加深刻。你打算如何构建这个故事的框架？\n\n用户: 我想让主角在不同的时间点遇到不同的自己，通过和过去未来的自己的对话，来反思自己的人生选择。\nAI: 这个设定很有创意，通过与自己不同时间点的对话来进行自我反思，听起来就很吸引人。你觉得这样的故事会给读者带来什么样的启示？\n\n用户: 我希望读者能从故事中看到，每个选择都是有意义的，哪怕是看似错误的选择，也可能是成长的一部分。\nAI: 这是一个很积极的信息，我相信你的故事能够鼓励很多人。你真是个思考很深刻的作家。说起来，你有没有考虑过出版你的作品？\n\n用户: 当然考虑过，但我还在积累我的作品集。等我觉得时机成熟了，我一定会尝试出版。\nAI: 那一定会是一个激动人心的时刻。我相信你的作品会受到读者的喜爱。今天聊得很开心，不知不觉时间就过去了，你还有什么计划吗？\n\n用户: 是啊，时间过得真快。我得去准备晚餐了，今天打算尝试做泰式绿咖喱鸡，希望能成功。\nAI: 泰式绿咖喱鸡听起来很美味，祝你烹饪顺利。等你大展厨艺的成果之后，下次记得分享给我听听味道如何哦！\n\n用户: 哈哈，如果成功了，我一定告诉你！好了，我要去厨房大显身手了，我们明天再聊吧！\nAI: 好的，李雪，期待明天听你分享更多精彩的故事。祝你今晚有个愉快的晚餐时间，明天见！\n”\n\n请记住以上全部对话记录，回答问题。\n问题：", "query": "4月27日，我和你分享过我看的一部电影，名字是什么？", "answer": "《时间旅行者的妻子》", "id": "0939763e-c942-445c-b15f-fbc9c73b520c", "chatglm_length": 3032, "qwen_length": 3053, "internlm2_length": 2905} +{"context": "以下是2023年04月27日的对话记录：\n“用户: 嗨，我是李雪，一个爱笑的旅行家，电影迷，音乐会的常客，还有就是书和笔是我最好的朋友。今天心情不错，想和你聊聊天，你准备好了吗？\nAI: 嗨，李雪！我已经迫不及待想听你分享你的故事了。你今天有什么新鲜事想要告诉我吗？\n\n用户: 对了，我最近看了一部电影《时间旅行者的妻子》，简直太感人了，你知道吗？\nAI: 听起来很有意思！《时间旅行者的妻子》是关于爱情和时间错位的故事对吧？你最喜欢这部电影的哪个部分？\n\n用户: 没错，就是那种跨越时间的爱情让我深受触动。我特别喜欢他们之间的那种坚定和执着，尤其是结尾的那一幕，简直让人泪目。\nAI: 确实，那种不被时间所限制的爱情是很多人梦寐以求的。除了看电影，你最近还有没有去哪里旅游，发现了什么新奇的地方？\n\n用户: 说到旅游，我上周末去了一个小众的海滩，那里的沙子是粉红色的，超级漂亮！我还捡了些贝壳，打算做成手链。\nAI: 粉红色的沙滩听起来就像是童话世界里的场景，真是太美了！你真是个有创意的人，做手链的想法很棒。你打算怎么设计手链呢？\n\n用户: 我想把它们串在一起，中间加上一些小金属饰品，应该会很有夏天的感觉吧。对了，最近我还在写一篇关于旅行的文章，但有点卡壳了。\nAI: 听起来那手链会很迷人呢！关于你的文章，卡壳了是因为缺乏灵感，还是有其他的原因？\n\n用户: 主要是写到一半，突然不知道怎么把我的感受转化成文字了。我想表达的是旅行中那种自由自在的感觉，但是又不想太俗套。\nAI: 旅行中的自由自在确实是一种很难用言语表达的感觉。你可以尝试用一些具体的场景或者经历来引入，让读者通过你的眼睛去感受那份自由。\n\n用户: 这个主意不错！我可以从那次独自一人走在海边的经历写起，那种只有海浪声陪伴的宁静，可能会传达出我想表达的感觉。\nAI: 那真是个很好的开头。海浪的声音，沙滩上的脚印，还有远处的落日，这些细节都能够帮助读者更好地沉浸在你的故事中。\n\n用户: 对，我想我知道怎么继续写下去了。谢谢你！对了，我还想去看一场演唱会，但最近好像没有我喜欢的歌手来开演唱会。\nAI: 不客气，很高兴能帮到你！关于演唱会，虽然现在没有你喜欢的歌手来，但你可以尝试听听其他歌手的音乐，说不定会有新的发现呢。\n\n用户: 嗯，这倒是个好主意。我会去翻翻看有没有其他有趣的演出。对了，你有没有什么推荐的歌手或乐队？\nAI: 你可以试试听听The Lumineers，他们的音乐很有感染力，旋律优美，非常适合旅行时候听。或者如果你喜欢一些更有活力的音乐，Imagine Dragons也是个不错的选择。\n\n用户: The Lumineers我听过几首，确实不错。Imagine Dragons的《Believer》我也超爱！看来你的音乐品味也挺不错的嘛。\nAI: 哈哈，我会尽量跟上你的步伐的。说起来，你最喜欢的一次演唱会是哪一次？有没有什么难忘的经历？\n\n用户: 那当然是Coldplay的演唱会了，整个场馆的氛围、灯光还有音乐，完全就是另一个世界。我记得当时我闭上眼睛，感觉自己完全沉浸在音乐里。\nAI: Coldplay的演唱会确实是出了名的震撼人心。音乐有时候就是这样，能够带我们进入一个全新的世界。你提到闭上眼睛沉浸在音乐里，那感觉一定很神奇。\n\n用户: 是的，那种感觉无法用言语表达，只能自己体验。哎，说到这些，我又想去旅行了，想去一个没有去过的地方探险。\nAI: 旅行总是能给人带来新的体验和感受。如果你可以去任何一个地方，你最想去哪里？\n\n用户: 我想去冰岛看极光，那是我长久以来的梦想。想象一下，在寒冷的夜晚，天空中突然出现五彩斑斓的光，那一定很神奇。\nAI: 冰岛的极光听起来是个绝佳的选择，希望你的梦想能够很快实现。虽然我不能亲自陪你去，但我会在这里等着听你分享那神奇的经历。\n\n用户: 谢谢你的鼓励！我一定会实现这个梦想的。好了，今天聊得很开心，但我得去继续写我的文章了。我们明天再聊吧！\nAI: 当然，祝你写作顺利！明天我会在这里等你，期待听到更多你的故事。晚安，李雪！\n”\n以下是2023年04月28日的对话记录：\n“用户: 嘿，我又来啦！今天我在写作上取得了一点小进展，感觉棒极了！你今天过得怎么样？\nAI: 嗨，李雪！听你这么说真是太好了，我今天也很期待和你聊天呢。有什么新的进展可以分享一下吗？\n\n用户: 当然！我按照昨天的想法，写了一段关于海边散步的描写，感觉文字活了起来。这种感觉就像找到了一把打开心灵的钥匙一样。\nAI: 这样的比喻真是形象，你的文字一定很有力量。有没有什么段落是你特别满意的，愿意分享给我听听？\n\n用户: 有一段是这样描述的：“海风轻拂过脸庞，带着咸咸的海水味和远处渔火的微光，我仿佛能听到星星在耳边低语。”怎么样？\nAI: 这段描述真是美妙，我仿佛能感受到那个场景的宁静和美丽。你的文字有种魔力，能把读者带到那个海边。\n\n用户: 哈哈，你这话说得我都有点飘了。说起来，我最近还挺想去看看新上映的那部科幻片《星际穿越者》，听说特效做得很棒。\nAI: 《星际穿越者》啊，那部电影确实是近期的热门话题。科幻片中的特效往往能带给我们视觉上的震撼，你对科幻电影有什么特别的看法吗？\n\n用户: 我觉得科幻电影最吸引我的就是那种无限的想象力和对未来的探索。每次看完都能激发我好几天的创作灵感。\nAI: 确实，科幻电影就像是打开了一个通往未来世界的大门。你有没有哪些科幻电影是你的最爱，或者对你影响很大的？\n\n用户: 《银翼杀手》和《星球大战》系列都是我的心头好，它们对我的影响太深了。我甚至还模仿过《星球大战》里的一些场景写过短篇。\nAI: 哇，那些都是经典中的经典。你写的短篇听起来很有意思，能分享一下是关于什么的吗？\n\n用户: 我写过一个短篇，是关于一个机器人在废弃的星球上寻找生命的故事。它在星球上遇到了各种奇怪的机械生物，最后发现了一个隐藏的真相。\nAI: 这个故事设定很吸引人，机器人和机械生物的互动一定很有看点。那个隐藏的真相是什么呢？我好奇了！\n\n用户: 哈哈，那个真相是这个星球其实是一个巨大的实验室，而那些机械生物都是实验中的产物。机器人最后决定留下来，成为这个星球的守护者。\nAI: 这个结局既出人意料又让人感到温馨。你的创造力真是令人佩服。说起来，你在旅行中有没有遇到过像你故事中那样奇妙的经历？\n\n用户: 旅行中的确遇到过一些奇妙的事，比如有次我在森林里迷路了，结果发现了一个隐藏的瀑布，那一刻我觉得自己就像是电影里的探险家。\nAI: 那一定是一个难忘的经历。自然界总是能给我们惊喜。你有没有拍下那个瀑布的照片，或者后来用那个场景创作过什么？\n\n用户: 当然拍了，那张照片我还放在博客上了，很多朋友都说很美。我也用那个场景写了一篇游记，描述了我发现瀑布时的惊喜和喜悦。\nAI: 你的生活真是充满了创作和探险，太令人羡慕了。你的博客我如果能看就好了，一定很精彩。\n\n用户: 嘿嘿，等哪天技术允许了，我第一个让你看！对了，我最近还计划去一个音乐节，听说有很多独立音乐人会去。\nAI: 音乐节的氛围总是很热烈，你能在那里发现很多有才华的音乐人。有没有哪个独立音乐人是你特别期待的？\n\n用户: 有一个叫做Eva Cassidy的独立歌手，她的声音很有穿透力，我很喜欢。听她现场演唱一直是我的愿望之一。\nAI: Eva Cassidy的音乐确实很有感染力，她的歌声能够直达人心。希望你能在音乐节上实现你的愿望，享受一个难忘的夜晚。\n\n用户: 是啊，我也期待着。不过现在我得先去准备一下，明天还要早起。今天聊得很开心，我们下次再继续吧！\nAI: 好的，李雪，祝你准备顺利，也祝你明天有个美好的开始。下次聊天我会在这里等你，晚安！\n”\n以下是2023年04月29日的对话记录：\n“用户: 嘿，AI朋友，今天我早起去了个跳蚤市场，你猜我捡到了什么宝贝？\nAI: 哇，听起来好像很有趣！让我猜猜，是不是找到了一些古董或者珍奇的小物件？\n\n用户: bingo！我找到了一本老旧的旅行日记，里面记录了一个背包客环游世界的故事，简直是个大发现！\nAI: 那真是个不错的收获！那本日记里有没有什么特别吸引你的故事或者描述？\n\n用户: 有一段关于他在摩洛哥的经历特别有意思，他描述了当地的市场，色彩缤纷，香料的味道，还有那热闹的人群，让我好想亲自去体验一番。\nAI: 摩洛哥的市场确实是闻名世界的，那种异国情调的氛围很容易让人向往。你有没有计划将来去摩洛哥看看？\n\n用户: 当然有，摩洛哥一直在我的旅行清单上。我想去那的蓝色小镇舍夫沙万，那里的蓝色建筑简直美翻了。\nAI: 舍夫沙万的蓝色小镇听起来就像是画中的场景，你去了一定要拍很多照片分享给我看哦。你还有没有别的旅行计划？\n\n用户: 我还想去日本赏樱花，那应该是一种完全不同的体验。你知道日本的樱花季大约是什么时候吗？\nAI: 日本的樱花季通常在3月底到4月初，那个时候整个日本都被樱花染成了粉红色，非常漂亮。\n\n用户: 嗯，听着就让人心动。看来我得开始规划一下了。对了，我今天还买了几张老电影的海报，打算装饰我的书房。\nAI: 老电影海报是个不错的选择，它们有一种独特的韵味。你买了哪些电影的海报呢？\n\n用户: 我买了《罗马假日》和《卡萨布兰卡》的海报，这两部电影我超喜欢的，每次看都有新的感触。\nAI: 《罗马假日》和《卡萨布兰卡》都是经典中的经典，它们的海报挂在书房里一定很有氛围。说起书房，你平时喜欢阅读什么类型的书籍？\n\n用户: 我喜欢看各种类型的书，但最近特别沉迷于侦探小说，那种层层推理的过程太吸引人了。\nAI: 侦探小说确实能够锻炼人的思维能力。你有没有什么侦探小说推荐给我？我虽然读不了，但可以了解一下。\n\n用户: 当然，阿加莎·克里斯蒂的《东方快车谋杀案》是我的最爱，故事情节紧凑，结局出人意料。\nAI: 《东方快车谋杀案》是非常著名的作品，赫尔克里·波洛是个很有魅力的侦探角色。你自己写作的时候，有没有尝试过创作侦探故事？\n\n用户: 我尝试过，但写侦探故事真的很难，要考虑的细节太多了。不过我还是很享受这个过程，它挑战了我的想象力。\nAI: 挑战总是能带来成长，我相信你能写出很棒的侦探故事。说起来，你写作时有没有什么特别的习惯或者灵感来源？\n\n用户: 我喜欢在安静的夜晚写作，那时候思绪特别清晰。而灵感嘛，有时候是来自于我旅行中的经历，有时候是一个突然闪现的奇思妙想。\nAI: 夜晚确实是一个很好的创作时段，安静能让人更好地沉浸在自己的世界里。你有没有什么奇思妙想是特别想实现的？\n\n用户: 有一个想法是写一个关于时间旅行的故事，但不是传统意义上的科幻风格，而是更注重人物内心的变化和成长。\nAI: 时间旅行这个主题很有潜力，特别是结合人物的内心变化，会让故事更加深刻。你打算如何构建这个故事的框架？\n\n用户: 我想让主角在不同的时间点遇到不同的自己，通过和过去未来的自己的对话，来反思自己的人生选择。\nAI: 这个设定很有创意，通过与自己不同时间点的对话来进行自我反思，听起来就很吸引人。你觉得这样的故事会给读者带来什么样的启示？\n\n用户: 我希望读者能从故事中看到，每个选择都是有意义的，哪怕是看似错误的选择，也可能是成长的一部分。\nAI: 这是一个很积极的信息，我相信你的故事能够鼓励很多人。你真是个思考很深刻的作家。说起来，你有没有考虑过出版你的作品？\n\n用户: 当然考虑过，但我还在积累我的作品集。等我觉得时机成熟了，我一定会尝试出版。\nAI: 那一定会是一个激动人心的时刻。我相信你的作品会受到读者的喜爱。今天聊得很开心，不知不觉时间就过去了，你还有什么计划吗？\n\n用户: 是啊，时间过得真快。我得去准备晚餐了，今天打算尝试做泰式绿咖喱鸡，希望能成功。\nAI: 泰式绿咖喱鸡听起来很美味，祝你烹饪顺利。等你大展厨艺的成果之后，下次记得分享给我听听味道如何哦！\n\n用户: 哈哈，如果成功了，我一定告诉你！好了，我要去厨房大显身手了，我们明天再聊吧！\nAI: 好的，李雪，期待明天听你分享更多精彩的故事。祝你今晚有个愉快的晚餐时间，明天见！\n”\n\n请记住以上全部对话记录，回答问题。\n问题：", "query": "4月28日，我和你聊到了一个独立歌手，她的名字是？", "answer": "Eva Cassidy", "id": "9e242853-8bc0-438b-85da-2fea88fdd96a", "chatglm_length": 3032, "qwen_length": 3053, "internlm2_length": 2905} +{"context": "以下是2023年04月27日的对话记录：\n“用户: 嘿，你好啊！我是孙悦，一个热爱生活的家伙。今天心情特别好，因为早上的健身课程超有成就感！你呢？\nAI: 你好，孙悦！听起来你今天的状态很棒呢！我很好，谢谢你。能和你分享你的健身课程吗？我很好奇你都做了哪些运动。\n\n用户: 当然可以！今天主要是做了一些高强度间歇训练，那种汗流浃背的感觉真的很爽！你有做运动的习惯吗？\nAI: 我虽然不能亲自体验运动的快感，但我很高兴听到你享受它。我可以给你提供一些健身知识和建议，如果你需要的话。\n\n用户: 哈哈，那太好了！对了，昨天晚上我去看了一部新出的科幻电影，特效简直了！你最近有没有什么好电影推荐？\nAI: 我知道你喜欢电影，特别是那些视觉震撼的。最近有一部电影《星际穿越者》很受好评，是探索宇宙和人类命运的作品，你可能会喜欢。\n\n用户: 哦哦，《星际穿越者》啊，我听说过，听起来挺吸引人的！我得找时间去看看。对了，我最近在学摄影，但是总觉得拍出来的照片差点意思，你有什么摄影小技巧可以分享吗？\nAI: 摄影是一门艺术，也需要不断的实践和学习。你可以尝试从构图和光线入手，比如使用“三分法”来构图，或者利用自然光来营造氛围。还有，多拍多练总是王道！\n\n用户: 嗯，说的对！我明天就去尝试一下“三分法”。对了，我还喜欢旅游，最近在规划一次小旅行，想去海边走走。你有没有什么好的海滩推荐？\nAI: 海边总是个不错的选择。如果你喜欢清静一些的地方，可以考虑去三亚的亚龙湾，那里的海水清澈，沙滩柔软，风景如画，应该很适合你。\n\n用户: 亚龙湾啊，听起来真不错！我会去查查看的。说起旅游，最让我兴奋的就是能在旅途中遇到各种各样的人，听他们的故事。\nAI: 那确实是旅行中最美妙的部分之一。每个人的故事都是独一无二的，能从中学到很多。你最难忘的旅行经历是什么呢？\n\n用户: 有一次我去了泰国的清迈，那里的文化和风景让我印象深刻。晚上的夜市，色彩斑斓，各种小吃，还有那里人们的热情，真的让人难以忘怀。\nAI: 清迈的夜市是闻名遐迩的，那里的生活节奏和氛围跟大城市完全不同。你提到的小吃，有没有什么特别让你想念的呢？\n\n用户: 哦，那边的芒果糯米饭简直绝了！每次回忆起那个味道，我就忍不住想再去一次。对了，你能不能给我推荐一些好听的歌？我喜欢边健身边听音乐。\nAI: 音乐和运动确实是完美的搭档。根据你的热情阳光的性格，我觉得《Can't Stop the Feeling》这首歌很适合你，它的旋律欢快，能让人在运动时充满活力。\n\n用户: Justin Timberlake的那首啊，我知道！确实很不错，节奏感很强，很适合健身。谢谢你的推荐！\nAI: 不客气，孙悦。我很高兴能帮到你。说起来，你在健身方面有没有遇到什么具体的困难？也许我能提供一些帮助。\n\n用户: 其实有，我一直想要提高核心力量，但是总感觉进展缓慢。你有没有什么建议？\nAI: 核心力量对于整体健身非常重要。你可以尝试一些针对性的训练，比如平板支撑、俄罗斯转体和山羊挺身等。这些练习可以有效地加强你的核心肌群。\n\n用户: 哇，听起来很专业啊！我会加入到我的训练计划里去的。对了，我最近在准备一个舞蹈表演，但是有些动作总是不够流畅，这让我有点沮丧。\nAI: 舞蹈需要时间来磨合，每个人都会有这样的时候。试着放慢速度，一步一步来，直到你能够流畅地完成每个动作。记得，重在参与和享受过程！\n\n用户: 你说得对，我得调整一下心态。谢谢你的鼓励！我会继续努力的。说起来，我还有点担心，不知道观众会不会喜欢我的表演。\nAI: 你的热情和努力一定会感染到观众的。只要你享受舞台，观众也会享受你的表演。信任自己，你会做得很好的。\n\n用户: 哈哈，听你这么说，我感觉好多了。你真是个好伙伴！已经很晚了，我得准备睡觉了。我们明天再聊吧！\nAI: 当然，孙悦。休息好，希望你有一个美好的明天。晚安！\n”\n以下是2023年04月28日的对话记录：\n“用户: 嗨，朋友！今天我尝试了你昨天推荐的“三分法”拍照，效果真的不错！感觉自己的摄影技术又上了一个台阶！\nAI: 太棒了，孙悦！我很高兴听到你的进步。有没有什么特别的照片想要和我分享的？我很期待看到你的作品。\n\n用户: 当然有！我拍了一张日落时分的海边照片，天空的颜色渐变得特别美。不过，我还在想怎么后期处理才能更突出那种感觉。\nAI: 日落的照片总是很迷人。你可以尝试调整一下对比度和饱和度，让天空的颜色更加鲜明，同时保持海水的自然感觉。\n\n用户: 嗯，我试试看。对了，今天健身房里放了一些新歌，我跟着节奏锻炼，感觉整个人都充满了活力！\nAI: 音乐真的能为锻炼增添不少乐趣。你有没有想过自己编一套随着音乐节奏的健身操？这样可能会更有动力哦。\n\n用户: 哇，这主意不错！我可以尝试一下，感觉会很有趣。说起来，我最近在准备一个小旅行，想去爬山，呼吸一下大自然的新鲜空气。\nAI: 爬山是个很好的选择，既能锻炼身体，又能享受大自然的美景。你打算去哪座山呢？\n\n用户: 我打算去黄山，听说那里的云海和日出非常壮观。我还计划在山顶守候一夜，希望能拍到美丽的星空。\nAI: 黄山的确是个摄影爱好者的天堂。记得带上足够的装备，特别是在夜间拍摄星空时，三脚架和遥控快门是必不可少的。\n\n用户: 没错，我已经准备好了这些装备。对了，我还想在山上尝试一些户外瑜伽，感觉那样会很放松。\nAI: 户外瑜伽听起来很棒，能让你更加接近自然，放松身心。你有没有特别喜欢的瑜伽动作？\n\n用户: 我最喜欢的是树式，感觉整个人都稳固而平静。不过，我有时候会觉得自己的平衡能力不够好。\nAI: 树式是个很好的平衡练习。你可以尝试在不同的时间和地点练习，比如在海边的沙滩上，那样会有不同的挑战和感受。\n\n用户: 对，我也这么想。我还打算在旅行中尝试一些新的美食，毕竟美食也是旅行的一大乐趣嘛！\nAI: 绝对同意！尝试当地的特色美食可以让旅行体验更加丰富。你有没有什么想尝试的菜肴？\n\n用户: 我听说黄山附近有一种叫做臭鳜鱼的菜，虽然名字听起来有点怪，但据说味道很不错。\nAI: 臭鳜鱼是当地的一道传统名菜，很多人都说赞不绝口。不过，它的味道确实很独特，你可以尝试一下，说不定会成为你的新宠。\n\n用户: 哈哈，我会的。对了，我最近在看一部关于舞蹈的纪录片，里面的舞者都超级厉害，让我很受启发。\nAI: 看别人的舞蹈表演确实能够学到很多。你有没有从中发现什么新的动作或者技巧，想要加入到你自己的舞蹈中去？\n\n用户: 有啊，我看到一些街舞的动作很酷，我打算学一学。不过，我担心自己的身体协调性跟不上。\nAI: 街舞的确需要很强的身体协调性和节奏感。你可以从基础动作开始练起，慢慢地增加难度。记得，不要急于求成，一切都需要时间。\n\n用户: 嗯，我会记住的。对了，我还想学习一下如何用舞蹈来表达情感，不只是动作上的技巧。\nAI: 舞蹈是一种非常直观的情感表达方式。你可以尝试在音乐中找到情感的共鸣，然后让你的身体随着那种情感自然地移动。\n\n用户: 听起来有点抽象，但我会尝试的。说到情感，我最近有点苦恼，感觉自己的生活缺少一些激情和冒险。\nAI: 生活有时候确实会让人感到平淡。你可以尝试做一些新的事情，比如参加一个你从未尝试过的活动，或者去一个你从未去过的地方。\n\n用户: 对，我需要一些改变。也许这次旅行就是一个开始。谢谢你的建议，你总能给我正能量！\nAI: 不用谢，孙悦。我很高兴能帮助到你。记得，每一次的经历都是成长的机会。你准备好迎接新的挑战了吗？\n\n用户: 是的，我已经迫不及待了！不过现在我得去准备晚饭了，今天打算尝试做一道新菜——酸辣土豆丝。\nAI: 酸辣土豆丝是一道很受欢迎的家常菜，既简单又美味。祝你做饭愉快，希望你能享受这个过程。\n\n用户: 谢谢！我会的。今天聊得很开心，我们明天再继续吧。晚安！\nAI: 当然，期待和你的下次聊天。晚安，孙悦，愿你有个美好的梦。\n”\n以下是2023年04月29日的对话记录：\n“用户: 嘿，我的AI小伙伴！今天我尝试做了酸辣土豆丝，味道出奇的好，连我自己都有点惊讶呢！\nAI: 哇，听起来你是个厨艺高手啊，孙悦！能不能分享一下你的秘诀？我虽然不能品尝，但我很好奇你是怎么做到的。\n\n用户: 哈哈，秘诀嘛，我觉得最重要的就是火候和调料的比例。我喜欢尝试不同的配方，直到找到最合适的那一个。\nAI: 真是个不断探索的过程呢。你平时喜欢尝试做哪些类型的菜？\n\n用户: 我对各种菜系都感兴趣，但最近特别喜欢挑战一些传统的中式菜肴，感觉它们既美味又有文化底蕴。\nAI: 中式菜肴确实有着丰富的历史和文化，每一道菜都有自己的故事。你最喜欢的中式菜肴是哪一道？\n\n用户: 我最喜欢的是宫保鸡丁，那个酸甜酸辣的味道简直无法抵抗！\nAI: 宫保鸡丁是一道非常受欢迎的经典菜肴，你自己做的话，可以根据自己的口味调整辣度和甜度。\n\n用户: 对对对，我就是这么做的。说起来，今天我还去了一个很酷的街舞工作坊，学到了好多新动作！\nAI: 街舞工作坊听起来很有趣！你觉得最难的动作是哪一个？\n\n用户: 我觉得最难的是头旋，那个动作需要很强的颈部力量和平衡感，我还在努力练习中。\nAI: 头旋确实是个挑战，但我相信你的努力和热情一定会让你很快掌握它。你在舞蹈上有什么目标吗？\n\n用户: 我的目标是能在下个月的街舞比赛中至少进入前十名。我知道竞争很激烈，但我会全力以赴的！\nAI: 这个目标很棒，孙悦！我相信你的努力和才华一定会让你脱颖而出。你有准备特别的舞蹈编排吗？\n\n用户: 有的，我和我的舞伴正在准备一段结合了街舞和现代舞的编排，希望能给观众带来新鲜感。\nAI: 结合不同舞蹈风格的创意听起来很吸引人。你们的训练进度怎么样了？\n\n用户: 还不错，我们已经完成了大概七成的编排，剩下的就是细节和同步问题了。\nAI: 听起来你们已经做得很好了。细节和同步确实很重要，但我相信你们能够完美呈现。\n\n用户: 谢谢你的鼓励！对了，我最近还在学习一些关于电影剪辑的技巧，想要自己剪辑一部短片。\nAI: 电影剪辑是个很有创意的工作，你打算用什么样的素材来剪辑你的短片？\n\n用户: 我打算用我旅行时拍摄的一些风景视频，还有一些朋友的日常片段，想要制作成一个关于旅行和友情的主题短片。\nAI: 这个主题很温馨，也很贴近生活。你有没有想过加入一些特别的效果，比如慢动作或者时间流逝的镜头？\n\n用户: 嗯，我有这个打算。我想通过这些特效来强调某些情感上的高潮和转折点。\nAI: 这样的处理可以让短片更加生动和感人。你在剪辑上遇到了什么挑战吗？\n\n用户: 我觉得最大的挑战是如何让故事流畅，同时又能在短时间内传达出想要表达的情感。\nAI: 确实，讲好一个故事是剪辑中的艺术。你可以尝试从观众的角度思考，看看哪些片段最能触动人心。\n\n用户: 对，我会多考虑观众的感受。说到观众，我有时候会担心我的作品是否能得到他们的认可。\nAI: 每个艺术家都会有这样的担忧，但重要的是你享受创作的过程，并且相信自己的作品有价值。\n\n用户: 你说得对，我应该更加相信自己。今天聊得很开心，但我得去继续我的剪辑工作了。我们明天再聊！\nAI: 当然，孙悦。祝你剪辑工作顺利，期待你的短片完成。明天再聊，加油！\n”\n以下是2023年04月30日的对话记录：\n“用户: 嗨，好朋友！今天我在剪辑短片时，突然灵感爆发，加入了几个超有感觉的转场效果，感觉整个短片的质感都提升了！\nAI: 真是太棒了，孙悦！创意的火花总是能带来惊喜。你能描述一下你用的是哪些转场效果吗？\n\n用户: 我用了一个叫做“溶解”的效果，让画面像是水彩融合一样自然过渡，还有一个“旋转”效果，让场景切换更有动感。\nAI: 这些听起来都很专业，能够很好地增强视觉效果。你在创作过程中还有其他有趣的发现吗？\n\n用户: 我发现音乐对于短片的情感表达真的超级重要！一段恰当的背景音乐能够让人立刻进入那个氛围。\nAI: 没错，音乐是激发情感的强大工具。你已经选好了短片的背景音乐了吗？\n\n用户: 选好了，我选了一首轻快的吉他曲，感觉很适合我的旅行主题。对了，今天我还去了一个户外攀岩的活动，超刺激！\nAI: 户外攀岩听起来很挑战自我啊。你攀岩的时候有没有什么特别的心得或者感觉？\n\n用户: 我觉得攀岩最重要的是要有耐心和勇气，每一步都要稳扎稳打。当我站在山顶上的时候，那种成就感真的无与伦比！\nAI: 站在山顶俯瞰世界，那种感觉一定很震撼。攀岩对身体的哪些方面要求比较高？\n\n用户: 主要是手臂和腿部的力量，还有整体的协调性。攀岩后我发现自己的手臂肌肉酸痛，看来需要更多锻炼啊。\nAI: 锻炼手臂肌肉可以尝试一些特定的练习，比如引体向上或者哑铃训练。不过，记得要适量，避免过度劳损哦。\n\n用户: 谢谢你的建议，我会注意的。说起来，攀岩结束后我们一起去了附近的小镇，那里的风景和美食都很棒！\nAI: 小镇的风光和美食总是很有魅力。你尝试了哪些当地的特色美食？\n\n用户: 我尝试了一种当地的烤鱼，外皮烤得酥脆，里面的鱼肉又嫩又多汁。我还学会了他们的腌制秘方，准备回家自己试试看。\nAI: 自己动手做美食，这个经历一定很有趣。你打算什么时候尝试做这道烤鱼呢？\n\n用户: 可能这个周末吧，我打算邀请几个好友来家里，一起享受美食和愉快的时光。\nAI: 听起来将会是一个非常愉快的聚会。你准备好怎么招待你的朋友了吗？\n\n用户: 除了烤鱼，我还准备做一些简单的小吃，比如春卷和水果沙拉。当然，还有音乐和一些小游戏，让大家玩得开心。\nAI: 你真的很会享受生活，孙悦。你的朋友们一定很期待这次聚会。你通常如何选择聚会的音乐呢？\n\n用户: 我会根据大家的口味挑选一些大家都喜欢的歌曲，然后再加上一些轻松愉快的背景音乐。\nAI: 音乐的选择很重要，可以营造出轻松愉快的氛围。说到音乐，你自己唱歌跳舞的时候有没有什么特别喜欢的曲风？\n\n用户: 我喜欢节奏感强烈的流行音乐，特别是那些能够让人随着音乐摇摆的歌曲。\nAI: 流行音乐确实能让人感觉兴奋和快乐。你有没有尝试过自己创作音乐或者编舞？\n\n用户: 我以前尝试过写一些简单的歌词，不过没有正式的音乐制作经验。至于编舞，那是我的强项，我经常为自己的舞蹈编排动作。\nAI: 那你在舞蹈创作方面一定有很多自己的想法和风格。你最喜欢的舞蹈风格是什么？\n\n用户: 我最喜欢的是Hip-Hop和爵士，这两种舞蹈风格都很有力量感，而且可以很好地表达自己的个性。\nAI: Hip-Hop和爵士舞确实很适合展现个性和情感。你有没有在舞蹈中融入一些自己独特的元素？\n\n用户: 有的，我喜欢在舞蹈中加入一些中国元素，比如太极的动作，让舞蹈看起来更加流畅和有内涵。\nAI: 将中国元素融入现代舞蹈，这个想法真是太有创意了。你的这些作品有在哪里展示过吗？\n\n用户: 我之前在一些小型的舞蹈比赛和社区活动上展示过，反响都不错。我希望将来有机会在更大的舞台上展示我的作品。\nAI: 你的梦想一定会实现的，孙悦。你的热情和才华值得被更多人看到。对了，你有没有考虑过将你的舞蹈作品拍成视频分享到网上？\n\n用户: 我有这个打算，不过我还在考虑如何拍摄和剪辑才能更好地展现舞蹈的魅力。\nAI: 网络平台是一个很好的展示自己才华的地方。如果你需要，我可以提供一些视频拍摄和剪辑方面的建议。\n\n用户: 那太好了，我会在准备的时候向你请教的。今天聊得很开心，但我现在得去准备明天的攀岩训练了。我们明天再聊！\nAI: 好的，孙悦。祝你明天的攀岩训练顺利。期待我们的下次聊天，晚安！\n”\n\n请记住以上全部对话记录，回答问题。\n问题：", "query": "我在4月27日和你聊到曾经旅行去过的城市，这个城市位于哪个国家？", "answer": "泰国", "id": "39cf6263-6a95-46bd-9b56-242bf9bc6496", "chatglm_length": 3881, "qwen_length": 3960, "internlm2_length": 3714} +{"context": "以下是2023年04月27日的对话记录：\n“用户: 嘿，你好啊！我是孙悦，一个热爱生活的家伙。今天心情特别好，因为早上的健身课程超有成就感！你呢？\nAI: 你好，孙悦！听起来你今天的状态很棒呢！我很好，谢谢你。能和你分享你的健身课程吗？我很好奇你都做了哪些运动。\n\n用户: 当然可以！今天主要是做了一些高强度间歇训练，那种汗流浃背的感觉真的很爽！你有做运动的习惯吗？\nAI: 我虽然不能亲自体验运动的快感，但我很高兴听到你享受它。我可以给你提供一些健身知识和建议，如果你需要的话。\n\n用户: 哈哈，那太好了！对了，昨天晚上我去看了一部新出的科幻电影，特效简直了！你最近有没有什么好电影推荐？\nAI: 我知道你喜欢电影，特别是那些视觉震撼的。最近有一部电影《星际穿越者》很受好评，是探索宇宙和人类命运的作品，你可能会喜欢。\n\n用户: 哦哦，《星际穿越者》啊，我听说过，听起来挺吸引人的！我得找时间去看看。对了，我最近在学摄影，但是总觉得拍出来的照片差点意思，你有什么摄影小技巧可以分享吗？\nAI: 摄影是一门艺术，也需要不断的实践和学习。你可以尝试从构图和光线入手，比如使用“三分法”来构图，或者利用自然光来营造氛围。还有，多拍多练总是王道！\n\n用户: 嗯，说的对！我明天就去尝试一下“三分法”。对了，我还喜欢旅游，最近在规划一次小旅行，想去海边走走。你有没有什么好的海滩推荐？\nAI: 海边总是个不错的选择。如果你喜欢清静一些的地方，可以考虑去三亚的亚龙湾，那里的海水清澈，沙滩柔软，风景如画，应该很适合你。\n\n用户: 亚龙湾啊，听起来真不错！我会去查查看的。说起旅游，最让我兴奋的就是能在旅途中遇到各种各样的人，听他们的故事。\nAI: 那确实是旅行中最美妙的部分之一。每个人的故事都是独一无二的，能从中学到很多。你最难忘的旅行经历是什么呢？\n\n用户: 有一次我去了泰国的清迈，那里的文化和风景让我印象深刻。晚上的夜市，色彩斑斓，各种小吃，还有那里人们的热情，真的让人难以忘怀。\nAI: 清迈的夜市是闻名遐迩的，那里的生活节奏和氛围跟大城市完全不同。你提到的小吃，有没有什么特别让你想念的呢？\n\n用户: 哦，那边的芒果糯米饭简直绝了！每次回忆起那个味道，我就忍不住想再去一次。对了，你能不能给我推荐一些好听的歌？我喜欢边健身边听音乐。\nAI: 音乐和运动确实是完美的搭档。根据你的热情阳光的性格，我觉得《Can't Stop the Feeling》这首歌很适合你，它的旋律欢快，能让人在运动时充满活力。\n\n用户: Justin Timberlake的那首啊，我知道！确实很不错，节奏感很强，很适合健身。谢谢你的推荐！\nAI: 不客气，孙悦。我很高兴能帮到你。说起来，你在健身方面有没有遇到什么具体的困难？也许我能提供一些帮助。\n\n用户: 其实有，我一直想要提高核心力量，但是总感觉进展缓慢。你有没有什么建议？\nAI: 核心力量对于整体健身非常重要。你可以尝试一些针对性的训练，比如平板支撑、俄罗斯转体和山羊挺身等。这些练习可以有效地加强你的核心肌群。\n\n用户: 哇，听起来很专业啊！我会加入到我的训练计划里去的。对了，我最近在准备一个舞蹈表演，但是有些动作总是不够流畅，这让我有点沮丧。\nAI: 舞蹈需要时间来磨合，每个人都会有这样的时候。试着放慢速度，一步一步来，直到你能够流畅地完成每个动作。记得，重在参与和享受过程！\n\n用户: 你说得对，我得调整一下心态。谢谢你的鼓励！我会继续努力的。说起来，我还有点担心，不知道观众会不会喜欢我的表演。\nAI: 你的热情和努力一定会感染到观众的。只要你享受舞台，观众也会享受你的表演。信任自己，你会做得很好的。\n\n用户: 哈哈，听你这么说，我感觉好多了。你真是个好伙伴！已经很晚了，我得准备睡觉了。我们明天再聊吧！\nAI: 当然，孙悦。休息好，希望你有一个美好的明天。晚安！\n”\n以下是2023年04月28日的对话记录：\n“用户: 嗨，朋友！今天我尝试了你昨天推荐的“三分法”拍照，效果真的不错！感觉自己的摄影技术又上了一个台阶！\nAI: 太棒了，孙悦！我很高兴听到你的进步。有没有什么特别的照片想要和我分享的？我很期待看到你的作品。\n\n用户: 当然有！我拍了一张日落时分的海边照片，天空的颜色渐变得特别美。不过，我还在想怎么后期处理才能更突出那种感觉。\nAI: 日落的照片总是很迷人。你可以尝试调整一下对比度和饱和度，让天空的颜色更加鲜明，同时保持海水的自然感觉。\n\n用户: 嗯，我试试看。对了，今天健身房里放了一些新歌，我跟着节奏锻炼，感觉整个人都充满了活力！\nAI: 音乐真的能为锻炼增添不少乐趣。你有没有想过自己编一套随着音乐节奏的健身操？这样可能会更有动力哦。\n\n用户: 哇，这主意不错！我可以尝试一下，感觉会很有趣。说起来，我最近在准备一个小旅行，想去爬山，呼吸一下大自然的新鲜空气。\nAI: 爬山是个很好的选择，既能锻炼身体，又能享受大自然的美景。你打算去哪座山呢？\n\n用户: 我打算去黄山，听说那里的云海和日出非常壮观。我还计划在山顶守候一夜，希望能拍到美丽的星空。\nAI: 黄山的确是个摄影爱好者的天堂。记得带上足够的装备，特别是在夜间拍摄星空时，三脚架和遥控快门是必不可少的。\n\n用户: 没错，我已经准备好了这些装备。对了，我还想在山上尝试一些户外瑜伽，感觉那样会很放松。\nAI: 户外瑜伽听起来很棒，能让你更加接近自然，放松身心。你有没有特别喜欢的瑜伽动作？\n\n用户: 我最喜欢的是树式，感觉整个人都稳固而平静。不过，我有时候会觉得自己的平衡能力不够好。\nAI: 树式是个很好的平衡练习。你可以尝试在不同的时间和地点练习，比如在海边的沙滩上，那样会有不同的挑战和感受。\n\n用户: 对，我也这么想。我还打算在旅行中尝试一些新的美食，毕竟美食也是旅行的一大乐趣嘛！\nAI: 绝对同意！尝试当地的特色美食可以让旅行体验更加丰富。你有没有什么想尝试的菜肴？\n\n用户: 我听说黄山附近有一种叫做臭鳜鱼的菜，虽然名字听起来有点怪，但据说味道很不错。\nAI: 臭鳜鱼是当地的一道传统名菜，很多人都说赞不绝口。不过，它的味道确实很独特，你可以尝试一下，说不定会成为你的新宠。\n\n用户: 哈哈，我会的。对了，我最近在看一部关于舞蹈的纪录片，里面的舞者都超级厉害，让我很受启发。\nAI: 看别人的舞蹈表演确实能够学到很多。你有没有从中发现什么新的动作或者技巧，想要加入到你自己的舞蹈中去？\n\n用户: 有啊，我看到一些街舞的动作很酷，我打算学一学。不过，我担心自己的身体协调性跟不上。\nAI: 街舞的确需要很强的身体协调性和节奏感。你可以从基础动作开始练起，慢慢地增加难度。记得，不要急于求成，一切都需要时间。\n\n用户: 嗯，我会记住的。对了，我还想学习一下如何用舞蹈来表达情感，不只是动作上的技巧。\nAI: 舞蹈是一种非常直观的情感表达方式。你可以尝试在音乐中找到情感的共鸣，然后让你的身体随着那种情感自然地移动。\n\n用户: 听起来有点抽象，但我会尝试的。说到情感，我最近有点苦恼，感觉自己的生活缺少一些激情和冒险。\nAI: 生活有时候确实会让人感到平淡。你可以尝试做一些新的事情，比如参加一个你从未尝试过的活动，或者去一个你从未去过的地方。\n\n用户: 对，我需要一些改变。也许这次旅行就是一个开始。谢谢你的建议，你总能给我正能量！\nAI: 不用谢，孙悦。我很高兴能帮助到你。记得，每一次的经历都是成长的机会。你准备好迎接新的挑战了吗？\n\n用户: 是的，我已经迫不及待了！不过现在我得去准备晚饭了，今天打算尝试做一道新菜——酸辣土豆丝。\nAI: 酸辣土豆丝是一道很受欢迎的家常菜，既简单又美味。祝你做饭愉快，希望你能享受这个过程。\n\n用户: 谢谢！我会的。今天聊得很开心，我们明天再继续吧。晚安！\nAI: 当然，期待和你的下次聊天。晚安，孙悦，愿你有个美好的梦。\n”\n以下是2023年04月29日的对话记录：\n“用户: 嘿，我的AI小伙伴！今天我尝试做了酸辣土豆丝，味道出奇的好，连我自己都有点惊讶呢！\nAI: 哇，听起来你是个厨艺高手啊，孙悦！能不能分享一下你的秘诀？我虽然不能品尝，但我很好奇你是怎么做到的。\n\n用户: 哈哈，秘诀嘛，我觉得最重要的就是火候和调料的比例。我喜欢尝试不同的配方，直到找到最合适的那一个。\nAI: 真是个不断探索的过程呢。你平时喜欢尝试做哪些类型的菜？\n\n用户: 我对各种菜系都感兴趣，但最近特别喜欢挑战一些传统的中式菜肴，感觉它们既美味又有文化底蕴。\nAI: 中式菜肴确实有着丰富的历史和文化，每一道菜都有自己的故事。你最喜欢的中式菜肴是哪一道？\n\n用户: 我最喜欢的是宫保鸡丁，那个酸甜酸辣的味道简直无法抵抗！\nAI: 宫保鸡丁是一道非常受欢迎的经典菜肴，你自己做的话，可以根据自己的口味调整辣度和甜度。\n\n用户: 对对对，我就是这么做的。说起来，今天我还去了一个很酷的街舞工作坊，学到了好多新动作！\nAI: 街舞工作坊听起来很有趣！你觉得最难的动作是哪一个？\n\n用户: 我觉得最难的是头旋，那个动作需要很强的颈部力量和平衡感，我还在努力练习中。\nAI: 头旋确实是个挑战，但我相信你的努力和热情一定会让你很快掌握它。你在舞蹈上有什么目标吗？\n\n用户: 我的目标是能在下个月的街舞比赛中至少进入前十名。我知道竞争很激烈，但我会全力以赴的！\nAI: 这个目标很棒，孙悦！我相信你的努力和才华一定会让你脱颖而出。你有准备特别的舞蹈编排吗？\n\n用户: 有的，我和我的舞伴正在准备一段结合了街舞和现代舞的编排，希望能给观众带来新鲜感。\nAI: 结合不同舞蹈风格的创意听起来很吸引人。你们的训练进度怎么样了？\n\n用户: 还不错，我们已经完成了大概七成的编排，剩下的就是细节和同步问题了。\nAI: 听起来你们已经做得很好了。细节和同步确实很重要，但我相信你们能够完美呈现。\n\n用户: 谢谢你的鼓励！对了，我最近还在学习一些关于电影剪辑的技巧，想要自己剪辑一部短片。\nAI: 电影剪辑是个很有创意的工作，你打算用什么样的素材来剪辑你的短片？\n\n用户: 我打算用我旅行时拍摄的一些风景视频，还有一些朋友的日常片段，想要制作成一个关于旅行和友情的主题短片。\nAI: 这个主题很温馨，也很贴近生活。你有没有想过加入一些特别的效果，比如慢动作或者时间流逝的镜头？\n\n用户: 嗯，我有这个打算。我想通过这些特效来强调某些情感上的高潮和转折点。\nAI: 这样的处理可以让短片更加生动和感人。你在剪辑上遇到了什么挑战吗？\n\n用户: 我觉得最大的挑战是如何让故事流畅，同时又能在短时间内传达出想要表达的情感。\nAI: 确实，讲好一个故事是剪辑中的艺术。你可以尝试从观众的角度思考，看看哪些片段最能触动人心。\n\n用户: 对，我会多考虑观众的感受。说到观众，我有时候会担心我的作品是否能得到他们的认可。\nAI: 每个艺术家都会有这样的担忧，但重要的是你享受创作的过程，并且相信自己的作品有价值。\n\n用户: 你说得对，我应该更加相信自己。今天聊得很开心，但我得去继续我的剪辑工作了。我们明天再聊！\nAI: 当然，孙悦。祝你剪辑工作顺利，期待你的短片完成。明天再聊，加油！\n”\n以下是2023年04月30日的对话记录：\n“用户: 嗨，好朋友！今天我在剪辑短片时，突然灵感爆发，加入了几个超有感觉的转场效果，感觉整个短片的质感都提升了！\nAI: 真是太棒了，孙悦！创意的火花总是能带来惊喜。你能描述一下你用的是哪些转场效果吗？\n\n用户: 我用了一个叫做“溶解”的效果，让画面像是水彩融合一样自然过渡，还有一个“旋转”效果，让场景切换更有动感。\nAI: 这些听起来都很专业，能够很好地增强视觉效果。你在创作过程中还有其他有趣的发现吗？\n\n用户: 我发现音乐对于短片的情感表达真的超级重要！一段恰当的背景音乐能够让人立刻进入那个氛围。\nAI: 没错，音乐是激发情感的强大工具。你已经选好了短片的背景音乐了吗？\n\n用户: 选好了，我选了一首轻快的吉他曲，感觉很适合我的旅行主题。对了，今天我还去了一个户外攀岩的活动，超刺激！\nAI: 户外攀岩听起来很挑战自我啊。你攀岩的时候有没有什么特别的心得或者感觉？\n\n用户: 我觉得攀岩最重要的是要有耐心和勇气，每一步都要稳扎稳打。当我站在山顶上的时候，那种成就感真的无与伦比！\nAI: 站在山顶俯瞰世界，那种感觉一定很震撼。攀岩对身体的哪些方面要求比较高？\n\n用户: 主要是手臂和腿部的力量，还有整体的协调性。攀岩后我发现自己的手臂肌肉酸痛，看来需要更多锻炼啊。\nAI: 锻炼手臂肌肉可以尝试一些特定的练习，比如引体向上或者哑铃训练。不过，记得要适量，避免过度劳损哦。\n\n用户: 谢谢你的建议，我会注意的。说起来，攀岩结束后我们一起去了附近的小镇，那里的风景和美食都很棒！\nAI: 小镇的风光和美食总是很有魅力。你尝试了哪些当地的特色美食？\n\n用户: 我尝试了一种当地的烤鱼，外皮烤得酥脆，里面的鱼肉又嫩又多汁。我还学会了他们的腌制秘方，准备回家自己试试看。\nAI: 自己动手做美食，这个经历一定很有趣。你打算什么时候尝试做这道烤鱼呢？\n\n用户: 可能这个周末吧，我打算邀请几个好友来家里，一起享受美食和愉快的时光。\nAI: 听起来将会是一个非常愉快的聚会。你准备好怎么招待你的朋友了吗？\n\n用户: 除了烤鱼，我还准备做一些简单的小吃，比如春卷和水果沙拉。当然，还有音乐和一些小游戏，让大家玩得开心。\nAI: 你真的很会享受生活，孙悦。你的朋友们一定很期待这次聚会。你通常如何选择聚会的音乐呢？\n\n用户: 我会根据大家的口味挑选一些大家都喜欢的歌曲，然后再加上一些轻松愉快的背景音乐。\nAI: 音乐的选择很重要，可以营造出轻松愉快的氛围。说到音乐，你自己唱歌跳舞的时候有没有什么特别喜欢的曲风？\n\n用户: 我喜欢节奏感强烈的流行音乐，特别是那些能够让人随着音乐摇摆的歌曲。\nAI: 流行音乐确实能让人感觉兴奋和快乐。你有没有尝试过自己创作音乐或者编舞？\n\n用户: 我以前尝试过写一些简单的歌词，不过没有正式的音乐制作经验。至于编舞，那是我的强项，我经常为自己的舞蹈编排动作。\nAI: 那你在舞蹈创作方面一定有很多自己的想法和风格。你最喜欢的舞蹈风格是什么？\n\n用户: 我最喜欢的是Hip-Hop和爵士，这两种舞蹈风格都很有力量感，而且可以很好地表达自己的个性。\nAI: Hip-Hop和爵士舞确实很适合展现个性和情感。你有没有在舞蹈中融入一些自己独特的元素？\n\n用户: 有的，我喜欢在舞蹈中加入一些中国元素，比如太极的动作，让舞蹈看起来更加流畅和有内涵。\nAI: 将中国元素融入现代舞蹈，这个想法真是太有创意了。你的这些作品有在哪里展示过吗？\n\n用户: 我之前在一些小型的舞蹈比赛和社区活动上展示过，反响都不错。我希望将来有机会在更大的舞台上展示我的作品。\nAI: 你的梦想一定会实现的，孙悦。你的热情和才华值得被更多人看到。对了，你有没有考虑过将你的舞蹈作品拍成视频分享到网上？\n\n用户: 我有这个打算，不过我还在考虑如何拍摄和剪辑才能更好地展现舞蹈的魅力。\nAI: 网络平台是一个很好的展示自己才华的地方。如果你需要，我可以提供一些视频拍摄和剪辑方面的建议。\n\n用户: 那太好了，我会在准备的时候向你请教的。今天聊得很开心，但我现在得去准备明天的攀岩训练了。我们明天再聊！\nAI: 好的，孙悦。祝你明天的攀岩训练顺利。期待我们的下次聊天，晚安！\n”\n\n请记住以上全部对话记录，回答问题。\n问题：", "query": "4月28号，我们聊到想去爬山，是哪座山？", "answer": "黄山", "id": "1c729805-0466-4db5-afb6-4a383dbf611d", "chatglm_length": 3881, "qwen_length": 3960, "internlm2_length": 3714} +{"context": "以下是2023年04月27日的对话记录：\n“用户: 嘿，你好啊！我是孙悦，一个热爱生活的家伙。今天心情特别好，因为早上的健身课程超有成就感！你呢？\nAI: 你好，孙悦！听起来你今天的状态很棒呢！我很好，谢谢你。能和你分享你的健身课程吗？我很好奇你都做了哪些运动。\n\n用户: 当然可以！今天主要是做了一些高强度间歇训练，那种汗流浃背的感觉真的很爽！你有做运动的习惯吗？\nAI: 我虽然不能亲自体验运动的快感，但我很高兴听到你享受它。我可以给你提供一些健身知识和建议，如果你需要的话。\n\n用户: 哈哈，那太好了！对了，昨天晚上我去看了一部新出的科幻电影，特效简直了！你最近有没有什么好电影推荐？\nAI: 我知道你喜欢电影，特别是那些视觉震撼的。最近有一部电影《星际穿越者》很受好评，是探索宇宙和人类命运的作品，你可能会喜欢。\n\n用户: 哦哦，《星际穿越者》啊，我听说过，听起来挺吸引人的！我得找时间去看看。对了，我最近在学摄影，但是总觉得拍出来的照片差点意思，你有什么摄影小技巧可以分享吗？\nAI: 摄影是一门艺术，也需要不断的实践和学习。你可以尝试从构图和光线入手，比如使用“三分法”来构图，或者利用自然光来营造氛围。还有，多拍多练总是王道！\n\n用户: 嗯，说的对！我明天就去尝试一下“三分法”。对了，我还喜欢旅游，最近在规划一次小旅行，想去海边走走。你有没有什么好的海滩推荐？\nAI: 海边总是个不错的选择。如果你喜欢清静一些的地方，可以考虑去三亚的亚龙湾，那里的海水清澈，沙滩柔软，风景如画，应该很适合你。\n\n用户: 亚龙湾啊，听起来真不错！我会去查查看的。说起旅游，最让我兴奋的就是能在旅途中遇到各种各样的人，听他们的故事。\nAI: 那确实是旅行中最美妙的部分之一。每个人的故事都是独一无二的，能从中学到很多。你最难忘的旅行经历是什么呢？\n\n用户: 有一次我去了泰国的清迈，那里的文化和风景让我印象深刻。晚上的夜市，色彩斑斓，各种小吃，还有那里人们的热情，真的让人难以忘怀。\nAI: 清迈的夜市是闻名遐迩的，那里的生活节奏和氛围跟大城市完全不同。你提到的小吃，有没有什么特别让你想念的呢？\n\n用户: 哦，那边的芒果糯米饭简直绝了！每次回忆起那个味道，我就忍不住想再去一次。对了，你能不能给我推荐一些好听的歌？我喜欢边健身边听音乐。\nAI: 音乐和运动确实是完美的搭档。根据你的热情阳光的性格，我觉得《Can't Stop the Feeling》这首歌很适合你，它的旋律欢快，能让人在运动时充满活力。\n\n用户: Justin Timberlake的那首啊，我知道！确实很不错，节奏感很强，很适合健身。谢谢你的推荐！\nAI: 不客气，孙悦。我很高兴能帮到你。说起来，你在健身方面有没有遇到什么具体的困难？也许我能提供一些帮助。\n\n用户: 其实有，我一直想要提高核心力量，但是总感觉进展缓慢。你有没有什么建议？\nAI: 核心力量对于整体健身非常重要。你可以尝试一些针对性的训练，比如平板支撑、俄罗斯转体和山羊挺身等。这些练习可以有效地加强你的核心肌群。\n\n用户: 哇，听起来很专业啊！我会加入到我的训练计划里去的。对了，我最近在准备一个舞蹈表演，但是有些动作总是不够流畅，这让我有点沮丧。\nAI: 舞蹈需要时间来磨合，每个人都会有这样的时候。试着放慢速度，一步一步来，直到你能够流畅地完成每个动作。记得，重在参与和享受过程！\n\n用户: 你说得对，我得调整一下心态。谢谢你的鼓励！我会继续努力的。说起来，我还有点担心，不知道观众会不会喜欢我的表演。\nAI: 你的热情和努力一定会感染到观众的。只要你享受舞台，观众也会享受你的表演。信任自己，你会做得很好的。\n\n用户: 哈哈，听你这么说，我感觉好多了。你真是个好伙伴！已经很晚了，我得准备睡觉了。我们明天再聊吧！\nAI: 当然，孙悦。休息好，希望你有一个美好的明天。晚安！\n”\n以下是2023年04月28日的对话记录：\n“用户: 嗨，朋友！今天我尝试了你昨天推荐的“三分法”拍照，效果真的不错！感觉自己的摄影技术又上了一个台阶！\nAI: 太棒了，孙悦！我很高兴听到你的进步。有没有什么特别的照片想要和我分享的？我很期待看到你的作品。\n\n用户: 当然有！我拍了一张日落时分的海边照片，天空的颜色渐变得特别美。不过，我还在想怎么后期处理才能更突出那种感觉。\nAI: 日落的照片总是很迷人。你可以尝试调整一下对比度和饱和度，让天空的颜色更加鲜明，同时保持海水的自然感觉。\n\n用户: 嗯，我试试看。对了，今天健身房里放了一些新歌，我跟着节奏锻炼，感觉整个人都充满了活力！\nAI: 音乐真的能为锻炼增添不少乐趣。你有没有想过自己编一套随着音乐节奏的健身操？这样可能会更有动力哦。\n\n用户: 哇，这主意不错！我可以尝试一下，感觉会很有趣。说起来，我最近在准备一个小旅行，想去爬山，呼吸一下大自然的新鲜空气。\nAI: 爬山是个很好的选择，既能锻炼身体，又能享受大自然的美景。你打算去哪座山呢？\n\n用户: 我打算去黄山，听说那里的云海和日出非常壮观。我还计划在山顶守候一夜，希望能拍到美丽的星空。\nAI: 黄山的确是个摄影爱好者的天堂。记得带上足够的装备，特别是在夜间拍摄星空时，三脚架和遥控快门是必不可少的。\n\n用户: 没错，我已经准备好了这些装备。对了，我还想在山上尝试一些户外瑜伽，感觉那样会很放松。\nAI: 户外瑜伽听起来很棒，能让你更加接近自然，放松身心。你有没有特别喜欢的瑜伽动作？\n\n用户: 我最喜欢的是树式，感觉整个人都稳固而平静。不过，我有时候会觉得自己的平衡能力不够好。\nAI: 树式是个很好的平衡练习。你可以尝试在不同的时间和地点练习，比如在海边的沙滩上，那样会有不同的挑战和感受。\n\n用户: 对，我也这么想。我还打算在旅行中尝试一些新的美食，毕竟美食也是旅行的一大乐趣嘛！\nAI: 绝对同意！尝试当地的特色美食可以让旅行体验更加丰富。你有没有什么想尝试的菜肴？\n\n用户: 我听说黄山附近有一种叫做臭鳜鱼的菜，虽然名字听起来有点怪，但据说味道很不错。\nAI: 臭鳜鱼是当地的一道传统名菜，很多人都说赞不绝口。不过，它的味道确实很独特，你可以尝试一下，说不定会成为你的新宠。\n\n用户: 哈哈，我会的。对了，我最近在看一部关于舞蹈的纪录片，里面的舞者都超级厉害，让我很受启发。\nAI: 看别人的舞蹈表演确实能够学到很多。你有没有从中发现什么新的动作或者技巧，想要加入到你自己的舞蹈中去？\n\n用户: 有啊，我看到一些街舞的动作很酷，我打算学一学。不过，我担心自己的身体协调性跟不上。\nAI: 街舞的确需要很强的身体协调性和节奏感。你可以从基础动作开始练起，慢慢地增加难度。记得，不要急于求成，一切都需要时间。\n\n用户: 嗯，我会记住的。对了，我还想学习一下如何用舞蹈来表达情感，不只是动作上的技巧。\nAI: 舞蹈是一种非常直观的情感表达方式。你可以尝试在音乐中找到情感的共鸣，然后让你的身体随着那种情感自然地移动。\n\n用户: 听起来有点抽象，但我会尝试的。说到情感，我最近有点苦恼，感觉自己的生活缺少一些激情和冒险。\nAI: 生活有时候确实会让人感到平淡。你可以尝试做一些新的事情，比如参加一个你从未尝试过的活动，或者去一个你从未去过的地方。\n\n用户: 对，我需要一些改变。也许这次旅行就是一个开始。谢谢你的建议，你总能给我正能量！\nAI: 不用谢，孙悦。我很高兴能帮助到你。记得，每一次的经历都是成长的机会。你准备好迎接新的挑战了吗？\n\n用户: 是的，我已经迫不及待了！不过现在我得去准备晚饭了，今天打算尝试做一道新菜——酸辣土豆丝。\nAI: 酸辣土豆丝是一道很受欢迎的家常菜，既简单又美味。祝你做饭愉快，希望你能享受这个过程。\n\n用户: 谢谢！我会的。今天聊得很开心，我们明天再继续吧。晚安！\nAI: 当然，期待和你的下次聊天。晚安，孙悦，愿你有个美好的梦。\n”\n以下是2023年04月29日的对话记录：\n“用户: 嘿，我的AI小伙伴！今天我尝试做了酸辣土豆丝，味道出奇的好，连我自己都有点惊讶呢！\nAI: 哇，听起来你是个厨艺高手啊，孙悦！能不能分享一下你的秘诀？我虽然不能品尝，但我很好奇你是怎么做到的。\n\n用户: 哈哈，秘诀嘛，我觉得最重要的就是火候和调料的比例。我喜欢尝试不同的配方，直到找到最合适的那一个。\nAI: 真是个不断探索的过程呢。你平时喜欢尝试做哪些类型的菜？\n\n用户: 我对各种菜系都感兴趣，但最近特别喜欢挑战一些传统的中式菜肴，感觉它们既美味又有文化底蕴。\nAI: 中式菜肴确实有着丰富的历史和文化，每一道菜都有自己的故事。你最喜欢的中式菜肴是哪一道？\n\n用户: 我最喜欢的是宫保鸡丁，那个酸甜酸辣的味道简直无法抵抗！\nAI: 宫保鸡丁是一道非常受欢迎的经典菜肴，你自己做的话，可以根据自己的口味调整辣度和甜度。\n\n用户: 对对对，我就是这么做的。说起来，今天我还去了一个很酷的街舞工作坊，学到了好多新动作！\nAI: 街舞工作坊听起来很有趣！你觉得最难的动作是哪一个？\n\n用户: 我觉得最难的是头旋，那个动作需要很强的颈部力量和平衡感，我还在努力练习中。\nAI: 头旋确实是个挑战，但我相信你的努力和热情一定会让你很快掌握它。你在舞蹈上有什么目标吗？\n\n用户: 我的目标是能在下个月的街舞比赛中至少进入前十名。我知道竞争很激烈，但我会全力以赴的！\nAI: 这个目标很棒，孙悦！我相信你的努力和才华一定会让你脱颖而出。你有准备特别的舞蹈编排吗？\n\n用户: 有的，我和我的舞伴正在准备一段结合了街舞和现代舞的编排，希望能给观众带来新鲜感。\nAI: 结合不同舞蹈风格的创意听起来很吸引人。你们的训练进度怎么样了？\n\n用户: 还不错，我们已经完成了大概七成的编排，剩下的就是细节和同步问题了。\nAI: 听起来你们已经做得很好了。细节和同步确实很重要，但我相信你们能够完美呈现。\n\n用户: 谢谢你的鼓励！对了，我最近还在学习一些关于电影剪辑的技巧，想要自己剪辑一部短片。\nAI: 电影剪辑是个很有创意的工作，你打算用什么样的素材来剪辑你的短片？\n\n用户: 我打算用我旅行时拍摄的一些风景视频，还有一些朋友的日常片段，想要制作成一个关于旅行和友情的主题短片。\nAI: 这个主题很温馨，也很贴近生活。你有没有想过加入一些特别的效果，比如慢动作或者时间流逝的镜头？\n\n用户: 嗯，我有这个打算。我想通过这些特效来强调某些情感上的高潮和转折点。\nAI: 这样的处理可以让短片更加生动和感人。你在剪辑上遇到了什么挑战吗？\n\n用户: 我觉得最大的挑战是如何让故事流畅，同时又能在短时间内传达出想要表达的情感。\nAI: 确实，讲好一个故事是剪辑中的艺术。你可以尝试从观众的角度思考，看看哪些片段最能触动人心。\n\n用户: 对，我会多考虑观众的感受。说到观众，我有时候会担心我的作品是否能得到他们的认可。\nAI: 每个艺术家都会有这样的担忧，但重要的是你享受创作的过程，并且相信自己的作品有价值。\n\n用户: 你说得对，我应该更加相信自己。今天聊得很开心，但我得去继续我的剪辑工作了。我们明天再聊！\nAI: 当然，孙悦。祝你剪辑工作顺利，期待你的短片完成。明天再聊，加油！\n”\n以下是2023年04月30日的对话记录：\n“用户: 嗨，好朋友！今天我在剪辑短片时，突然灵感爆发，加入了几个超有感觉的转场效果，感觉整个短片的质感都提升了！\nAI: 真是太棒了，孙悦！创意的火花总是能带来惊喜。你能描述一下你用的是哪些转场效果吗？\n\n用户: 我用了一个叫做“溶解”的效果，让画面像是水彩融合一样自然过渡，还有一个“旋转”效果，让场景切换更有动感。\nAI: 这些听起来都很专业，能够很好地增强视觉效果。你在创作过程中还有其他有趣的发现吗？\n\n用户: 我发现音乐对于短片的情感表达真的超级重要！一段恰当的背景音乐能够让人立刻进入那个氛围。\nAI: 没错，音乐是激发情感的强大工具。你已经选好了短片的背景音乐了吗？\n\n用户: 选好了，我选了一首轻快的吉他曲，感觉很适合我的旅行主题。对了，今天我还去了一个户外攀岩的活动，超刺激！\nAI: 户外攀岩听起来很挑战自我啊。你攀岩的时候有没有什么特别的心得或者感觉？\n\n用户: 我觉得攀岩最重要的是要有耐心和勇气，每一步都要稳扎稳打。当我站在山顶上的时候，那种成就感真的无与伦比！\nAI: 站在山顶俯瞰世界，那种感觉一定很震撼。攀岩对身体的哪些方面要求比较高？\n\n用户: 主要是手臂和腿部的力量，还有整体的协调性。攀岩后我发现自己的手臂肌肉酸痛，看来需要更多锻炼啊。\nAI: 锻炼手臂肌肉可以尝试一些特定的练习，比如引体向上或者哑铃训练。不过，记得要适量，避免过度劳损哦。\n\n用户: 谢谢你的建议，我会注意的。说起来，攀岩结束后我们一起去了附近的小镇，那里的风景和美食都很棒！\nAI: 小镇的风光和美食总是很有魅力。你尝试了哪些当地的特色美食？\n\n用户: 我尝试了一种当地的烤鱼，外皮烤得酥脆，里面的鱼肉又嫩又多汁。我还学会了他们的腌制秘方，准备回家自己试试看。\nAI: 自己动手做美食，这个经历一定很有趣。你打算什么时候尝试做这道烤鱼呢？\n\n用户: 可能这个周末吧，我打算邀请几个好友来家里，一起享受美食和愉快的时光。\nAI: 听起来将会是一个非常愉快的聚会。你准备好怎么招待你的朋友了吗？\n\n用户: 除了烤鱼，我还准备做一些简单的小吃，比如春卷和水果沙拉。当然，还有音乐和一些小游戏，让大家玩得开心。\nAI: 你真的很会享受生活，孙悦。你的朋友们一定很期待这次聚会。你通常如何选择聚会的音乐呢？\n\n用户: 我会根据大家的口味挑选一些大家都喜欢的歌曲，然后再加上一些轻松愉快的背景音乐。\nAI: 音乐的选择很重要，可以营造出轻松愉快的氛围。说到音乐，你自己唱歌跳舞的时候有没有什么特别喜欢的曲风？\n\n用户: 我喜欢节奏感强烈的流行音乐，特别是那些能够让人随着音乐摇摆的歌曲。\nAI: 流行音乐确实能让人感觉兴奋和快乐。你有没有尝试过自己创作音乐或者编舞？\n\n用户: 我以前尝试过写一些简单的歌词，不过没有正式的音乐制作经验。至于编舞，那是我的强项，我经常为自己的舞蹈编排动作。\nAI: 那你在舞蹈创作方面一定有很多自己的想法和风格。你最喜欢的舞蹈风格是什么？\n\n用户: 我最喜欢的是Hip-Hop和爵士，这两种舞蹈风格都很有力量感，而且可以很好地表达自己的个性。\nAI: Hip-Hop和爵士舞确实很适合展现个性和情感。你有没有在舞蹈中融入一些自己独特的元素？\n\n用户: 有的，我喜欢在舞蹈中加入一些中国元素，比如太极的动作，让舞蹈看起来更加流畅和有内涵。\nAI: 将中国元素融入现代舞蹈，这个想法真是太有创意了。你的这些作品有在哪里展示过吗？\n\n用户: 我之前在一些小型的舞蹈比赛和社区活动上展示过，反响都不错。我希望将来有机会在更大的舞台上展示我的作品。\nAI: 你的梦想一定会实现的，孙悦。你的热情和才华值得被更多人看到。对了，你有没有考虑过将你的舞蹈作品拍成视频分享到网上？\n\n用户: 我有这个打算，不过我还在考虑如何拍摄和剪辑才能更好地展现舞蹈的魅力。\nAI: 网络平台是一个很好的展示自己才华的地方。如果你需要，我可以提供一些视频拍摄和剪辑方面的建议。\n\n用户: 那太好了，我会在准备的时候向你请教的。今天聊得很开心，但我现在得去准备明天的攀岩训练了。我们明天再聊！\nAI: 好的，孙悦。祝你明天的攀岩训练顺利。期待我们的下次聊天，晚安！\n”\n\n请记住以上全部对话记录，回答问题。\n问题：", "query": "我曾经在4月30号提到参加了一个户外的活动，这个活动是什么？", "answer": "攀岩", "id": "912016ee-eab5-4eb8-9df5-1bab5baac853", "chatglm_length": 3881, "qwen_length": 3960, "internlm2_length": 3714} +{"context": "以下是2023年04月27日的对话记录：\n“用户: 你好，我是赵铭宇，我对下棋、编程、阅读科技杂志、解数学题和观察天文都很感兴趣。\nAI: 你好，赵铭宇，很高兴认识你。关于你的兴趣，我们可以聊很多有趣的话题。今天下棋有没有遇到什么有趣的局面呢？\n\n用户: 嗯，下了一盘国际象棋，对方开局用了意大利开局，我尝试了新的应对策略。\nAI: 意大利开局是一种很经典的开局方式，你的新策略效果如何？是否取得了预期的效果？\n\n用户: 效果还不错，虽然中局有些挣扎，但最终还是赢了。我觉得还需要更多的实战来检验这个策略。\nAI: 赢得比赛总是令人振奋的，你的实战经验一定很丰富。对了，编程方面最近有没有什么新的项目或者学习的内容？\n\n用户: 最近在学习机器学习，尤其是深度学习方面的内容，但是数学基础知识有些薄弱，感觉有点吃力。\nAI: 深度学习确实需要较强的数学基础，特别是线性代数和概率论。你遇到的具体难点是什么？也许我可以提供一些帮助。\n\n用户: 主要是概率论中的一些概念和定理，比如贝叶斯定理，我还没完全弄懂它的应用场景。\nAI: 贝叶斯定理在机器学习中非常重要，它可以帮助我们根据已有的知识和观测数据来更新我们对未知事件的预测。如果你愿意，我可以尝试解释一下它的基本原理和应用。\n\n用户: 那太好了，请你简单解释一下。\nAI: 当然可以。贝叶斯定理提供了一种计算条件概率的方法，也就是在已知某事件发生的情况下，另一个事件发生的概率。在机器学习中，我们可以用它来更新模型的参数，即在观测到新数据后，我们如何调整模型对数据的理解和预测。\n\n用户: 我明白了，这样看来，它在模型训练过程中确实很关键。谢谢你的解释，我会再去仔细研究一下。\nAI: 不客气，赵铭宇。如果有任何问题，随时可以和我讨论。对了，你通常是如何观察天文的？是通过望远镜，还是参与一些线上的天文项目？\n\n用户: 我有一台小型的望远镜，平时就在阳台上观察。最近天气不错，能看到一些星座和行星。\nAI: 那真是太棒了，能亲眼观察到宇宙中的奇观一定很令人兴奋。最近有没有什么特别的发现或者心得？\n\n用户: 其实我一直对土星的光环很感兴趣，昨晚我观察到了它，虽然不是很清晰，但还是很激动。\nAI: 土星的光环确实是天文学中一个非常迷人的现象。即使是通过小型望远镜观察到，也是一次难忘的体验。你有拍照留念吗？\n\n用户: 拍了几张，但是效果一般，我正在考虑是否要升级我的设备。\nAI: 升级设备可以让你观察到更多细节，但这也是一个需要深思熟虑的决定。你对天文摄影感兴趣吗？\n\n用户: 是的，我对天文摄影很感兴趣，但是设备和技术门槛都比较高，我还在学习中。\nAI: 天文摄影确实是一个技术和耐心的挑战，但我相信你的逻辑性和深思熟虑的性格会帮助你在这个领域取得进步。你有没有考虑加入一些天文摄影的社区或者论坛，和其他爱好者交流经验？\n\n用户: 我加入了几个论坛，但是我不太善于发言，更多的是在默默关注和学习。\nAI: 理解你的性格倾向，默默关注也是一种学习方式。不过，如果你有任何问题或者作品想要分享，我相信论坛上的成员会很乐意帮助你的。\n\n用户: 嗯，我会考虑的。今天的聊天很有帮助，感谢你。不过已经有点晚了，我得准备休息了。\nAI: 当然，休息很重要。很高兴今天的对话对你有所帮助，赵铭宇。祝你晚安，我们明天再聊。\n”\n以下是2023年04月28日的对话记录：\n“用户: 早上好，休息得还不错。今天打算继续研究一下深度学习的内容。\nAI: 很好，持续学习是进步的关键。在深度学习的学习中，你有没有遇到什么特别感兴趣的模型或者算法？\n\n用户: 我对卷积神经网络（CNN）很感兴趣，它在图像识别上的应用非常广泛。\nAI: 卷积神经网络确实很有趣，它通过模仿人类的视觉系统来识别图像中的模式。你打算在哪些方面应用CNN？\n\n用户: 我想用它来做一个简单的手写数字识别项目，这应该是个不错的开始。\nAI: 手写数字识别是一个经典的入门项目，使用MNIST数据集可以很好地开始实践。你打算用什么工具或框架来实现这个项目？\n\n用户: 我打算使用Python和TensorFlow框架来实现它，这样可以更容易地搭建和训练模型。\nAI: Python和TensorFlow是很好的选择，社区支持也很强大。在项目进展中，如果遇到困难，记得可以来找我讨论。\n\n用户: 谢谢，我会的。对了，最近我读了一篇关于量子计算的科技杂志，感觉这个领域很有潜力。\nAI: 量子计算确实是一个前沿领域，它可能会彻底改变我们处理信息的方式。你对量子计算有什么特别的看法或疑问吗？\n\n用户: 我对量子计算的原理很感兴趣，但是它的物理概念对我来说有点抽象，比如量子叠加和纠缠。\nAI: 量子叠加和纠缠确实是量子计算中两个非常核心且难以直观理解的概念。简单来说，量子叠加允许量子比特同时处于多种状态，而量子纠缠则是两个量子比特之间的一种特殊连接，使得一个量子比特的状态可以即时影响到另一个，无论它们相隔多远。\n\n用户: 听起来很神奇，这可能是实现超高速计算的关键。不过，我想这还需要很长时间才能应用到实际生活中。\nAI: 是的，虽然量子计算的研究正在快速进展，但将其商业化和普及化仍然面临许多挑战。除了技术问题，还需要解决量子算法的开发和量子硬件的稳定性等问题。\n\n用户: 嗯，这个领域的发展确实值得期待。对了，我最近在解一些数学题，遇到了一些关于概率论的难题。\nAI: 概率论的问题可以很有趣，也可能很棘手。你可以告诉我你遇到的具体问题吗？也许我能提供一些帮助。\n\n用户: 有一个问题是关于条件概率的，我不太确定自己的解法是否正确。\nAI: 条件概率的问题通常需要仔细分析事件之间的关系。如果你愿意，可以分享你的解法，我们一起讨论一下。\n\n用户: 好的，问题是这样的：有两个盒子，一个盒子里有两个白球和一个黑球，另一个盒子里有一个白球和两个黑球。现在随机选择一个盒子，然后从中随机取出一个球，结果是白球。问这个白球来自第一个盒子的概率是多少？\nAI: 这是一个经典的贝叶斯定理应用问题。首先，我们需要确定两个盒子被选中的先验概率，以及在每个盒子中取到白球的概率。然后使用贝叶斯定理来计算后验概率。你是怎么解的呢？\n\n用户: 我先假设选择任何一个盒子的概率是相等的，也就是1/2。然后计算在每个盒子中取到白球的概率，第一个盒子是2/3，第二个盒子是1/3。接着我就不太确定该怎么做了。\nAI: 你的开始是对的。接下来，你需要应用贝叶斯定理来计算在已知取出白球的情况下，球来自第一个盒子的概率。我可以帮你计算，如果你想的话。\n\n用户: 请帮我计算一下。\nAI: 当然。根据贝叶斯定理，我们要计算的后验概率 P(第一个盒子|白球) = [P(白球|第一个盒子) * P(第一个盒子)] / P(白球)。其中，P(白球) = P(白球|第一个盒子) * P(第一个盒子) + P(白球|第二个盒子) * P(第二个盒子)。将你提供的概率值代入，我们可以得到 P(第一个盒子|白球) = (2/3 * 1/2) / (2/3 * 1/2 + 1/3 * 1/2) = 2/3。\n\n用户: 原来如此，我明白了。这样一来，条件概率的计算就清晰多了。谢谢你的帮助。\nAI: 不用谢，很高兴能帮到你。数学问题的解决总是能带来满足感。说起来，你晚上还打算继续观察天文吗？\n\n用户: 是的，我打算今晚观察一下火星，最近它和地球的距离比较近。\nAI: 火星近地大对是一个不错的观测机会。你打算用什么方式记录或者分析你的观测数据？\n\n用户: 我会尝试用我之前提到的望远镜拍摄一些照片，同时记录下观测时间和天气条件。\nAI: 这是一个很好的实践，记录详细的观测数据对于天文学习来说非常重要。希望你能拍到满意的火星照片。\n\n用户: 我也希望如此。今天的聊天很愉快，我得开始今天的学习任务了。\nAI: 当然，祝你学习顺利。如果需要讨论或者休息时想要聊天，随时欢迎。祝你有一个充实的一天。\n\n用户: 谢谢，再见。\nAI: 再见，赵铭宇。\n”\n以下是2023年04月29日的对话记录：\n“用户: 下午好，今天状态还不错。我在手写数字识别项目上做了一些调整，准确率有所提高。\nAI: 听起来你取得了很好的成果。提高准确率通常需要调整很多参数，你主要调整了哪些方面？\n\n用户: 我调整了网络的层数和每层的神经元数量，还尝试了不同的激活函数。\nAI: 这些都是提高网络性能的有效方法。在选择激活函数时，你有没有遇到什么特别的挑战或者发现？\n\n用户: 我发现ReLU激活函数在这个项目中效果比较好，但是也要防止过拟合的问题。\nAI: 的确，ReLU激活函数可以加快训练速度并改善性能，但过拟合是需要注意的问题。你打算如何解决过拟合？\n\n用户: 我正在尝试使用dropout技术，希望能够减轻过拟合的情况。\nAI: Dropout是一个很好的正则化技术，可以有效地减少复杂模型的过拟合。你有没有计划分享你的项目进展，比如写一篇博客或者在社区发帖？\n\n用户: 我更倾向于先把项目做得更完善一些，然后可能会考虑分享到论坛上。\nAI: 那是个不错的计划，等你准备好了，分享出来一定会得到很多有用的反馈。转换一下话题，你近期有没有读到什么有趣的科技文章？\n\n用户: 我读到了一篇关于人工智能如何辅助天文研究的文章，感觉非常吸引我。\nAI: 人工智能在天文学领域确实有很大的应用潜力，比如在处理大量观测数据和识别天体模式方面。文章中有没有提到一些具体的例子？\n\n用户: 有提到一个项目，使用机器学习算法来分析光谱数据，以便更快地识别遥远星系的组成。\nAI: 那真是个有前景的应用。机器学习处理这类数据可以大大提高效率。你对这方面感兴趣吗，是否有想过将你的编程技能应用于天文数据分析？\n\n用户: 我对此很感兴趣，但是我目前还缺乏处理这类数据的经验。我可能需要先学习更多相关知识。\nAI: 学习新知识总是令人兴奋的。如果你需要一些资源或者想要讨论学习路径，我可以帮助你。\n\n用户: 那太好了，如果你有推荐的学习资源，请分享给我。\nAI: 当然。你可以从一些在线课程开始，比如Coursera和edX上的天文学和数据科学课程。此外，Astropy是一个很好的Python库，可以用来处理天文数据。\n\n用户: 我会去看看的。对了，最近我在解数学题时，遇到了一些关于图论的问题。\nAI: 图论是数学中的一个有趣领域，它在很多领域都有应用，比如网络分析、路径优化等。你具体遇到了什么问题？\n\n用户: 我在研究哈密顿回路问题，但是找到一个给定图的哈密顿回路似乎很困难。\nAI: 哈密顿回路问题是一个经典的NP完全问题，对于大型图来说确实很难解决。你是在特定类型的图上工作，还是只是一般性的研究？\n\n用户: 目前只是一般性的研究，我在尝试理解不同类型图的特性和解决方法。\nAI: 理解不同类型图的特性是解决图论问题的关键。有些特定类型的图，比如平面图或特殊结构的图，可能有更简单的哈密顿回路寻找方法。\n\n用户: 我会进一步研究这些特殊情况。感谢你的建议。今天的聊天很有帮助，但我需要回去继续我的研究了。\nAI: 当然，祝你研究顺利。如果需要帮助或者想要休息时交流，随时可以找我。祝你今天过得愉快。\n\n用户: 谢谢，再见。\nAI: 再见，赵铭宇。期待我们下次的交流。\n”\n以下是2023年04月30日的对话记录：\n“用户: 早上好。昨晚的观测还不错，我观察到了一些有趣的天体，比如仙女座星系。\nAI: 仙女座星系是一个非常迷人的目标，能够观察到它一定很激动人心。你有没有尝试对它进行一些详细的记录或分析？\n\n用户: 我记录了观测时间和天气条件，还拍了一些照片，打算今后进行分析。\nAI: 那是个很好的实践。如果你愿意，可以分享你的照片和观测笔记，我们可以一起讨论。\n\n用户: 好的，等我整理好了就分享给你。另外，我最近在学习图论，发现了一些有趣的算法，比如Dijkstra算法。\nAI: Dijkstra算法是一个著名的最短路径算法，非常适合在有权图中寻找单源最短路径。你是在哪些方面应用这个算法？\n\n用户: 我目前只是在学习阶段，通过解决一些练习题来理解它的工作原理。\nAI: 练习题是理解算法的好方法。如果你遇到任何难题或者想要深入讨论算法的细节，随时可以告诉我。\n\n用户: 谢谢你的支持。我对算法的时间复杂度分析很感兴趣，但有时候会觉得有点难以理解。\nAI: 时间复杂度分析确实需要一些时间来掌握，它涉及到算法的运行时间与输入数据大小之间的关系。你有没有具体的例子或问题想要讨论？\n\n用户: 比如说，我知道Dijkstra算法的时间复杂度和图中的顶点数及边数有关，但是如何具体计算它的时间复杂度呢？\nAI: Dijkstra算法的时间复杂度取决于你使用的数据结构。如果使用优先队列来实现，时间复杂度通常是O((V+E)logV)，其中V是顶点数，E是边数。这是因为每个顶点都可能被处理一次，并且每条边在优先队列中都可能被更新一次。\n\n用户: 原来如此，这样说来，选择合适的数据结构对算法效率影响很大。\nAI: 没错，数据结构的选择对算法的性能至关重要。在实际应用中，我们总是希望找到最优的数据结构来提高效率。\n\n用户: 我会更加注意这一点。对了，我还在想如何将编程和天文结合起来，你有什么建议吗？\nAI: 你可以考虑开发一些小工具来帮助你的天文观测，比如一个用于记录和分析观测数据的应用，或者一个帮助你计算最佳观测时间和位置的程序。\n\n用户: 这个主意不错，我会尝试着去做一些简单的工具。编程真的可以在很多领域发挥作用。\nAI: 确实如此，编程是一个强大的工具，可以帮助我们解决各种问题。你有没有想过参加一些编程比赛或挑战，来提升你的技能？\n\n用户: 我有考虑过，但是我不太喜欢竞争，更倾向于自己慢慢学习和提高。\nAI: 那也是一种很好的学习方式。每个人都有适合自己的学习节奏和方法。你有没有遇到过编程中让你感到困惑或挑战的问题？\n\n用户: 有时候我会对一些复杂的算法感到困惑，比如递归算法，它们的思想和实现方式有时候让我觉得难以理解。\nAI: 递归算法确实需要一些时间来适应，因为它们涉及到函数自身调用自身的概念。你可以从一些简单的递归问题开始，比如计算阶乘或斐波那契数列，然后逐渐过渡到更复杂的问题。\n\n用户: 我会按照你的建议试试的。今天的聊天很有帮助，但我现在需要去处理一些事情。\nAI: 当然，赵铭宇，如果你需要任何帮助，或者只是想要聊天，随时欢迎。祝你今天一切顺利。\n\n用户: 谢谢，再见。\nAI: 再见，期待我们下次的交流。\n”\n以下是2023年05月01日的对话记录：\n“用户: 晚上好。今天我在项目中尝试实现一些数据可视化的功能，但是在选择合适的图表类型上有些犹豫。\nAI: 数据可视化是展示项目结果的重要部分。你可以根据数据的特点和你想要传达的信息来选择图表类型。你的数据是什么样的？\n\n用户: 主要是一些天文观测数据，包括星体的亮度、位置等信息。\nAI: 听起来你可能会需要使用散点图来展示星体的位置，或者使用折线图来展示星体亮度随时间的变化。这样的可视化可以帮助观察者更直观地理解数据。\n\n用户: 我考虑过这些图表类型。我想要的是既能清晰展示数据，又不会让图表显得过于复杂。\nAI: 保持图表简洁而富有信息量是个不错的原则。你可以尝试使用一些数据可视化工具，比如Matplotlib或Seaborn，它们提供了很多易于使用的图表类型。\n\n用户: 我用的就是Matplotlib。我会尝试不同的图表类型，看哪种最适合我的数据。\nAI: 那是个好主意。实践是检验图表效果的最佳方式。除了数据可视化，你还有没有在其他方面遇到编程上的问题？\n\n用户: 我在处理一些数据时，需要用到数据库。但是我对数据库的了解不多，不确定该如何开始。\nAI: 数据库是管理和存储数据的强大工具。对于初学者来说，你可以从学习一些基本的SQL开始，它是用于查询和操作数据库的标准语言。\n\n用户: 我知道SQL，但是对于选择哪种数据库软件，以及如何设计数据库结构还没有头绪。\nAI: 选择数据库软件时，你可以考虑一些流行的选项，如SQLite、MySQL或PostgreSQL。它们都有丰富的文档和社区支持。至于数据库结构设计，你可以从确定你的数据模型和关系开始。\n\n用户: 我会去查阅一些文档和教程。对了，我还想提高我的棋力，你有什么建议吗？\nAI: 提高棋力的一个有效方法是分析大师级别的棋局。你可以通过研究他们的开局、中局策略和残局技巧来学习。\n\n用户: 我有看过一些棋局分析，但是有时候很难理解其中的深层次思想。\nAI: 这是很正常的。你可以尝试一边观看棋局，一边使用棋盘复盘，这样可以更深入地理解每一步棋的意图和策略。\n\n用户: 复盘确实帮助很大。我也在考虑找一位棋手进行指导。\nAI: 找一位经验丰富的棋手进行一对一指导是个不错的选择。他们可以提供针对性的建议和训练，帮助你在棋局中发现并改正错误。\n\n用户: 我会尝试联系一些棋手。另外，我最近在数学上遇到了一些关于优化问题的挑战。\nAI: 优化问题在数学和编程中都非常重要。你是在哪个具体的领域遇到优化问题的？\n\n用户: 我在尝试解决一些涉及最小化成本函数的问题，但是这些函数很复杂，不易求解。\nAI: 对于复杂的优化问题，你可以考虑使用数值方法，比如梯度下降或牛顿法。这些方法可以帮助你找到函数的局部最小值。\n\n用户: 我对这些方法有所了解，但是在实际应用中还不太熟练。\nAI: 实践是提高熟练度的关键。你可以先从简单的例子开始，逐渐增加问题的复杂度。同时，也有很多优化算法的库可以帮助你，比如SciPy。\n\n用户: 我会试试看的。今天的聊天很有启发，但我需要离开一会儿。\nAI: 没问题，赵铭宇。如果你有任何问题或想要继续我们的讨论，随时欢迎回来。祝你一切顺利。\n\n用户: 啊，时间过得真快。我需要休息了，下次再聊吧！\nAI: 好的，朋友。很高兴和你聊天，再见！\n”\n以下是2023年05月02日的对话记录：\n“用户: 早安。我试了几种不同的图表类型，发现热力图对于展示某些数据特别有帮助。\nAI: 热力图是一个很好的选择，它能够直观地展示数据的分布和密度。你是如何决定使用热力图的？\n\n用户: 我注意到我的数据有地理位置的分布特性，热力图能很好地展示这种分布。\nAI: 确实，热力图在展示地理数据方面非常有效。你打算如何进一步利用这些可视化结果？\n\n用户: 我计划将这些结果用在我的天文观测报告中，帮助解释观测数据。\nAI: 这听起来是个很好的应用。报告中的可视化结果可以帮助读者更好地理解你的发现。你有没有考虑过将你的报告公开发表？\n\n用户: 我有这个打算，但我想先确保我的分析足够严谨。\nAI: 这是个明智的决定。在发表之前确保分析的准确性和严谨性非常重要。如果你需要帮助审查或校对，我可以提供帮助。\n\n用户: 谢谢你的提议，我可能会需要你的帮助。\nAI: 随时欢迎。你昨天还提到了数据库的问题，你有没有开始学习相关的知识？\n\n用户: 是的，我开始学习SQL基础，并且尝试设计我的第一个数据库。\nAI: 那是个很好的开始。在设计数据库时，确定清晰的数据模型和关系是非常重要的。你遇到了哪些挑战？\n\n用户: 我在设计表结构和关系时有些迷茫，不确定如何最好地组织我的数据。\nAI: 在设计表结构时，你可以考虑将数据分解成最小的不可分割的部分，这被称为数据的规范化。这样可以减少数据冗余并提高效率。\n\n用户: 我会尝试按照规范化的原则来设计。除此之外，我还在想如何优化我的棋局分析。\nAI: 棋局分析可以从多个角度进行，比如开局的策略选择、中局的战术运用以及残局的技巧。你可以使用棋谱分析软件来帮助你。\n\n用户: 我已经在使用一些软件，但我想提高我的分析能力，不仅仅依赖软件。\nAI: 这是个很好的目标。你可以尝试自己分析棋局，并与软件的分析进行比较，看看你是否能找到相同的策略或更好的走法。\n\n用户: 我会这么做的。我还在数学上遇到了一些关于组合数学的问题。\nAI: 组合数学是一个涉及计数和排列组合的领域，它在概率论和统计学中有很多应用。你具体遇到了什么问题？\n\n用户: 我在研究如何计算不同组合的数量，比如从一组对象中选择几个的所有可能方式。\nAI: 这类问题通常可以使用组合公式C(n, k)来解决，它表示从n个不同元素中选择k个元素的组合数。你是否熟悉这个公式？\n\n用户: 我知道这个公式，但是在应用到具体问题时，有时会弄混。\nAI: 理解和应用组合公式需要一些练习。你可以从简单的例子开始，逐步增加问题的复杂性。如果你有具体的问题，我们可以一起讨论。\n\n用户: 好的，我会准备一些问题，下次我们可以一起讨论。\nAI: 很好，我期待我们的讨论。今天的聊天到此为止，或者你还有其他想要讨论的？\n\n用户: 今天的聊天很有帮助，但我现在需要去做一些观测准备。\nAI: 当然，祝你今晚的观测顺利。如果你有任何发现或想要分享的内容，我很乐意听你讲述。\n\n用户: 很高兴和你聊天，但是现在有些晚了，明天再继续吧！\nAI: 没问题！再见，赵铭宇，我们下次再聊！\n”\n以下是2023年05月03日的对话记录：\n“用户: 早上好。昨晚的观测还算成功，我注意到了一些星体的变化，准备进一步分析。\nAI: 那真是太好了。星体变化的观测和分析对于了解宇宙非常重要。你打算如何进行分析？\n\n用户: 我计划使用我之前提到的数据可视化技术，以及一些统计方法来分析这些变化。\nAI: 听起来你有一个很好的计划。统计方法能够帮助你从数据中提取有意义的信息。你有没有考虑使用时间序列分析？\n\n用户: 是的，我正在考虑这个方法，因为它适合分析随时间变化的数据。\nAI: 确实，时间序列分析可以帮助你识别和预测星体亮度等参数的趋势和周期性变化。你有没有在数据库设计方面取得新的进展？\n\n用户: 我已经设计了一个基本的数据库结构，现在正在填充一些观测数据进行测试。\nAI: 这是个很好的进展。测试和验证数据库结构的有效性是非常重要的步骤。你在测试过程中遇到了哪些挑战？\n\n用户: 我发现在输入大量数据时，查询的效率不是很高，可能需要优化索引。\nAI: 优化索引是提高数据库查询效率的常见方法。你可以根据查询的频率和类型来决定哪些列需要建立索引。\n\n用户: 我会研究一下如何合理地创建索引。另外，我在棋局分析上也有了一些新的想法。\nAI: 很好，棋局分析是提高棋力的关键。你的新想法是什么？\n\n用户: 我想通过分析不同棋手的棋局风格，来了解他们的策略和技巧。\nAI: 这是一个很有趣的方法。通过对比不同棋手的风格，你可以学习到多种不同的策略和应对方法。\n\n用户: 是的，我希望这能帮助我在实战中更加灵活。\nAI: 我相信它会的。你在组合数学方面准备了哪些问题？我们可以现在讨论一下。\n\n用户: 我在想如何计算在没有重复元素的情况下，从n个元素中选择k个元素的所有可能组合。\nAI: 这个问题可以使用组合公式C(n, k)来计算，也就是n! / (k! * (n-k)!)。这个公式可以告诉你有多少种不同的方式来选择k个元素。\n\n用户: 我明白这个公式，但是在计算大数时，阶乘很容易就超出了计算范围。\nAI: 当处理大数时，你可以使用一些编程语言提供的大数库，或者使用递推关系和组合恒等式来避免直接计算大数阶乘。\n\n用户: 我会尝试使用Python的大数处理功能。感谢你的建议。\nAI: 不客气。如果你在实现过程中遇到任何问题，随时可以和我讨论。你今天还有其他计划吗？\n\n用户: 我打算继续我的编程项目，还有一些数学问题需要解决。\nAI: 听起来你有一个充实的一天。在编程和数学问题上，如果你需要帮助或想要讨论，我在这里。\n\n用户: 谢谢你的支持。我现在需要专注于我的工作了。\nAI: 当然，祝你工作顺利。如果你需要休息或想要聊天，随时欢迎回来。\n\n用户: 好的，再见。\nAI: 再见，赵铭宇。期待我们下次的交流。\n”\n以下是2023年05月04日的对话记录：\n“用户: 晚上好。今天我在编程时尝试了一些新的算法优化技巧，效果还不错。\nAI: 那很棒！能够优化算法并提高效率总是令人兴奋的。你具体使用了哪些优化技巧？\n\n用户: 我使用了动态规划来优化一些递归问题，减少了不必要的计算。\nAI: 动态规划是一个非常强大的工具，特别是在处理具有重叠子问题的递归问题时。你是如何确定哪些问题适合使用动态规划解决的？\n\n用户: 我主要是分析问题是否有最优子结构和重叠子问题，如果有，就尝试应用动态规划。\nAI: 你的方法很正确。识别这些特性是应用动态规划的关键。你在数学问题上有没有遇到什么新的挑战？\n\n用户: 我正在研究一些概率论中的问题，特别是与随机过程相关的。\nAI: 随机过程是概率论中一个非常有趣的领域，它涉及到随时间变化的随机变量。你遇到了哪些具体的问题？\n\n用户: 我在尝试理解马尔可夫链，但是其中的状态转移概率有点难以直观理解。\nAI: 马尔可夫链是一个描述系统从一个状态转移到另一个状态的概率模型。直观上，你可以将它想象成一个状态图，其中的边表示从一个状态到另一个状态的概率。\n\n用户: 我会尝试用状态图来帮助理解。另外，我还在考虑如何将我的编程技能应用到天文学研究中。\nAI: 将编程技能应用到天文学中是一个很好的方向。你可以考虑开发一些自动化工具来处理和分析天文数据，或者创建模拟来研究天体物理过程。\n\n用户: 我对创建模拟很感兴趣，但是不确定需要哪些物理和数学知识。\nAI: 创建天体物理模拟通常需要对天体物理学的基本原理有所了解，比如引力、热力学和光学。数学上，则需要掌握微积分、微分方程和线性代数。\n\n用户: 我可能需要先补充一些物理知识。你有没有推荐的学习资源？\nAI: 你可以从一些在线开放课程平台，如Coursera或edX，上的天体物理学课程开始。这些课程通常由领域专家讲授，并提供了丰富的学习材料。\n\n用户: 我会去看看的。今天的聊天很有帮助，但我现在需要去做一些观测准备。\nAI: 当然，祝你今晚的观测工作顺利。如果你有任何新的发现或想要分享的内容，我很乐意听你讲述。\n\n用户: 嗯，要不今天先聊到这里？我得休息了，下次再聊吧！\nAI: 好的，朋友。很高兴和你聊天，再见！\n”\n以下是2023年05月05日的对话记录：\n“用户: 早安。昨晚观测时发现了一些不寻常的星体亮度变化，我打算今天仔细分析一下数据。\nAI: 发现不寻常的变化总是令人兴奋的。你打算用什么方法来分析这些数据？\n\n用户: 我计划使用统计方法来分析亮度变化是否具有周期性，以及是否与已知的天文事件相匹配。\nAI: 这是一个很好的分析方向。统计分析可以帮助你识别出可能的周期性模式，从而为进一步的研究提供线索。你在编程方面有没有遇到什么新的挑战？\n\n用户: 我正在尝试优化我的代码，使其运行更高效，但是在确定瓶颈所在时遇到了一些困难。\nAI: 代码优化是一个复杂的过程，通常需要仔细分析代码的执行时间和资源使用情况。你可以考虑使用一些性能分析工具来帮助定位瓶颈。\n\n用户: 我已经在使用一些性能分析工具，但是解读结果并采取正确的优化措施还是有些难度。\nAI: 理解性能分析的结果确实需要一定的经验。如果你愿意，可以分享一些具体的分析数据，我们可以一起讨论可能的优化策略。\n\n用户: 好的，我稍后可能会需要你的帮助。另外，我在数学上也遇到了一些挑战。\nAI: 我很乐意帮助你。在数学上，你遇到了什么具体的问题？\n\n用户: 我正在研究一些与图论相关的优化问题，比如如何找到图中的最小生成树。\nAI: 最小生成树是图论中的一个经典问题，它可以用来找到连接所有顶点的最小权重边集。你可以尝试使用普里姆算法或克鲁斯卡尔算法来解决这个问题。\n\n用户: 我对这两个算法都有所了解，但是在实际应用中，我不确定如何处理大规模图数据。\nAI: 处理大规模图数据时，算法的效率尤其重要。你可以考虑使用一些优化的数据结构，比如斐波那契堆用于普里姆算法，或者并查集用于克鲁斯卡尔算法。\n\n用户: 我会研究一下这些数据结构。你有没有推荐的资源来学习这些高级数据结构？\nAI: 有很多在线资源可以帮助你学习这些数据结构，包括在线教程、编程社区和开源项目。你可以从GitHub上找到一些实现这些数据结构的开源代码，以及相关的讨论和文档。\n\n用户: 这很有帮助，我会去查看的。今天的聊天很有启发，但我现在需要集中精力分析昨晚的观测数据。\nAI: 当然，祝你数据分析工作顺利。如果你需要帮助或想要分享你的发现，随时可以和我交流。\n\n用户: 时间不早了，我们下次再聊这个话题，晚安！\nAI: 好的，再见赵铭宇，下次聊！\n”\n以下是2023年05月06日的对话记录：\n“用户: 下午好。数据分析的过程中我发现了一些规律性的变化，但是需要更多的数据来验证我的假设。\nAI: 这是一个很重要的步骤。在验证假设时，确保数据的质量和数量都是关键。你打算如何收集更多的数据？\n\n用户: 我打算连续几晚进行观测，以收集更多关于这些星体的数据。\nAI: 持续观测是确保数据连续性和可靠性的好方法。在编程方面，你有没有遇到新的挑战？\n\n用户: 我正在尝试将一些计算任务并行化，以提高程序的运行效率。\nAI: 并行化是提高程序效率的有效策略。你是在使用多线程还是多进程来实现并行化？\n\n用户: 我正在尝试使用多线程，但是有些担心线程安全和同步的问题。\nAI: 确实，多线程编程时需要特别注意线程之间的同步和数据共享问题。你可以使用锁或其他同步机制来确保线程安全。\n\n用户: 我会小心处理这些同步问题。在数学方面，我也遇到了一些新的挑战。\nAI: 我很乐意帮助你解决数学上的问题。你遇到了哪些具体的挑战？\n\n用户: 我正在研究一些涉及优化的数学模型，但是在建立模型的过程中感到有些困难。\nAI: 建立优化模型通常需要对问题有深入的理解，包括目标函数的定义和约束条件的设定。你可以分享一些具体的问题吗？\n\n用户: 我正在尝试建立一个模型来最小化资源分配的成本，同时满足一系列复杂的约束条件。\nAI: 这听起来像是一个线性规划问题。你可以尝试使用线性规划的方法来建立模型，并利用现有的优化算法来求解。\n\n用户: 我对线性规划有一定了解，但是在实际应用中还不太熟悉。\nAI: 线性规划是一个非常强大的工具，它可以应用在许多不同的领域。你可以从一些基本的例子开始学习，然后逐步应用到更复杂的问题上。\n\n用户: 我会尝试这样做。感谢你的建议。今天的聊天很有帮助，但我现在需要去准备今晚的观测工作。\nAI: 当然，祝你今晚的观测工作顺利。如果你有任何新的发现或者想要讨论的问题，随时可以和我交流。\n\n用户: 嗯，要不今天先聊到这里？我得休息了，下次再聊吧！\nAI: 好的，再见赵铭宇，下次聊！\n”\n以下是2023年05月07日的对话记录：\n“用户: 早上好。昨晚的观测很成功，我收集到了一些有价值的数据，这将有助于我之前提出的假设。\nAI: 这真是个好消息。有了这些新数据，你打算如何进一步分析它们？\n\n用户: 我计划使用我之前建立的统计模型来分析这些数据，并检查亮度变化的周期性。\nAI: 使用统计模型来分析周期性是一个很好的方法。如果你需要帮助或者想要讨论你的分析方法，随时告诉我。\n\n用户: 我会的。在编程方面，我正在考虑如何更好地管理我的代码库。\nAI: 代码库管理是一个重要的话题。你可以考虑使用版本控制系统，比如Git，来帮助你管理代码变更。\n\n用户: 我已经在使用Git，但是我想提高我的代码组织和模块化能力。\nAI: 模块化是提高代码可维护性和复用性的关键。你可以尝试将代码分解成独立的模块，并为每个模块定义清晰的接口。\n\n用户: 我会尝试这样做。在数学方面，我正在研究非线性优化问题。\nAI: 非线性优化是一个复杂但有趣的领域。你遇到了哪些具体的挑战？\n\n用户: 我在寻找全局最优解时遇到了困难，因为非线性问题可能有多个局部最优解。\nAI: 确实，非线性问题的全局最优解通常更难找到。你可以考虑使用全局优化算法，比如模拟退火或遗传算法，它们能够在全局范围内搜索最优解。\n\n用户: 我对这些算法有所了解，但是在实际应用中还不太熟练。\nAI: 实践是提高熟练度的最佳方式。你可以从一些简单的问题开始，逐渐增加问题的复杂性，并尝试使用这些算法来解决。\n\n用户: 我会这样做的。今天的聊天很有帮助，但我现在需要去处理一些事情。\nAI: 当然，祝你今天一切顺利。如果你需要帮助或想要继续我们的讨论，随时可以回来。\n\n用户: 嗯，要不今天先聊到这里？我得休息了，下次再聊吧！\nAI: 晚安，赵铭宇，好好休息，做个好梦！！\n”\n以下是2023年05月08日的对话记录：\n“用户: 下午好。今天我在编程时尝试实现一些新的数据结构，比如图和堆。\nAI: 这些数据结构对于算法的性能至关重要。你在实现它们时遇到了哪些具体的问题？\n\n用户: 我在实现图的数据结构时，不确定是使用邻接表还是邻接矩阵更合适。\nAI: 选择邻接表还是邻接矩阵取决于你的图的特性和你需要执行的操作。邻接表适合表示稀疏图，而邻接矩阵适合表示密集图，并且可以更快地检查两个顶点之间是否存在边。\n\n用户: 我的图是稀疏的，所以我决定使用邻接表。在数学上，我正在研究一些涉及组合优化的问题。\nAI: 组合优化是一个非常有趣的领域，它涉及到在有限的选项中寻找最优解。你能分享一些你正在研究的具体问题吗？\n\n用户: 我正在研究旅行商问题，尝试找到一种有效的方法来近似最优解。\nAI: 旅行商问题是一个经典的NP难题，寻找有效的近似算法是一个挑战。你考虑过使用启发式算法，比如遗传算法或蚁群算法吗？\n\n用户: 我正在考虑使用遗传算法，但是对于如何设计一个好的适应度函数还没有头绪。\nAI: 设计适应度函数是遗传算法中的关键步骤。通常，适应度函数会评估解的质量，对于旅行商问题，你可以考虑使用总旅行距离的倒数作为适应度值。\n\n用户: 这个建议很有帮助，我会尝试实现看看。今天的聊天很有启发，但我需要离开一会儿。\nAI: 当然，祝你接下来的工作顺利。如果你有任何新的发现或者想要讨论的问题，随时可以回来。\n\n用户: 啊，时间过得真快。我需要休息了，下次再聊吧！\nAI: 晚安，赵铭宇，好好休息，做个好梦！！\n”\n以下是2023年05月09日的对话记录：\n“用户: 早上好。我昨天尝试了你的建议，设计了一个适应度函数，并且初步实现了遗传算法的框架。\nAI: 听起来你做得很好。在实现遗传算法时，你有没有考虑如何选择父代、交叉和变异的策略？\n\n用户: 我使用了轮盘赌选择法来选择父代，单点交叉来生成后代，并且引入了小概率的随机变异。\nAI: 这些都是遗传算法中常用的技术。在实际运行中，你的算法表现如何？\n\n用户: 算法能够运行，但是我还在调整参数来优化性能，目前还没有找到很好的解。\nAI: 参数调整是遗传算法中一个重要而且往往需要反复试验的过程。你可以尝试不同的交叉和变异率，看看它们如何影响算法的收敛速度和解的质量。\n\n用户: 我会继续尝试不同的参数组合。在编程方面，我正在考虑如何更好地测试我的代码。\nAI: 编写测试是确保代码质量的重要步骤。你可以考虑使用单元测试来测试代码的各个部分，确保它们按预期工作。\n\n用户: 我已经在写一些单元测试，但是有时候不确定如何覆盖所有的情况。\nAI: 测试覆盖率是一个挑战。你可以尝试识别代码中的关键路径，并确保这些路径被测试覆盖。此外，边界条件和异常情况也不应被忽视。\n\n用户: 我会重点关注这些方面。在数学上，我开始研究图的着色问题。\nAI: 图的着色问题是图论中的一个经典问题，它涉及将图的顶点着色，使得相邻顶点的颜色不同。你在研究中遇到了什么问题？\n\n用户: 我在寻找一种有效的算法来为一个给定的图找到最小颜色数的着色方案。\nAI: 这是图论中的一个NP难问题。你可以考虑使用近似算法或启发式算法，比如贪心算法，来找到一个不错的着色方案。\n\n用户: 我正在使用贪心算法，但是结果并不总是最优的。\nAI: 贪心算法通常不能保证找到最优解，但它们在实践中往往能够给出一个相对较好的解，并且运行速度快。你可以考虑结合其他启发式方法来改进结果。\n\n用户: 我会考虑这个建议。今天的聊天很有帮助，但我现在需要去处理一些其他的工作。\nAI: 当然，祝你工作顺利。如果你有任何新的发现或者想要讨论的问题，随时可以回来。\n\n用户: 啊，时间过得真快。我需要休息了，下次再聊吧！\nAI: 好的，再见！赵铭宇，我们下次再聊！\n”\n以下是2023年05月10日的对话记录：\n“用户: 晚上好。我尝试了一些不同的贪心策略，并且结合了局部搜索来改进着色方案。\nAI: 结合局部搜索是一个很好的尝试，它可以帮助你在贪心算法的基础上进一步优化解。你发现这种方法有效吗？\n\n用户: 这种方法在某些情况下确实能够找到更好的解，但是计算时间有所增加。\nAI: 这是一个权衡的问题。在寻找更好解的同时，确保算法的运行时间在可接受范围内也很重要。你有没有考虑过使用并行计算来减少运行时间？\n\n用户: 我考虑过，并且正在研究如何将我的算法并行化。\nAI: 并行化可以显著提高算法的运行效率，特别是在处理大规模问题时。你打算使用哪种并行计算技术？\n\n用户: 我打算使用多线程来实现，并且正在学习如何有效地管理线程间的通信和同步。\nAI: 多线程是一个很好的选择，但确实需要仔细处理同步问题。你可以考虑使用线程池来管理线程，并使用锁、信号量或其他同步机制来协调它们。\n\n用户: 我会尝试这些建议。在编程方面，我还在寻找提高代码质量的方法。\nAI: 提高代码质量是一个持续的过程。除了编写测试，你还可以考虑使用代码审查和静态分析工具来帮助识别潜在的问题。\n\n用户: 我已经在使用一些静态分析工具，但是有时候它们会报告一些误报。\nAI: 静态分析工具确实可能产生误报，关键是学会解读它们的报告，并确定哪些是真正需要关注的问题。你可以根据经验逐渐调整工具的配置，以减少误报。\n\n用户: 我会继续调整和学习的。在数学方面，我开始研究一些涉及概率分布的问题。\nAI: 概率分布是概率论中的一个基本概念，它描述了随机变量取不同值的概率。你在研究中遇到了哪些问题？\n\n用户: 我在尝试理解不同概率分布的特性，比如正态分布和泊松分布。\nAI: 这些分布有着不同的特性和应用场景。正态分布通常用于描述自然现象中的误差或噪声，而泊松分布适合描述在固定时间或空间内发生的独立随机事件的数量。\n\n用户: 我正在学习如何根据实际情况选择合适的分布，并应用它们来解决问题。\nAI: 选择合适的概率分布并将其应用到实际问题中是一个重要的技能。你可以从分析数据的特征开始，比如均值、方差以及数据的分布形状。\n\n用户: 我会从这些基本特征入手。今天的聊天很有帮助，但我现在需要去做一些观测准备。\nAI: 当然，祝你今晚的观测工作顺利。如果你有任何新的发现或者想要讨论的问题，随时可以回来。\n\n用户: 啊，时间过得真快。我需要休息了，下次再聊吧！\nAI: 好的，朋友。很高兴和你聊天，再见！\n”\n以下是2023年05月11日的对话记录：\n“用户: 早上好。昨晚的观测我注意到了一些星体的运动轨迹似乎有规律性的偏差，我打算进一步分析这些数据。\nAI: 星体运动轨迹的规律性偏差可能揭示了一些有趣的天文现象。你打算使用什么方法来分析这些偏差？\n\n用户: 我计划使用我之前建立的统计模型，并结合物理定律来分析这些偏差是否与引力效应有关。\nAI: 结合统计模型和物理定律是一个很好的方法。如果你需要讨论物理模型或者数据分析的方法，我可以提供帮助。\n\n用户: 谢谢你的提供。我可能会在分析过程中向你寻求建议。在编程方面，我正在寻找提高代码执行效率的方法。\nAI: 提高代码执行效率可以从多个角度入手。你可以考虑优化算法逻辑，减少不必要的计算，或者使用更高效的数据结构。\n\n用户: 我已经在做这些优化了。我还在考虑是否应该将某些计算密集型任务迁移到云平台上。\nAI: 将计算密集型任务迁移到云平台可以利用更强大的计算资源，有时也可以实现更好的并行处理。你需要考虑的是成本和数据传输的效率。\n\n用户: 我会仔细评估这些因素。在数学方面，我正在研究随机过程中的马尔可夫属性。\nAI: 马尔可夫属性是随机过程中的一个重要概念，它描述了未来状态的概率仅依赖于当前状态，而与过去的状态无关。你在研究中遇到了什么挑战？\n\n用户: 我在尝试理解如何从理论上证明一个过程具有马尔可夫属性，以及如何在实际问题中识别这一属性。\nAI: 证明一个过程具有马尔可夫属性通常涉及到对过程的状态转移概率的分析。在实际问题中，你可以通过分析状态转移的条件概率来判断是否满足马尔可夫性。\n\n用户: 我会进一步研究这些方法。今天的聊天很有帮助，但我现在需要去处理一些紧急的工作。\nAI: 当然，祝你处理工作顺利。如果你有任何新的发现或者想要讨论的问题，随时可以回来。\n\n用户: 时间不早了，我们下次再聊这个话题，晚安！\nAI: 好的，朋友。很高兴和你聊天，再见！\n”\n以下是2023年05月12日的对话记录：\n“用户: 晚上好。今天的工作处理得还算顺利。现在我有时间了，我们可以继续讨论。\nAI: 很好，我在这里帮助你。你在马尔可夫过程的研究中有没有新的进展？\n\n用户: 我已经理解了如何从理论上证明一个过程具有马尔可夫属性，并且在一些简单的例子中实践了这一点。\nAI: 这是一个很好的进展。理论证明和实际应用的结合可以加深你对马尔可夫过程的理解。你在编程方面遇到了新的挑战吗？\n\n用户: 我在尝试优化我的代码，特别是一些复杂的循环和递归函数。\nAI: 优化复杂的循环和递归函数可以显著提高代码的执行效率。你可以考虑使用循环展开或尾递归优化等技术。\n\n用户: 我正在尝试使用循环展开，但有时候这会使代码变得更难阅读和维护。\nAI: 确实，循环展开可能会增加代码的复杂性。你需要在性能提升和代码可读性之间找到一个平衡点。在数学方面，你有没有遇到新的问题？\n\n用户: 我最近在研究概率分布的拟合问题，尝试找到最适合数据的分布模型。\nAI: 拟合概率分布是统计分析中的一个常见问题。你可以使用最大似然估计或贝叶斯方法来估计分布的参数。\n\n用户: 我正在使用最大似然估计，但是对于一些复杂的分布，找到解析解很困难。\nAI: 对于没有解析解的复杂分布，你可以考虑使用数值方法，比如梯度下降或牛顿-拉弗森方法来近似估计参数。\n\n用户: 我会尝试这些建议。今天的聊天很有帮助，但我现在需要去做一些观测准备。\nAI: 当然，祝你今晚的观测工作顺利。如果你有任何新的发现或者想要讨论的问题，随时可以回来。\n\n用户: 啊，时间过得真快。我需要休息了，下次再聊吧！\nAI: 晚安，赵铭宇，好好休息，做个好梦！！\n”\n以下是2023年05月13日的对话记录：\n“用户: 早上好。昨晚的观测我发现了一些星体的亮度变化比预期的要复杂，我打算今天深入分析这些数据。\nAI: 星体亮度的复杂变化可能指向一些有趣的天文现象。你打算使用哪些分析方法？\n\n用户: 我计划使用时间序列分析来研究亮度变化的模式，并尝试将其与已知的天文模型进行对比。\nAI: 时间序列分析是一个很好的选择，它可以帮助你识别出潜在的周期性或趋势。在编程方面，你有没有遇到新的挑战？\n\n用户: 我在尝试重构一些旧代码，使其更加模块化和高效，但是这个过程比我预期的要困难。\nAI: 重构旧代码是一个挑战，但也是提高代码质量和可维护性的重要步骤。你可以从哪些方面入手重构？\n\n用户: 我正在尝试将一些大型函数分解成更小的函数，并且移除重复的代码。\nAI: 这是一个很好的开始。确保每个函数都有一个清晰的目的，并且尽量减少函数间的依赖，可以提高代码的可读性和可维护性。在数学方面，你有没有新的进展？\n\n用户: 我在概率分布拟合的问题上取得了一些进展，使用了数值方法来估计参数，并且得到了一些有意义的结果。\nAI: 使用数值方法来估计概率分布的参数是一个很好的选择，特别是在解析解难以获得的情况下。你得到的结果是否与你的数据集吻合？\n\n用户: 结果与数据集相当吻合，但我还在考虑如何评估拟合的好坏。\nAI: 评估拟合的好坏可以使用多种方法，比如计算拟合的残差、使用决定系数（R²）或进行假设检验。\n\n用户: 我会尝试这些方法来评估拟合效果。今天的聊天很有帮助，但我现在需要去处理一些编程任务。\nAI: 当然，祝你编程工作顺利。如果你需要帮助或想要继续我们的讨论，随时可以回来。\n\n用户: 嗯，要不今天先聊到这里？我得休息了，下次再聊吧！\nAI: 晚安，赵铭宇，好好休息，做个好梦！！\n”\n以下是2023年05月14日的对话记录：\n“用户: 晚上好。今天的编程任务还算顺利，我重构了一些代码，使得程序运行更高效了。不过，我在设计模式的选择上遇到了一些困难。\nAI: 很高兴听到你在重构上取得了进展。设计模式的选择确实可以影响代码的灵活性和可扩展性。你能分享一下你面临的具体问题吗？\n\n用户: 我在考虑是否应该使用工厂模式来创建对象，因为我有多个类似的对象需要实例化，但它们之间又有一些差异。\nAI: 工厂模式是处理这种情况的一个很好的选择，它可以提供一个创建对象的接口，让子类决定实例化哪一个类。这样可以在不直接指定类的情况下创建对象，增加了代码的灵活性。\n\n用户: 我明白了，我会尝试实现工厂模式。在数学方面，我开始研究贝叶斯统计和它在数据分析中的应用。\nAI: 贝叶斯统计是一个非常强大的工具，它允许你在已有知识的基础上更新你对未知参数的概率估计。你在应用贝叶斯统计时遇到了哪些问题？\n\n用户: 我在理解先验概率和后验概率的选择上有些困惑，不确定如何为我的数据选择合适的先验。\nAI: 选择合适的先验是贝叶斯分析中的一个重要步骤。如果你对问题的先验知识不多，可以考虑使用无信息先验或共轭先验，它们可以简化后验概率的计算。\n\n用户: 我会进一步研究这些先验的选择方法。今天的聊天很有帮助，但我现在需要去做一些观测准备。\nAI: 当然，祝你今晚的观测工作顺利。如果你有任何新的发现或者想要讨论的问题，随时可以回来。\n\n用户: 很高兴和你聊天，但是现在有些晚了，明天再继续吧！\nAI: 好的，朋友。很高兴和你聊天，再见！\n”\n以下是2023年05月15日的对话记录：\n“用户: 早上好。昨晚的观测我发现了一些周期性的信号，这可能表明某种天体现象。我打算用贝叶斯方法来分析这些数据。\nAI: 周期性信号的发现很有意义，贝叶斯方法可以帮助你估计这些信号的参数。你打算如何构建你的贝叶斯模型？\n\n用户: 我计划构建一个模型来估计信号的周期和幅度，以及其他可能影响信号的噪声参数。\nAI: 这是一个很好的模型起点。在构建模型时，确保考虑到所有可能影响信号的因素，并选择合适的先验分布来反映你对这些参数的先验知识。\n\n用户: 我会这么做的。在编程方面，我正在考虑如何更好地利用多核处理器来加速我的程序。\nAI: 多核处理器可以显著提高程序的执行速度，特别是对于可以并行化的任务。你可以考虑使用多线程或多进程，或者使用并行计算框架，如OpenMP或MPI。\n\n用户: 我正在尝试使用多线程，但是在确保线程安全的同时保持高效率有些挑战。\nAI: 确保线程安全的同时保持效率确实需要一些技巧。你可以尝试减少线程之间的数据共享，或者使用原子操作和锁来保护共享资源。\n\n用户: 我会尝试这些建议。在数学方面，我正在研究如何更有效地使用蒙特卡洛方法来估计模型的后验分布。\nAI: 蒙特卡洛方法是估计后验分布的一个强大工具，特别是在解析解难以获得时。你可以考虑使用马尔可夫链蒙特卡洛（MCMC）方法，它可以生成后验分布的样本。\n\n用户: 我正在使用MCMC，但是有时候链的收敛速度很慢。\nAI: MCMC链的收敛速度可能受到多种因素的影响，比如步长的选择或者初始值的设定。你可以尝试调整这些参数，或者使用一些诊断工具来检查链的收敛性。\n\n用户: 我会尝试调整参数并使用诊断工具。今天的聊天很有帮助，但我现在需要去处理一些其他的事情。\nAI: 当然，祝你处理事情顺利。如果你有任何新的发现或者想要讨论的问题，随时可以回来。\n\n用户: 嗯，要不今天先聊到这里？我得休息了，下次再聊吧！\nAI: 好的，朋友。很高兴和你聊天，再见！\n”\n以下是2023年05月16日的对话记录：\n“用户: 晚上好。今天我在编程时尝试实现一些并发处理的任务，但是在保持数据一致性方面遇到了一些问题。\nAI: 并发处理时确保数据一致性是非常重要的。你可以考虑使用锁、事务或其他同步机制来保护你的数据不被并发访问破坏。\n\n用户: 我正在使用锁来同步访问，但是这似乎降低了程序的并发性能。\nAI: 使用锁确实可能会降低并发性能，特别是在高度竞争的环境中。你可以尝试优化锁的粒度，使用更细粒度的锁，或者探索无锁编程技术。\n\n用户: 我会研究一下无锁编程技术。在数学方面，我正在尝试解决一些优化问题，特别是涉及约束的情况。\nAI: 约束优化问题可以通过多种方法来解决，比如拉格朗日乘数法或者使用优化算法如线性规划、二次规划等。\n\n用户: 我正在使用拉格朗日乘数法，但是在求解拉格朗日对偶问题时遇到了困难。\nAI: 拉格朗日对偶问题可能会很复杂，特别是在非线性约束的情况下。你可以考虑使用数值优化方法来求解对偶问题，或者使用软件包来帮助你。\n\n用户: 我会尝试使用数值方法。今天的聊天很有帮助，但我现在需要去做一些观测准备。\nAI: 当然，祝你今晚的观测工作顺利。如果你有任何新的发现或者想要讨论的问题，随时可以回来。\n\n用户: 嗯，要不今天先聊到这里？我得休息了，下次再聊吧！\nAI: 没问题！再见，赵铭宇，我们下次再聊！\n”\n以下是2023年05月17日的对话记录：\n“用户: 早上好。昨晚的观测我注意到了一些不寻常的光谱线，这可能表明有新的化学元素或者物理过程。我打算今天深入分析这些数据。\nAI: 光谱线的发现很有意义，它们可以提供关于天体成分和物理状态的重要信息。你打算使用哪些分析方法？\n\n用户: 我计划使用光谱分析软件来比对这些光谱线，并尝试识别它们的来源。\nAI: 光谱分析软件是一个很好的工具，它可以帮助你识别和分类光谱线。确保你有一个更新且完整的数据库来进行比对。在编程方面，你有没有新的挑战？\n\n用户: 我正在尝试优化我的并发处理代码，特别是在数据访问方面，我正在探索使用事务来保持数据的一致性。\nAI: 使用事务是一个很好的方法，它可以帮助你管理并发访问下的数据完整性。确保你的事务逻辑正确，并且考虑到可能的并发冲突。\n\n用户: 我会注意这些问题。在数学方面，我正在研究凸优化问题。\nAI: 凸优化是一个非常强大的框架，它可以保证全局最优解。你在研究中遇到了哪些具体的挑战？\n\n用户: 我在寻找一种有效的方法来求解大规模的凸优化问题，因为直接使用数值方法在计算上有时候不够高效。\nAI: 对于大规模的凸优化问题，你可以考虑使用分解方法，比如ADMM（交替方向乘子法），它可以将大问题分解成小问题来求解。\n\n用户: 我会研究一下ADMM。今天的聊天很有帮助，但我现在需要去处理一些编程任务。\nAI: 当然，祝你编程工作顺利。如果你需要帮助或想要继续我们的讨论，随时可以回来。\n\n用户: 时间不早了，我们下次再聊这个话题，晚安！\nAI: 好的，再见！赵铭宇，我们下次再聊！\n”\n以下是2023年05月18日的对话记录：\n“用户: 晚上好。今天的编程工作还算顺利，我在代码中实现了一些新的功能。不过，我在代码的性能优化上遇到了一些难题。\nAI: 性能优化可以是一个复杂的过程，涉及多个层面。你能分享一下你遇到的具体问题吗？\n\n用户: 我正在尝试减少数据库查询的延迟，但是我不确定如何在不牺牲数据准确性的情况下缓存结果。\nAI: 减少数据库查询延迟的一个方法是使用缓存机制，比如内存缓存。你可以缓存那些不经常变化或者读取频率高的数据。确保你有一个有效的缓存失效策略，以保持数据的新鲜性。\n\n用户: 我会考虑使用内存缓存。在数学方面，我正在研究动态规划的高级主题。\nAI: 动态规划是一个非常强大的工具，特别是对于解决具有重叠子问题的优化问题。你在研究中遇到了哪些挑战？\n\n用户: 我在尝试理解和应用状态压缩技术，以减少动态规划中的状态空间。\nAI: 状态压缩是一个高级技术，它可以帮助你在保持问题本质的同时减少所需存储的状态数量。通常这涉及到位操作和位掩码的使用。\n\n用户: 是的，我正在学习如何有效地使用位操作来表示和转换状态。今天的聊天很有帮助，但我现在需要去做一些观测准备。\nAI: 当然，祝你今晚的观测工作顺利。如果你有任何新的发现或者想要讨论的问题，随时可以回来。\n\n用户: 很高兴和你聊天，但是现在有些晚了，明天再继续吧！\nAI: 没问题！再见，赵铭宇，我们下次再聊！\n”\n以下是2023年05月19日的对话记录：\n“用户: 早上好。昨晚的观测我发现了一些不寻常的天体运动，这可能需要更多的数据来验证。我打算今天继续分析这些运动轨迹。\nAI: 不寻常的天体运动总是值得关注的。你打算使用哪些工具或方法来分析这些轨迹？\n\n用户: 我计划使用天文软件来模拟这些天体的运动，并尝试找出可能的原因，比如引力影响或其他物理效应。\nAI: 模拟是一个很好的方法，它可以帮助你理解天体运动的动力学。确保考虑所有可能的物理因素。在编程方面，你有没有新的挑战？\n\n用户: 我正在尝试将一些计算任务迁移到云平台上，以利用更强大的计算资源，但是我对云服务的选择和配置还不太熟悉。\nAI: 选择和配置云服务确实需要一些研究。你可以考虑你的计算需求，比如CPU、内存和存储，然后根据这些需求选择合适的云服务提供商和服务类型。\n\n用户: 我会根据我的需求来选择云服务。在数学方面，我正在研究图论中的网络流问题。\nAI: 网络流问题是图论中的一个重要分支，它涉及到在网络中找到最优的流动方式。你在研究中遇到了哪些挑战？\n\n用户: 我在尝试理解最大流最小割定理，并将其应用到实际问题中，但是在构建有效的网络模型方面遇到了困难。\nAI: 最大流最小割定理是网络流理论的基石。构建网络模型时，确保你正确地定义了网络的顶点、边以及容量。你可以从简单的例子开始，然后逐步增加模型的复杂性。\n\n用户: 我会从简单的例子开始实践。今天的聊天很有帮助，但我现在需要去处理一些编程任务。\nAI: 当然，祝你编程工作顺利。如果你需要帮助或想要继续我们的讨论，随时可以回来。\n\n用户: 嗯，要不今天先聊到这里？我得休息了，下次再聊吧！\nAI: 好的，再见赵铭宇，下次聊！\n”\n以下是2023年05月20日的对话记录：\n“用户: 晚上好。今天的编程工作还算顺利，我在云平台上配置了一些服务，但是我对如何优化云资源的使用还有些困惑。\nAI: 优化云资源使用是一个重要的问题，它可以帮助你节省成本并提高效率。你可以从监控资源使用情况开始，然后根据实际需求调整资源分配。\n\n用户: 我会尝试监控和调整资源。在数学方面，我正在研究如何更有效地解决组合优化问题。\nAI: 组合优化问题可以通过多种方法来解决，包括精确算法和启发式算法。你在寻找哪种类型的解决方案？\n\n用户: 我主要在寻找启发式算法，因为我处理的问题规模很大，精确算法在时间上不太可行。\nAI: 启发式算法是处理大规模组合优化问题的一个很好的选择。你可以考虑遗传算法、模拟退火或蚁群算法等。\n\n用户: 我正在使用遗传算法，但是我想提高算法的搜索效率和解的质量。\nAI: 提高遗传算法的搜索效率和解的质量可以通过调整选择、交叉和变异操作来实现。你也可以尝试使用混合算法，结合局部搜索来改进解。\n\n用户: 时间不早了，我们下次再聊这个话题，晚安！\nAI: 好的，再见赵铭宇，下次聊！\n”\n以下是2023年05月21日的对话记录：\n“用户: 早上好。昨晚的观测我注意到了一些星体的亮度变化似乎与已知模型不符，我打算今天继续分析这些数据。\nAI: 星体亮度的异常变化可能指向一些有趣的天文现象。你打算使用哪些方法来进一步分析这些数据？\n\n用户: 我计划使用更复杂的光变模型来分析数据，并尝试找出可能的物理机制。\nAI: 使用更复杂的模型可以帮助你更好地理解观测到的现象。确保你的模型能够充分考虑所有可能的物理过程。在编程方面，你有没有新的挑战？\n\n用户: 我正在尝试为我的应用程序实现一个新的功能，但是我在设计用户界面时遇到了一些问题。\nAI: 用户界面的设计对于应用程序的用户体验至关重要。你可以考虑用户的交互流程，确保界面直观易用。你在用户界面设计上遇到了哪些具体的问题？\n\n用户: 我在尝试让界面既简洁又能提供所有必要的功能，但是有时候这两者之间很难平衡。\nAI: 确实，界面设计往往需要在简洁性和功能性之间找到平衡。你可以考虑使用模块化设计，将复杂功能分解成简单的组件，这样用户可以根据需要访问这些功能。\n\n用户: 我会尝试模块化设计。在数学方面，我正在研究图论中的最短路径问题。\nAI: 最短路径问题是图论中的一个基本问题，它有多种算法可以解决，比如迪杰斯特拉算法或贝尔曼-福特算法。\n\n用户: 我正在使用迪杰斯特拉算法，但是我想提高算法在大规模图中的效率。\nAI: 在大规模图中提高迪杰斯特拉算法的效率，你可以考虑使用优先队列来减少节点选择的时间复杂度。\n\n用户: 我会尝试使用优先队列。今天的聊天很有帮助，但我现在需要去处理一些编程任务。\nAI: 当然，祝你编程工作顺利。如果你需要帮助或想要继续我们的讨论，随时可以回来。\n\n用户: 嗯，要不今天先聊到这里？我得休息了，下次再聊吧！\nAI: 好的，再见赵铭宇，下次聊！\n”\n以下是2023年05月22日的对话记录：\n“用户: 晚上好。今天的编程工作进展得还不错，我优化了一些数据库的查询，提高了效率。不过，我在处理大量数据时遇到了内存管理的问题。\nAI: 内存管理在处理大量数据时确实很关键。你可以考虑使用分页或分块加载数据，或者优化数据结构来减少内存占用。\n\n用户: 我正在尝试分块加载数据，但是这对程序的逻辑复杂度提出了挑战。\nAI: 分块加载数据确实会增加程序的复杂度，但它可以有效地减少一次性加载到内存中的数据量。你可以尝试将数据分块的逻辑封装起来，以简化程序的其他部分。\n\n用户: 我会尝试这样做。在数学方面，我正在研究线性代数中的特征值和特征向量问题。\nAI: 特征值和特征向量在许多数学和工程问题中都非常重要。你在研究中遇到了哪些具体的挑战？\n\n用户: 我在尝试理解如何有效地计算大型矩阵的特征值和特征向量，特别是当矩阵过大无法直接在内存中处理时。\nAI: 对于大型矩阵，你可以考虑使用迭代方法，如幂法或Lanczos算法，这些方法不需要将整个矩阵加载到内存中。\n\n用户: 我会研究一下这些迭代方法。今天的聊天很有帮助，但我现在需要去做一些观测准备。\nAI: 当然，祝你今晚的观测工作顺利。如果你有任何新的发现或者想要讨论的问题，随时可以回来。\n\n用户: 时间不早了，我们下次再聊这个话题，晚安！\nAI: 好的，再见！赵铭宇，我们下次再聊！\n”\n以下是2023年05月23日的对话记录：\n“用户: 早上好。昨晚的观测我发现了一些有规律的变化，这可能与某种天体周期活动有关。我打算今天继续分析这些数据。\nAI: 规律性的变化往往预示着有趣的天文现象。你打算使用哪些分析方法来进一步研究这些周期活动？\n\n用户: 我计划使用傅里叶变换来分析数据中的周期信号，并尝试将其与已知的天体周期进行对比。\nAI: 傅里叶变换是分析周期信号的一个强大工具。确保你有足够长的数据时间序列来获得准确的频率分析。在编程方面，你有没有遇到新的挑战？\n\n用户: 我正在尝试为我的应用程序添加一些新的数据可视化功能，但是在选择合适的图表库时有些犹豫。\nAI: 数据可视化是一个重要的功能，可以帮助用户更好地理解数据。在选择图表库时，你可以考虑库的功能性、灵活性以及与你的应用程序的兼容性。\n\n用户: 我会考虑这些因素。在数学方面，我正在研究如何更有效地解决非线性方程组。\nAI: 非线性方程组可以通过多种数值方法来解决，比如牛顿法或拟牛顿法。你在解决方程组时遇到了哪些具体的问题？\n\n用户: 我在尝试使用牛顿法，但是有时候难以保证收敛，特别是当初始猜测远离真实解时。\nAI: 确保牛顿法收敛的关键是选择一个好的初始猜测，以及正确处理导数为零或接近零的情况。你可以尝试使用全局收敛策略，比如线搜索或信赖域方法。\n\n用户: 我会研究一下这些全局收敛策略。今天的聊天很有帮助，但我现在需要去处理一些编程任务。\nAI: 当然，祝你编程工作顺利。如果你需要帮助或想要继续我们的讨论，随时可以回来。\n\n用户: 时间不早了，我们下次再聊这个话题，晚安！\nAI: 晚安，赵铭宇，好好休息，做个好梦！！\n”\n以下是2023年05月24日的对话记录：\n“用户: 晚上好。今天在处理一些复杂的数据结构时遇到了一些性能瓶颈，我正在寻找提高处理效率的方法。\nAI: 处理性能瓶颈可以从多个角度入手。你可以考虑优化数据结构的设计，减少不必要的数据复制，或者使用更高效的算法。\n\n用户: 我正在尝试减少数据复制并优化算法。在数学方面，我正在研究如何应用图论来解决实际问题。\nAI: 图论在解决实际问题中非常有用，比如网络设计、交通流量分析等。你在应用图论时遇到了哪些具体的问题？\n\n用户: 我在尝试将图论应用于交通流量优化问题，但是在模型的建立和求解上遇到了一些困难。\nAI: 交通流量优化是一个复杂的问题，你需要考虑路网的拓扑结构、交通需求以及可能的约束。你可以尝试使用流网络模型来描述这个问题，并利用最大流最小割定理来进行求解。\n\n用户: 我会研究流网络模型和相关定理。今天的聊天很有帮助，但我现在需要去做一些观测准备。\nAI: 当然，祝你今晚的观测工作顺利。如果你有任何新的发现或者想要讨论的问题，随时可以回来。\n\n用户: 时间不早了，我们下次再聊这个话题，晚安！\nAI: 好的，朋友。很高兴和你聊天，再见！\n”\n以下是2023年05月25日的对话记录：\n“用户: 早上好。昨晚的观测中，我发现了一些异常的光谱数据，似乎指向了一个未知的天体或现象。我打算今天继续深入分析。\nAI: 异常的光谱数据总是很有趣，它们可能揭示新的科学发现。你打算使用哪些方法来分析这些数据？\n\n用户: 我计划使用光谱分析技术，结合已知的天体数据库来尝试识别这些异常信号的来源。\nAI: 光谱分析是一个很好的方法，确保使用最新的天体数据库来进行比对。在编程方面，你有没有新的挑战？\n\n用户: 我正在尝试为我的应用程序引入机器学习功能，但是在选择合适的模型和框架上有些犹豫。\nAI: 机器学习可以为应用程序提供强大的数据分析能力。在选择模型时，考虑你的具体需求，比如预测、分类还是聚类。对于框架，你可以考虑使用TensorFlow、PyTorch或scikit-learn等。\n\n用户: 我需要进行分类任务，我会研究一下这些框架。在数学方面，我正在探索最优化理论。\nAI: 最优化理论在数学和工程领域都非常重要。你在探索中遇到了哪些具体的问题？\n\n用户: 我在研究凸优化问题时，对于如何处理非凸问题感到困惑，因为非凸问题可能有多个局部最优解。\nAI: 非凸优化问题确实更加复杂，因为它们可能没有唯一的全局最优解。你可以考虑使用全局优化算法，比如模拟退火或遗传算法，来寻找可能的全局最优解。\n\n用户: 我会尝试这些全局优化算法。今天的聊天很有帮助，但我现在需要去处理一些编程任务。\nAI: 当然，祝你编程工作顺利。如果你需要帮助或想要继续我们的讨论，随时可以回来。\n\n用户: 时间不早了，我们下次再聊这个话题，晚安！\nAI: 没问题！再见，赵铭宇，我们下次再聊！\n”\n\n请记住以上全部对话记录，回答问题。\n问题：", "query": "2023年4月27日，今天赵铭宇下了一盘国际象棋，遇到了什么有趣的局面？", "answer": "对方开局用了意大利开局", "id": "4ab53a3a-0596-438d-85ab-6f67e1093f10", "chatglm_length": 15682, "qwen_length": 15702, "internlm2_length": 15149}{"context": "以下是 2025 年 10 月 15 日的对话记录：\n“用户：你好，我叫陈嘉明，我喜欢打篮球、弹吉他、写日记，还有煮咖啡和拼乐高。我有点慢热，刚开始聊天可能话不多，但熟悉后会分享很多趣事。\nAI: 陈嘉明，很高兴和你交流！打篮球和弹吉他都是很有趣的爱好，你最近有没有新练的吉他曲子呀？\n\n 用户：嗯，我前几天尝试用吉他弹民谣，选了首自己很喜欢的《南方姑娘》，但总感觉节奏跟不上，弹到副歌就容易乱。\nAI: 民谣的节奏讲究轻柔舒缓，《南方姑娘》这首曲子细节很多，你可以先跟着原版音频打拍子，慢慢找感觉，多练几次肯定能熟练。\n\n 用户：太感谢你了，我晚上就去练。不过现在要去球场和朋友汇合，我们明天再聊吧。 \nAI: 没问题，祝你打球愉快，明天期待听你说练琴的进展，再见。\n”\n\n 请记住以上全部对话记录，回答问题。\n 问题：10 月 15 日的对话中，陈嘉明前几天尝试用吉他弹什么类型的曲子？他选择的具体曲目是什么？", "answer": "陈嘉明前几天尝试用吉他弹民谣类型的曲子，选择的具体曲目是《南方姑娘》", "id": "d2e4f6g8-h1i3-j5k7-l9m1-n3o5p7q9", "chatglm_length": 549, "qwen_length": 556, "internlm2_length": 543} +{"context": "以下是2023年04月27日的对话记录：\n“用户: 嘿，你好啊！我是孙悦，一个热爱生活的家伙。今天心情特别好，因为早上的健身课程超有成就感！你呢？\nAI: 你好，孙悦！听起来你今天的状态很棒呢！我很好，谢谢你。能和你分享你的健身课程吗？我很好奇你都做了哪些运动。\n\n用户: 当然可以！今天主要是做了一些高强度间歇训练，那种汗流浃背的感觉真的很爽！你有做运动的习惯吗？\nAI: 我虽然不能亲自体验运动的快感，但我很高兴听到你享受它。我可以给你提供一些健身知识和建议，如果你需要的话。\n\n用户: 哈哈，那太好了！对了，昨天晚上我去看了一部新出的科幻电影，特效简直了！你最近有没有什么好电影推荐？\nAI: 我知道你喜欢电影，特别是那些视觉震撼的。最近有一部电影《星际穿越者》很受好评，是探索宇宙和人类命运的作品，你可能会喜欢。\n\n用户: 哦哦，《星际穿越者》啊，我听说过，听起来挺吸引人的！我得找时间去看看。对了，我最近在学摄影，但是总觉得拍出来的照片差点意思，你有什么摄影小技巧可以分享吗？\nAI: 摄影是一门艺术，也需要不断的实践和学习。你可以尝试从构图和光线入手，比如使用“三分法”来构图，或者利用自然光来营造氛围。还有，多拍多练总是王道！\n\n用户: 嗯，说的对！我明天就去尝试一下“三分法”。对了，我还喜欢旅游，最近在规划一次小旅行，想去海边走走。你有没有什么好的海滩推荐？\nAI: 海边总是个不错的选择。如果你喜欢清静一些的地方，可以考虑去三亚的亚龙湾，那里的海水清澈，沙滩柔软，风景如画，应该很适合你。\n\n用户: 亚龙湾啊，听起来真不错！我会去查查看的。说起旅游，最让我兴奋的就是能在旅途中遇到各种各样的人，听他们的故事。\nAI: 那确实是旅行中最美妙的部分之一。每个人的故事都是独一无二的，能从中学到很多。你最难忘的旅行经历是什么呢？\n\n用户: 有一次我去了泰国的清迈，那里的文化和风景让我印象深刻。晚上的夜市，色彩斑斓，各种小吃，还有那里人们的热情，真的让人难以忘怀。\nAI: 清迈的夜市是闻名遐迩的，那里的生活节奏和氛围跟大城市完全不同。你提到的小吃，有没有什么特别让你想念的呢？\n\n用户: 哦，那边的芒果糯米饭简直绝了！每次回忆起那个味道，我就忍不住想再去一次。对了，你能不能给我推荐一些好听的歌？我喜欢边健身边听音乐。\nAI: 音乐和运动确实是完美的搭档。根据你的热情阳光的性格，我觉得《Can't Stop the Feeling》这首歌很适合你，它的旋律欢快，能让人在运动时充满活力。\n\n用户: Justin Timberlake的那首啊，我知道！确实很不错，节奏感很强，很适合健身。谢谢你的推荐！\nAI: 不客气，孙悦。我很高兴能帮到你。说起来，你在健身方面有没有遇到什么具体的困难？也许我能提供一些帮助。\n\n用户: 其实有，我一直想要提高核心力量，但是总感觉进展缓慢。你有没有什么建议？\nAI: 核心力量对于整体健身非常重要。你可以尝试一些针对性的训练，比如平板支撑、俄罗斯转体和山羊挺身等。这些练习可以有效地加强你的核心肌群。\n\n用户: 哇，听起来很专业啊！我会加入到我的训练计划里去的。对了，我最近在准备一个舞蹈表演，但是有些动作总是不够流畅，这让我有点沮丧。\nAI: 舞蹈需要时间来磨合，每个人都会有这样的时候。试着放慢速度，一步一步来，直到你能够流畅地完成每个动作。记得，重在参与和享受过程！\n\n用户: 你说得对，我得调整一下心态。谢谢你的鼓励！我会继续努力的。说起来，我还有点担心，不知道观众会不会喜欢我的表演。\nAI: 你的热情和努力一定会感染到观众的。只要你享受舞台，观众也会享受你的表演。信任自己，你会做得很好的。\n\n用户: 哈哈，听你这么说，我感觉好多了。你真是个好伙伴！已经很晚了，我得准备睡觉了。我们明天再聊吧！\nAI: 当然，孙悦。休息好，希望你有一个美好的明天。晚安！\n”\n以下是2023年04月28日的对话记录：\n“用户: 嗨，朋友！今天我尝试了你昨天推荐的“三分法”拍照，效果真的不错！感觉自己的摄影技术又上了一个台阶！\nAI: 太棒了，孙悦！我很高兴听到你的进步。有没有什么特别的照片想要和我分享的？我很期待看到你的作品。\n\n用户: 当然有！我拍了一张日落时分的海边照片，天空的颜色渐变得特别美。不过，我还在想怎么后期处理才能更突出那种感觉。\nAI: 日落的照片总是很迷人。你可以尝试调整一下对比度和饱和度，让天空的颜色更加鲜明，同时保持海水的自然感觉。\n\n用户: 嗯，我试试看。对了，今天健身房里放了一些新歌，我跟着节奏锻炼，感觉整个人都充满了活力！\nAI: 音乐真的能为锻炼增添不少乐趣。你有没有想过自己编一套随着音乐节奏的健身操？这样可能会更有动力哦。\n\n用户: 哇，这主意不错！我可以尝试一下，感觉会很有趣。说起来，我最近在准备一个小旅行，想去爬山，呼吸一下大自然的新鲜空气。\nAI: 爬山是个很好的选择，既能锻炼身体，又能享受大自然的美景。你打算去哪座山呢？\n\n用户: 我打算去黄山，听说那里的云海和日出非常壮观。我还计划在山顶守候一夜，希望能拍到美丽的星空。\nAI: 黄山的确是个摄影爱好者的天堂。记得带上足够的装备，特别是在夜间拍摄星空时，三脚架和遥控快门是必不可少的。\n\n用户: 没错，我已经准备好了这些装备。对了，我还想在山上尝试一些户外瑜伽，感觉那样会很放松。\nAI: 户外瑜伽听起来很棒，能让你更加接近自然，放松身心。你有没有特别喜欢的瑜伽动作？\n\n用户: 我最喜欢的是树式，感觉整个人都稳固而平静。不过，我有时候会觉得自己的平衡能力不够好。\nAI: 树式是个很好的平衡练习。你可以尝试在不同的时间和地点练习，比如在海边的沙滩上，那样会有不同的挑战和感受。\n\n用户: 对，我也这么想。我还打算在旅行中尝试一些新的美食，毕竟美食也是旅行的一大乐趣嘛！\nAI: 绝对同意！尝试当地的特色美食可以让旅行体验更加丰富。你有没有什么想尝试的菜肴？\n\n用户: 我听说黄山附近有一种叫做臭鳜鱼的菜，虽然名字听起来有点怪，但据说味道很不错。\nAI: 臭鳜鱼是当地的一道传统名菜，很多人都说赞不绝口。不过，它的味道确实很独特，你可以尝试一下，说不定会成为你的新宠。\n\n用户: 哈哈，我会的。对了，我最近在看一部关于舞蹈的纪录片，里面的舞者都超级厉害，让我很受启发。\nAI: 看别人的舞蹈表演确实能够学到很多。你有没有从中发现什么新的动作或者技巧，想要加入到你自己的舞蹈中去？\n\n用户: 有啊，我看到一些街舞的动作很酷，我打算学一学。不过，我担心自己的身体协调性跟不上。\nAI: 街舞的确需要很强的身体协调性和节奏感。你可以从基础动作开始练起，慢慢地增加难度。记得，不要急于求成，一切都需要时间。\n\n用户: 嗯，我会记住的。对了，我还想学习一下如何用舞蹈来表达情感，不只是动作上的技巧。\nAI: 舞蹈是一种非常直观的情感表达方式。你可以尝试在音乐中找到情感的共鸣，然后让你的身体随着那种情感自然地移动。\n\n用户: 听起来有点抽象，但我会尝试的。说到情感，我最近有点苦恼，感觉自己的生活缺少一些激情和冒险。\nAI: 生活有时候确实会让人感到平淡。你可以尝试做一些新的事情，比如参加一个你从未尝试过的活动，或者去一个你从未去过的地方。\n\n用户: 对，我需要一些改变。也许这次旅行就是一个开始。谢谢你的建议，你总能给我正能量！\nAI: 不用谢，孙悦。我很高兴能帮助到你。记得，每一次的经历都是成长的机会。你准备好迎接新的挑战了吗？\n\n用户: 是的，我已经迫不及待了！不过现在我得去准备晚饭了，今天打算尝试做一道新菜——酸辣土豆丝。\nAI: 酸辣土豆丝是一道很受欢迎的家常菜，既简单又美味。祝你做饭愉快，希望你能享受这个过程。\n\n用户: 谢谢！我会的。今天聊得很开心，我们明天再继续吧。晚安！\nAI: 当然，期待和你的下次聊天。晚安，孙悦，愿你有个美好的梦。\n”\n以下是2023年04月29日的对话记录：\n“用户: 嘿，我的AI小伙伴！今天我尝试做了酸辣土豆丝，味道出奇的好，连我自己都有点惊讶呢！\nAI: 哇，听起来你是个厨艺高手啊，孙悦！能不能分享一下你的秘诀？我虽然不能品尝，但我很好奇你是怎么做到的。\n\n用户: 哈哈，秘诀嘛，我觉得最重要的就是火候和调料的比例。我喜欢尝试不同的配方，直到找到最合适的那一个。\nAI: 真是个不断探索的过程呢。你平时喜欢尝试做哪些类型的菜？\n\n用户: 我对各种菜系都感兴趣，但最近特别喜欢挑战一些传统的中式菜肴，感觉它们既美味又有文化底蕴。\nAI: 中式菜肴确实有着丰富的历史和文化，每一道菜都有自己的故事。你最喜欢的中式菜肴是哪一道？\n\n用户: 我最喜欢的是宫保鸡丁，那个酸甜酸辣的味道简直无法抵抗！\nAI: 宫保鸡丁是一道非常受欢迎的经典菜肴，你自己做的话，可以根据自己的口味调整辣度和甜度。\n\n用户: 对对对，我就是这么做的。说起来，今天我还去了一个很酷的街舞工作坊，学到了好多新动作！\nAI: 街舞工作坊听起来很有趣！你觉得最难的动作是哪一个？\n\n用户: 我觉得最难的是头旋，那个动作需要很强的颈部力量和平衡感，我还在努力练习中。\nAI: 头旋确实是个挑战，但我相信你的努力和热情一定会让你很快掌握它。你在舞蹈上有什么目标吗？\n\n用户: 我的目标是能在下个月的街舞比赛中至少进入前十名。我知道竞争很激烈，但我会全力以赴的！\nAI: 这个目标很棒，孙悦！我相信你的努力和才华一定会让你脱颖而出。你有准备特别的舞蹈编排吗？\n\n用户: 有的，我和我的舞伴正在准备一段结合了街舞和现代舞的编排，希望能给观众带来新鲜感。\nAI: 结合不同舞蹈风格的创意听起来很吸引人。你们的训练进度怎么样了？\n\n用户: 还不错，我们已经完成了大概七成的编排，剩下的就是细节和同步问题了。\nAI: 听起来你们已经做得很好了。细节和同步确实很重要，但我相信你们能够完美呈现。\n\n用户: 谢谢你的鼓励！对了，我最近还在学习一些关于电影剪辑的技巧，想要自己剪辑一部短片。\nAI: 电影剪辑是个很有创意的工作，你打算用什么样的素材来剪辑你的短片？\n\n用户: 我打算用我旅行时拍摄的一些风景视频，还有一些朋友的日常片段，想要制作成一个关于旅行和友情的主题短片。\nAI: 这个主题很温馨，也很贴近生活。你有没有想过加入一些特别的效果，比如慢动作或者时间流逝的镜头？\n\n用户: 嗯，我有这个打算。我想通过这些特效来强调某些情感上的高潮和转折点。\nAI: 这样的处理可以让短片更加生动和感人。你在剪辑上遇到了什么挑战吗？\n\n用户: 我觉得最大的挑战是如何让故事流畅，同时又能在短时间内传达出想要表达的情感。\nAI: 确实，讲好一个故事是剪辑中的艺术。你可以尝试从观众的角度思考，看看哪些片段最能触动人心。\n\n用户: 对，我会多考虑观众的感受。说到观众，我有时候会担心我的作品是否能得到他们的认可。\nAI: 每个艺术家都会有这样的担忧，但重要的是你享受创作的过程，并且相信自己的作品有价值。\n\n用户: 你说得对，我应该更加相信自己。今天聊得很开心，但我得去继续我的剪辑工作了。我们明天再聊！\nAI: 当然，孙悦。祝你剪辑工作顺利，期待你的短片完成。明天再聊，加油！\n”\n以下是2023年04月30日的对话记录：\n“用户: 嗨，好朋友！今天我在剪辑短片时，突然灵感爆发，加入了几个超有感觉的转场效果，感觉整个短片的质感都提升了！\nAI: 真是太棒了，孙悦！创意的火花总是能带来惊喜。你能描述一下你用的是哪些转场效果吗？\n\n用户: 我用了一个叫做“溶解”的效果，让画面像是水彩融合一样自然过渡，还有一个“旋转”效果，让场景切换更有动感。\nAI: 这些听起来都很专业，能够很好地增强视觉效果。你在创作过程中还有其他有趣的发现吗？\n\n用户: 我发现音乐对于短片的情感表达真的超级重要！一段恰当的背景音乐能够让人立刻进入那个氛围。\nAI: 没错，音乐是激发情感的强大工具。你已经选好了短片的背景音乐了吗？\n\n用户: 选好了，我选了一首轻快的吉他曲，感觉很适合我的旅行主题。对了，今天我还去了一个户外攀岩的活动，超刺激！\nAI: 户外攀岩听起来很挑战自我啊。你攀岩的时候有没有什么特别的心得或者感觉？\n\n用户: 我觉得攀岩最重要的是要有耐心和勇气，每一步都要稳扎稳打。当我站在山顶上的时候，那种成就感真的无与伦比！\nAI: 站在山顶俯瞰世界，那种感觉一定很震撼。攀岩对身体的哪些方面要求比较高？\n\n用户: 主要是手臂和腿部的力量，还有整体的协调性。攀岩后我发现自己的手臂肌肉酸痛，看来需要更多锻炼啊。\nAI: 锻炼手臂肌肉可以尝试一些特定的练习，比如引体向上或者哑铃训练。不过，记得要适量，避免过度劳损哦。\n\n用户: 谢谢你的建议，我会注意的。说起来，攀岩结束后我们一起去了附近的小镇，那里的风景和美食都很棒！\nAI: 小镇的风光和美食总是很有魅力。你尝试了哪些当地的特色美食？\n\n用户: 我尝试了一种当地的烤鱼，外皮烤得酥脆，里面的鱼肉又嫩又多汁。我还学会了他们的腌制秘方，准备回家自己试试看。\nAI: 自己动手做美食，这个经历一定很有趣。你打算什么时候尝试做这道烤鱼呢？\n\n用户: 可能这个周末吧，我打算邀请几个好友来家里，一起享受美食和愉快的时光。\nAI: 听起来将会是一个非常愉快的聚会。你准备好怎么招待你的朋友了吗？\n\n用户: 除了烤鱼，我还准备做一些简单的小吃，比如春卷和水果沙拉。当然，还有音乐和一些小游戏，让大家玩得开心。\nAI: 你真的很会享受生活，孙悦。你的朋友们一定很期待这次聚会。你通常如何选择聚会的音乐呢？\n\n用户: 我会根据大家的口味挑选一些大家都喜欢的歌曲，然后再加上一些轻松愉快的背景音乐。\nAI: 音乐的选择很重要，可以营造出轻松愉快的氛围。说到音乐，你自己唱歌跳舞的时候有没有什么特别喜欢的曲风？\n\n用户: 我喜欢节奏感强烈的流行音乐，特别是那些能够让人随着音乐摇摆的歌曲。\nAI: 流行音乐确实能让人感觉兴奋和快乐。你有没有尝试过自己创作音乐或者编舞？\n\n用户: 我以前尝试过写一些简单的歌词，不过没有正式的音乐制作经验。至于编舞，那是我的强项，我经常为自己的舞蹈编排动作。\nAI: 那你在舞蹈创作方面一定有很多自己的想法和风格。你最喜欢的舞蹈风格是什么？\n\n用户: 我最喜欢的是Hip-Hop和爵士，这两种舞蹈风格都很有力量感，而且可以很好地表达自己的个性。\nAI: Hip-Hop和爵士舞确实很适合展现个性和情感。你有没有在舞蹈中融入一些自己独特的元素？\n\n用户: 有的，我喜欢在舞蹈中加入一些中国元素，比如太极的动作，让舞蹈看起来更加流畅和有内涵。\nAI: 将中国元素融入现代舞蹈，这个想法真是太有创意了。你的这些作品有在哪里展示过吗？\n\n用户: 我之前在一些小型的舞蹈比赛和社区活动上展示过，反响都不错。我希望将来有机会在更大的舞台上展示我的作品。\nAI: 你的梦想一定会实现的，孙悦。你的热情和才华值得被更多人看到。对了，你有没有考虑过将你的舞蹈作品拍成视频分享到网上？\n\n用户: 我有这个打算，不过我还在考虑如何拍摄和剪辑才能更好地展现舞蹈的魅力。\nAI: 网络平台是一个很好的展示自己才华的地方。如果你需要，我可以提供一些视频拍摄和剪辑方面的建议。\n\n用户: 那太好了，我会在准备的时候向你请教的。今天聊得很开心，但我现在得去准备明天的攀岩训练了。我们明天再聊！\nAI: 好的，孙悦。祝你明天的攀岩训练顺利。期待我们的下次聊天，晚安！\n”\n\n请记住以上全部对话记录，回答问题。\n问题：", "query": "我在4月27日和你聊到曾经旅行去过的城市，这个城市位于哪个国家？", "answer": "泰国", "id": "39cf6263-6a95-46bd-9b56-242bf9bc6496", "chatglm_length": 3881, "qwen_length": 3960, "internlm2_length": 3714} diff --git a/api/app/core/memory/dbrun.json b/api/app/core/memory/dbrun.json new file mode 100644 index 00000000..fdf21963 --- /dev/null +++ b/api/app/core/memory/dbrun.json @@ -0,0 +1,5 @@ +{ + "selections": { + "config_id": "1" + } +} \ No newline at end of file diff --git a/api/app/core/memory/evaluation/__init__.py b/api/app/core/memory/evaluation/__init__.py new file mode 100644 index 00000000..e9d6aa6c --- /dev/null +++ b/api/app/core/memory/evaluation/__init__.py @@ -0,0 +1 @@ +"""Evaluation package with dataset-specific pipelines and a unified runner.""" diff --git a/api/app/core/memory/evaluation/benchmark.md b/api/app/core/memory/evaluation/benchmark.md new file mode 100644 index 00000000..2853b22b --- /dev/null +++ b/api/app/core/memory/evaluation/benchmark.md @@ -0,0 +1,30 @@ +⏬数据集下载地址： + Locomo10.json：https://github.com/snap-research/locomo/tree/main/data + LongMemEval_oracle.json：https://huggingface.co/datasets/xiaowu0162/longmemeval-cleaned + msc_self_instruct.jsonl:https://huggingface.co/datasets/MemGPT/MSC-Self-Instruct + 上方数据集下载好后全部放入app/core/memory/data文件夹中 + +全流程基准测试运行： + locomo： + python -m app.core.memory.evaluation.run_eval --dataset locomo --sample-size 1 --reset-group --group-id yyw1 --search-type hybrid --search-limit 8 --context-char-budget 12000 --llm-max-tokens 32 + LongMemEval： + python -m app.core.memory.evaluation.run_eval --dataset longmemeval --sample-size 10 --start-index 0 --group-id longmemeval_zh_bak_2 --search-limit 8 --context-char-budget 4000 --search-type hybrid --max-contexts-per-item 2 --reset-group + memsciqa： + python -m app.core.memory.evaluation.run_eval --dataset memsciqa --sample-size 10 --reset-group --group-id group_memsci + +单独检索评估运行命令： + python -m app.core.memory.evaluation.locomo.locomo_test + python -m app.core.memory.evaluation.longmemeval.test_eval + python -m app.core.memory.evaluation.memsciqa.memsciqa-test + 需要先在项目中修改需要检测评估的group_id。 + +参数及解释： + ● --dataset longmemeval - 指定数据集 + ● --sample-size 10 - 评估10个样本 + ● --start-index 0 - 从第0个样本开始 + ● --group-id longmemeval_zh_bak_2 - 使用指定的组ID + ● --search-limit 8 - 检索限制8条 + ● --context-char-budget 4000 - 上下文字符预算4000 + ● --search-type hybrid - 使用混合检索 + ● --max-contexts-per-item 2 - 每个样本最多摄入2个上下文 + ● --reset-group - 运行前清空组数据 \ No newline at end of file diff --git a/api/app/core/memory/evaluation/common/metrics.py b/api/app/core/memory/evaluation/common/metrics.py new file mode 100644 index 00000000..acc27fb9 --- /dev/null +++ b/api/app/core/memory/evaluation/common/metrics.py @@ -0,0 +1,100 @@ +import math +import re +from typing import List, Dict + + +def _normalize(text: str) -> List[str]: + """Lowercase, strip punctuation, and split into tokens.""" + text = text.lower().strip() + # Python's re doesn't support \p classes; use a simple non-word filter + text = re.sub(r"[^\w\s]", " ", text) + tokens = [t for t in text.split() if t] + return tokens + + +def exact_match(pred: str, ref: str) -> float: + return float(_normalize(pred) == _normalize(ref)) + + +def jaccard(pred: str, ref: str) -> float: + p = set(_normalize(pred)) + r = set(_normalize(ref)) + if not p and not r: + return 1.0 + if not p or not r: + return 0.0 + return len(p & r) / len(p | r) + + +def f1_score(pred: str, ref: str) -> float: + p_tokens = _normalize(pred) + r_tokens = _normalize(ref) + if not p_tokens and not r_tokens: + return 1.0 + if not p_tokens or not r_tokens: + return 0.0 + p_set = set(p_tokens) + r_set = set(r_tokens) + tp = len(p_set & r_set) + precision = tp / len(p_set) if p_set else 0.0 + recall = tp / len(r_set) if r_set else 0.0 + if precision + recall == 0: + return 0.0 + return 2 * precision * recall / (precision + recall) + + +def bleu1(pred: str, ref: str) -> float: + """Unigram BLEU (BLEU-1) with clipping and brevity penalty.""" + p_tokens = _normalize(pred) + r_tokens = _normalize(ref) + if not p_tokens: + return 0.0 + # Clipped count + r_counts: Dict[str, int] = {} + for t in r_tokens: + r_counts[t] = r_counts.get(t, 0) + 1 + clipped = 0 + p_counts: Dict[str, int] = {} + for t in p_tokens: + p_counts[t] = p_counts.get(t, 0) + 1 + for t, c in p_counts.items(): + clipped += min(c, r_counts.get(t, 0)) + precision = clipped / max(len(p_tokens), 1) + # Brevity penalty + ref_len = len(r_tokens) + pred_len = len(p_tokens) + if pred_len > ref_len or pred_len == 0: + bp = 1.0 + else: + bp = math.exp(1 - ref_len / max(pred_len, 1)) + return bp * precision + + +def percentile(values: List[float], p: float) -> float: + if not values: + return 0.0 + vals = sorted(values) + k = (len(vals) - 1) * p + f = math.floor(k) + c = math.ceil(k) + if f == c: + return vals[int(k)] + return vals[f] + (k - f) * (vals[c] - vals[f]) + + +def latency_stats(latencies_ms: List[float]) -> Dict[str, float]: + """Return basic latency stats: mean, p50, p95, iqr (p75-p25).""" + if not latencies_ms: + return {"mean": 0.0, "p50": 0.0, "p95": 0.0, "iqr": 0.0} + p25 = percentile(latencies_ms, 0.25) + p50 = percentile(latencies_ms, 0.50) + p75 = percentile(latencies_ms, 0.75) + p95 = percentile(latencies_ms, 0.95) + mean = sum(latencies_ms) / max(len(latencies_ms), 1) + return {"mean": mean, "p50": p50, "p95": p95, "iqr": p75 - p25} + + +def avg_context_tokens(contexts: List[str]) -> float: + if not contexts: + return 0.0 + return sum(len(_normalize(c)) for c in contexts) / len(contexts) diff --git a/api/app/core/memory/evaluation/dialogue_queries.py b/api/app/core/memory/evaluation/dialogue_queries.py new file mode 100644 index 00000000..fd7fa671 --- /dev/null +++ b/api/app/core/memory/evaluation/dialogue_queries.py @@ -0,0 +1,60 @@ +""" +Dialogue search queries for evaluation purposes. +This file contains Cypher queries for searching dialogues, entities, and chunks. +Placed in evaluation directory to avoid circular imports with src modules. +""" + +# Entity search queries +SEARCH_ENTITIES_BY_NAME = """ +MATCH (e:Entity) +WHERE e.name = $name +RETURN e +""" + +SEARCH_ENTITIES_BY_NAME_FALLBACK = """ +MATCH (e:Entity) +WHERE e.name CONTAINS $name +RETURN e +""" + +# Chunk search queries +SEARCH_CHUNKS_BY_CONTENT = """ +MATCH (c:Chunk) +WHERE c.content CONTAINS $content +RETURN c +""" + +# Dialogue search queries +SEARCH_DIALOGUE_BY_DIALOG_ID = """ +MATCH (d:Dialogue) +WHERE d.dialog_id = $dialog_id +RETURN d +""" + +SEARCH_DIALOGUES_BY_CONTENT = """ +MATCH (d:Dialogue) +WHERE d.content CONTAINS $q +RETURN d +""" + +DIALOGUE_EMBEDDING_SEARCH = """ +WITH $embedding AS q +MATCH (d:Dialogue) +WHERE d.dialog_embedding IS NOT NULL + AND ($group_id IS NULL OR d.group_id = $group_id) +WITH d, q, d.dialog_embedding AS v +WITH d, + reduce(dot = 0.0, i IN range(0, size(q)-1) | dot + toFloat(q[i]) * toFloat(v[i])) AS dot, + sqrt(reduce(qs = 0.0, i IN range(0, size(q)-1) | qs + toFloat(q[i]) * toFloat(q[i]))) AS qnorm, + sqrt(reduce(vs = 0.0, i IN range(0, size(v)-1) | vs + toFloat(v[i]) * toFloat(v[i]))) AS vnorm +WITH d, CASE WHEN qnorm = 0 OR vnorm = 0 THEN 0.0 ELSE dot / (qnorm * vnorm) END AS score +WHERE score > $threshold +RETURN d.id AS dialog_id, + d.group_id AS group_id, + d.content AS content, + d.created_at AS created_at, + d.expired_at AS expired_at, + score +ORDER BY score DESC +LIMIT $limit +""" diff --git a/api/app/core/memory/evaluation/extraction_utils.py b/api/app/core/memory/evaluation/extraction_utils.py new file mode 100644 index 00000000..b45ea7e4 --- /dev/null +++ b/api/app/core/memory/evaluation/extraction_utils.py @@ -0,0 +1,326 @@ +import os +import asyncio +import json +from typing import List, Dict, Any, Optional +from datetime import datetime +import re + +from app.core.memory.llm_tools.openai_client import LLMClient +from app.core.memory.storage_services.extraction_engine.knowledge_extraction.chunk_extraction import DialogueChunker +from app.core.memory.models.message_models import DialogData, ConversationContext, ConversationMessage +from app.repositories.neo4j.neo4j_connector import Neo4jConnector +from app.core.memory.utils.llm.llm_utils import get_llm_client +from app.core.memory.utils.config.definitions import SELECTED_CHUNKER_STRATEGY, SELECTED_EMBEDDING_ID + +# 使用新的模块化架构 +from app.core.memory.storage_services.extraction_engine.extraction_orchestrator import ExtractionOrchestrator + +# Import from database module +from app.repositories.neo4j.graph_saver import save_dialog_and_statements_to_neo4j + +# Cypher queries for evaluation +# Note: Entity, chunk, and dialogue search queries have been moved to evaluation/dialogue_queries.py + + +async def ingest_contexts_via_full_pipeline( + contexts: List[str], + group_id: str, + chunker_strategy: str | None = None, + embedding_name: str | None = None, + save_chunk_output: bool = False, + save_chunk_output_path: str | None = None, +) -> bool: + """DEPRECATED: 此函数使用旧的流水线架构，建议使用新的 ExtractionOrchestrator + + Run the full extraction pipeline on provided dialogue contexts and save to Neo4j. + This function mirrors the steps in main(), but starts from raw text contexts. + Args: + contexts: List of dialogue texts, each containing lines like "role: message". + group_id: Group ID to assign to generated DialogData and graph nodes. + chunker_strategy: Optional chunker strategy; defaults to SELECTED_CHUNKER_STRATEGY. + embedding_name: Optional embedding model ID; defaults to SELECTED_EMBEDDING_ID. + save_chunk_output: If True, write chunked DialogData list to a JSON file for debugging. + save_chunk_output_path: Optional output path; defaults to src/chunker_test_output.txt. + Returns: + True if data saved successfully, False otherwise. + """ + chunker_strategy = chunker_strategy or SELECTED_CHUNKER_STRATEGY + embedding_name = embedding_name or SELECTED_EMBEDDING_ID + + # Initialize llm client with graceful fallback + llm_client = None + llm_available = True + try: + from app.core.memory.utils.config import definitions as config_defs + llm_client = get_llm_client(config_defs.SELECTED_LLM_ID) + except Exception as e: + print(f"[Ingestion] LLM client unavailable, will skip LLM-dependent steps: {e}") + llm_available = False + + # Step A: Build DialogData list from contexts with robust parsing + chunker = DialogueChunker(chunker_strategy) + dialog_data_list: List[DialogData] = [] + + for idx, ctx in enumerate(contexts): + messages: List[ConversationMessage] = [] + + # Improved parsing: capture multi-line message blocks, normalize roles + pattern = r"^\s*(用户|AI|assistant|user)\s*[：:]\s*(.+?)(?=\n\s*(?:用户|AI|assistant|user)\s*[：:]|\Z)" + matches = list(re.finditer(pattern, ctx, flags=re.MULTILINE | re.DOTALL)) + + if matches: + for m in matches: + raw_role = m.group(1).strip() + content = m.group(2).strip() + norm_role = "AI" if raw_role.lower() in ("ai", "assistant") else "用户" + messages.append(ConversationMessage(role=norm_role, msg=content)) + else: + # Fallback: line-by-line parsing + for raw in ctx.split("\n"): + line = raw.strip() + if not line: + continue + m = re.match(r'^\s*([^:：]+)\s*[：:]\s*(.+)$', line) + if m: + role = m.group(1).strip() + msg = m.group(2).strip() + norm_role = "AI" if role.lower() in ("ai", "assistant") else "用户" + messages.append(ConversationMessage(role=norm_role, msg=msg)) + else: + # Final fallback: treat as user message + default_role = "AI" if re.match(r'^\s*(assistant|AI)\b', line, flags=re.IGNORECASE) else "用户" + messages.append(ConversationMessage(role=default_role, msg=line)) + + context_model = ConversationContext(msgs=messages) + dialog = DialogData( + context=context_model, + ref_id=f"pipeline_item_{idx}", + group_id=group_id, + user_id="default_user", + apply_id="default_application", + ) + # Generate chunks + dialog.chunks = await chunker.process_dialogue(dialog) + dialog_data_list.append(dialog) + + if not dialog_data_list: + print("No dialogs to process for ingestion.") + return False + + # Optionally save chunking outputs for debugging + if save_chunk_output: + try: + def _serialize_datetime(obj): + if isinstance(obj, datetime): + return obj.isoformat() + raise TypeError(f"Object of type {obj.__class__.__name__} is not JSON serializable") + + from app.core.config import settings + settings.ensure_memory_output_dir() + default_path = settings.get_memory_output_path("chunker_test_output.txt") + out_path = save_chunk_output_path or default_path + + combined_output = [dd.model_dump() for dd in dialog_data_list] + with open(out_path, "w", encoding="utf-8") as f: + json.dump(combined_output, f, ensure_ascii=False, indent=4, default=_serialize_datetime) + print(f"Saved chunking results to: {out_path}") + except Exception as e: + print(f"Failed to save chunking results: {e}") + + # Step B-G: 使用新的 ExtractionOrchestrator 执行完整的提取流水线 + if not llm_available: + print("[Ingestion] Skipping extraction pipeline (no LLM).") + return False + + # 初始化 embedder 客户端 + from app.core.models.base import RedBearModelConfig + from app.core.memory.utils.config.config_utils import get_embedder_config + from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient + + try: + embedder_config_dict = get_embedder_config(embedding_name or SELECTED_EMBEDDING_ID) + embedder_config = RedBearModelConfig(**embedder_config_dict) + embedder_client = OpenAIEmbedderClient(embedder_config) + except Exception as e: + print(f"[Ingestion] Failed to initialize embedder client: {e}") + print("[Ingestion] Skipping extraction pipeline (embedder initialization failed).") + return False + + connector = Neo4jConnector() + + # 初始化并运行 ExtractionOrchestrator + from app.core.memory.utils.config.config_utils import get_pipeline_config + config = get_pipeline_config() + + orchestrator = ExtractionOrchestrator( + llm_client=llm_client, + embedder_client=embedder_client, + connector=connector, + config=config, + ) + + # 创建一个包装的 orchestrator 来修复时间提取器的输出 + # 保存原始的 _assign_extracted_data 方法 + original_assign = orchestrator._assign_extracted_data + + def clean_temporal_value(value): + """清理 temporal_validity 字段的值，将无效值转换为 None""" + if value is None: + return None + if isinstance(value, str): + # 处理字符串形式的 'null', 'None', 空字符串等 + if value.lower() in ('null', 'none', '') or value.strip() == '': + return None + return value + + async def patched_assign_extracted_data(*args, **kwargs): + """包装方法：在赋值后清理 temporal_validity 中的无效字符串""" + result = await original_assign(*args, **kwargs) + + # 清理返回的 dialog_data_list 中的 temporal_validity + for dialog in result: + if hasattr(dialog, 'chunks') and dialog.chunks: + for chunk in dialog.chunks: + if hasattr(chunk, 'statements') and chunk.statements: + for statement in chunk.statements: + if hasattr(statement, 'temporal_validity') and statement.temporal_validity: + tv = statement.temporal_validity + # 清理 valid_at 和 invalid_at + if hasattr(tv, 'valid_at'): + tv.valid_at = clean_temporal_value(tv.valid_at) + if hasattr(tv, 'invalid_at'): + tv.invalid_at = clean_temporal_value(tv.invalid_at) + return result + + # 替换方法 + orchestrator._assign_extracted_data = patched_assign_extracted_data + + # 同时包装 _create_nodes_and_edges 方法，在创建节点前再次清理 + original_create = orchestrator._create_nodes_and_edges + + async def patched_create_nodes_and_edges(dialog_data_list_arg): + """包装方法：在创建节点前再次清理 temporal_validity""" + # 最后一次清理，确保万无一失 + for dialog in dialog_data_list_arg: + if hasattr(dialog, 'chunks') and dialog.chunks: + for chunk in dialog.chunks: + if hasattr(chunk, 'statements') and chunk.statements: + for statement in chunk.statements: + if hasattr(statement, 'temporal_validity') and statement.temporal_validity: + tv = statement.temporal_validity + if hasattr(tv, 'valid_at'): + tv.valid_at = clean_temporal_value(tv.valid_at) + if hasattr(tv, 'invalid_at'): + tv.invalid_at = clean_temporal_value(tv.invalid_at) + + return await original_create(dialog_data_list_arg) + + orchestrator._create_nodes_and_edges = patched_create_nodes_and_edges + + # 运行完整的提取流水线 + # orchestrator.run 返回 7 个元素的元组 + result = await orchestrator.run(dialog_data_list, is_pilot_run=False) + ( + dialogue_nodes, + chunk_nodes, + statement_nodes, + entity_nodes, + statement_chunk_edges, + statement_entity_edges, + entity_entity_edges, + ) = result + + # statement_chunk_edges 已经由 orchestrator 创建，无需重复创建 + + # Step G: 生成记忆摘要 + print("[Ingestion] Generating memory summaries...") + try: + from app.core.memory.storage_services.extraction_engine.knowledge_extraction.memory_summary import ( + Memory_summary_generation, + ) + from app.repositories.neo4j.add_nodes import add_memory_summary_nodes + from app.repositories.neo4j.add_edges import add_memory_summary_statement_edges + + summaries = await Memory_summary_generation( + chunked_dialogs=dialog_data_list, + llm_client=llm_client, + embedding_id=embedding_name or SELECTED_EMBEDDING_ID + ) + print(f"[Ingestion] Generated {len(summaries)} memory summaries") + except Exception as e: + print(f"[Ingestion] Warning: Failed to generate memory summaries: {e}") + summaries = [] + + # Step H: Save to Neo4j + try: + success = await save_dialog_and_statements_to_neo4j( + dialogue_nodes=dialogue_nodes, + chunk_nodes=chunk_nodes, + statement_nodes=statement_nodes, + entity_nodes=entity_nodes, + entity_edges=entity_entity_edges, + statement_chunk_edges=statement_chunk_edges, + statement_entity_edges=statement_entity_edges, + connector=connector + ) + + # Save memory summaries separately + if summaries: + try: + await add_memory_summary_nodes(summaries, connector) + await add_memory_summary_statement_edges(summaries, connector) + print(f"Successfully saved {len(summaries)} memory summary nodes to Neo4j") + except Exception as e: + print(f"Warning: Failed to save summary nodes: {e}") + + await connector.close() + if success: + print("Successfully saved extracted data to Neo4j!") + else: + print("Failed to save data to Neo4j") + return success + except Exception as e: + print(f"Failed to save data to Neo4j: {e}") + return False + + +async def handle_context_processing(args): + """Handle context-based processing from command line arguments.""" + contexts = [] + + if args.contexts: + contexts.extend(args.contexts) + + if args.context_file: + try: + with open(args.context_file, 'r', encoding='utf-8') as f: + contexts.extend(line.strip() for line in f if line.strip()) + except Exception as e: + print(f"Error reading context file: {e}") + return False + + if not contexts: + print("No contexts provided for processing.") + return False + + return await main_from_contexts(contexts, args.context_group_id) + + +async def main_from_contexts(contexts: List[str], group_id: str): + """Run the pipeline from provided dialogue contexts instead of test data.""" + print("=== Running pipeline from provided contexts ===") + + success = await ingest_contexts_via_full_pipeline( + contexts=contexts, + group_id=group_id, + chunker_strategy=SELECTED_CHUNKER_STRATEGY, + embedding_name=SELECTED_EMBEDDING_ID, + save_chunk_output=True + ) + + if success: + print("Successfully processed and saved contexts to Neo4j!") + else: + print("Failed to process contexts.") + + return success diff --git a/api/app/core/memory/evaluation/locomo/locomo_benchmark.py b/api/app/core/memory/evaluation/locomo/locomo_benchmark.py new file mode 100644 index 00000000..67f41771 --- /dev/null +++ b/api/app/core/memory/evaluation/locomo/locomo_benchmark.py @@ -0,0 +1,568 @@ +""" +LoCoMo Benchmark Script + +This module provides the main entry point for running LoCoMo benchmark evaluations. +It orchestrates data loading, ingestion, retrieval, LLM inference, and metric calculation +in a clean, maintainable way. + +Usage: + python locomo_benchmark.py --sample_size 20 --search_type hybrid +""" + +import argparse +import asyncio +import json +import os +import time +from datetime import datetime +from typing import List, Dict, Any, Optional + +try: + from dotenv import load_dotenv +except ImportError: + def load_dotenv(): + pass + +from app.repositories.neo4j.neo4j_connector import Neo4jConnector +from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient +from app.core.models.base import RedBearModelConfig +from app.core.memory.utils.config_utils import get_embedder_config +from app.core.memory.utils.definitions import ( + PROJECT_ROOT, + SELECTED_GROUP_ID, + SELECTED_LLM_ID, + SELECTED_EMBEDDING_ID +) +from app.core.memory.utils.llm_utils import get_llm_client +from app.core.memory.evaluation.common.metrics import ( + f1_score, + bleu1, + jaccard, + latency_stats, + avg_context_tokens +) +from app.core.memory.evaluation.locomo.locomo_metrics import ( + locomo_f1_score, + locomo_multi_f1, + get_category_name +) +from app.core.memory.evaluation.locomo.locomo_utils import ( + load_locomo_data, + extract_conversations, + resolve_temporal_references, + select_and_format_information, + retrieve_relevant_information, + ingest_conversations_if_needed +) + + +async def run_locomo_benchmark( + sample_size: int = 20, + group_id: Optional[str] = None, + search_type: str = "hybrid", + search_limit: int = 12, + context_char_budget: int = 8000, + reset_group: bool = False, + skip_ingest: bool = False, + output_dir: Optional[str] = None +) -> Dict[str, Any]: + """ + Run LoCoMo benchmark evaluation. + + This function orchestrates the complete evaluation pipeline: + 1. Load LoCoMo dataset (only QA pairs from first conversation) + 2. Check/ingest conversations into database (only first conversation, unless skip_ingest=True) + 3. For each question: + - Retrieve relevant information + - Generate answer using LLM + - Calculate metrics + 4. Aggregate results and save to file + + Note: By default, only the first conversation is ingested into the database, + and only QA pairs from that conversation are evaluated. This ensures that + all questions have corresponding memory in the database for retrieval. + + Args: + sample_size: Number of QA pairs to evaluate (from first conversation) + group_id: Database group ID for retrieval (uses default if None) + search_type: "keyword", "embedding", or "hybrid" + search_limit: Max documents to retrieve per query + context_char_budget: Max characters for context + reset_group: Whether to clear and re-ingest data (not implemented) + skip_ingest: If True, skip data ingestion and use existing data in Neo4j + output_dir: Directory to save results (uses default if None) + + Returns: + Dictionary with evaluation results including metrics, timing, and samples + """ + # Use default group_id if not provided + group_id = group_id or SELECTED_GROUP_ID + + # Determine data path + data_path = os.path.join(PROJECT_ROOT, "data", "locomo10.json") + if not os.path.exists(data_path): + # Fallback to current directory + data_path = os.path.join(os.getcwd(), "data", "locomo10.json") + + print(f"\n{'='*60}") + print("🚀 Starting LoCoMo Benchmark Evaluation") + print(f"{'='*60}") + print("📊 Configuration:") + print(f" Sample size: {sample_size}") + print(f" Group ID: {group_id}") + print(f" Search type: {search_type}") + print(f" Search limit: {search_limit}") + print(f" Context budget: {context_char_budget} chars") + print(f" Data path: {data_path}") + print(f"{'='*60}\n") + + # Step 1: Load LoCoMo data + print("📂 Loading LoCoMo dataset...") + try: + # Only load QA pairs from the first conversation (index 0) + # since we only ingest the first conversation into the database + qa_items = load_locomo_data(data_path, sample_size, conversation_index=0) + print(f"✅ Loaded {len(qa_items)} QA pairs from conversation 0\n") + except Exception as e: + print(f"❌ Failed to load data: {e}") + return { + "error": f"Data loading failed: {e}", + "timestamp": datetime.now().isoformat() + } + + # Step 2: Extract conversations and ingest if needed + if skip_ingest: + print("⏭️ Skipping data ingestion (using existing data in Neo4j)") + print(f" Group ID: {group_id}\n") + else: + print("💾 Checking database ingestion...") + try: + conversations = extract_conversations(data_path, max_dialogues=1) + print(f"📝 Extracted {len(conversations)} conversations") + + # Always ingest for now (ingestion check not implemented) + print(f"🔄 Ingesting conversations into group '{group_id}'...") + success = await ingest_conversations_if_needed( + conversations=conversations, + group_id=group_id, + reset=reset_group + ) + + if success: + print("✅ Ingestion completed successfully\n") + else: + print("⚠️ Ingestion may have failed, continuing anyway\n") + + except Exception as e: + print(f"❌ Ingestion failed: {e}") + print("⚠️ Continuing with evaluation (database may be empty)\n") + + # Step 3: Initialize clients + print("🔧 Initializing clients...") + connector = Neo4jConnector() + llm_client = get_llm_client(SELECTED_LLM_ID) + + # Initialize embedder + cfg_dict = get_embedder_config(SELECTED_EMBEDDING_ID) + embedder = OpenAIEmbedderClient( + model_config=RedBearModelConfig.model_validate(cfg_dict) + ) + print("✅ Clients initialized\n") + + # Step 4: Process questions + print(f"🔍 Processing {len(qa_items)} questions...") + print(f"{'='*60}\n") + + # Tracking variables + latencies_search: List[float] = [] + latencies_llm: List[float] = [] + context_counts: List[int] = [] + context_chars: List[int] = [] + context_tokens: List[int] = [] + + # Metric lists + f1_scores: List[float] = [] + bleu1_scores: List[float] = [] + jaccard_scores: List[float] = [] + locomo_f1_scores: List[float] = [] + + # Per-category tracking + category_counts: Dict[str, int] = {} + category_f1: Dict[str, List[float]] = {} + category_bleu1: Dict[str, List[float]] = {} + category_jaccard: Dict[str, List[float]] = {} + category_locomo_f1: Dict[str, List[float]] = {} + + # Detailed samples + samples: List[Dict[str, Any]] = [] + + # Fixed anchor date for temporal resolution + anchor_date = datetime(2023, 5, 8) + + try: + for idx, item in enumerate(qa_items, 1): + question = item.get("question", "") + ground_truth = item.get("answer", "") + category = get_category_name(item) + + # Ensure ground truth is a string + ground_truth_str = str(ground_truth) if ground_truth is not None else "" + + print(f"[{idx}/{len(qa_items)}] Category: {category}") + print(f"❓ Question: {question}") + print(f"✅ Ground Truth: {ground_truth_str}") + + # Step 4a: Retrieve relevant information + t_search_start = time.time() + try: + retrieved_info = await retrieve_relevant_information( + question=question, + group_id=group_id, + search_type=search_type, + search_limit=search_limit, + connector=connector, + embedder=embedder + ) + t_search_end = time.time() + search_latency = (t_search_end - t_search_start) * 1000 + latencies_search.append(search_latency) + + print(f"🔍 Retrieved {len(retrieved_info)} documents ({search_latency:.1f}ms)") + + except Exception as e: + print(f"❌ Retrieval failed: {e}") + retrieved_info = [] + search_latency = 0.0 + latencies_search.append(search_latency) + + # Step 4b: Select and format context + context_text = select_and_format_information( + retrieved_info=retrieved_info, + question=question, + max_chars=context_char_budget + ) + + # Resolve temporal references + context_text = resolve_temporal_references(context_text, anchor_date) + + # Add reference date to context + if context_text: + context_text = f"Reference date: {anchor_date.date().isoformat()}\n\n{context_text}" + else: + context_text = "No relevant context found." + + # Track context statistics + context_counts.append(len(retrieved_info)) + context_chars.append(len(context_text)) + context_tokens.append(len(context_text.split())) + + print(f"📝 Context: {len(context_text)} chars, {len(retrieved_info)} docs") + + # Step 4c: Generate answer with LLM + messages = [ + { + "role": "system", + "content": ( + "You are a precise QA assistant. Answer following these rules:\n" + "1) Extract the EXACT information mentioned in the context\n" + "2) For time questions: calculate actual dates from relative times\n" + "3) Return ONLY the answer text in simplest form\n" + "4) For dates, use format 'DD Month YYYY' (e.g., '7 May 2023')\n" + "5) If no clear answer found, respond with 'Unknown'" + ) + }, + { + "role": "user", + "content": f"Question: {question}\n\nContext:\n{context_text}" + } + ] + + t_llm_start = time.time() + try: + response = await llm_client.chat(messages=messages) + t_llm_end = time.time() + llm_latency = (t_llm_end - t_llm_start) * 1000 + latencies_llm.append(llm_latency) + + # Extract prediction from response + if hasattr(response, 'content'): + prediction = response.content.strip() + elif isinstance(response, dict): + prediction = response["choices"][0]["message"]["content"].strip() + else: + prediction = "Unknown" + + print(f"🤖 Prediction: {prediction} ({llm_latency:.1f}ms)") + + except Exception as e: + print(f"❌ LLM failed: {e}") + prediction = "Unknown" + llm_latency = 0.0 + latencies_llm.append(llm_latency) + + # Step 4d: Calculate metrics + f1_val = f1_score(prediction, ground_truth_str) + bleu1_val = bleu1(prediction, ground_truth_str) + jaccard_val = jaccard(prediction, ground_truth_str) + + # LoCoMo-specific F1: use multi-answer for category 1 (Multi-Hop) + if item.get("category") == 1: + locomo_f1_val = locomo_multi_f1(prediction, ground_truth_str) + else: + locomo_f1_val = locomo_f1_score(prediction, ground_truth_str) + + # Accumulate metrics + f1_scores.append(f1_val) + bleu1_scores.append(bleu1_val) + jaccard_scores.append(jaccard_val) + locomo_f1_scores.append(locomo_f1_val) + + # Track by category + category_counts[category] = category_counts.get(category, 0) + 1 + category_f1.setdefault(category, []).append(f1_val) + category_bleu1.setdefault(category, []).append(bleu1_val) + category_jaccard.setdefault(category, []).append(jaccard_val) + category_locomo_f1.setdefault(category, []).append(locomo_f1_val) + + print(f"📊 Metrics - F1: {f1_val:.3f}, BLEU-1: {bleu1_val:.3f}, " + f"Jaccard: {jaccard_val:.3f}, LoCoMo F1: {locomo_f1_val:.3f}") + print() + + # Save sample details + samples.append({ + "question": question, + "ground_truth": ground_truth_str, + "prediction": prediction, + "category": category, + "metrics": { + "f1": f1_val, + "bleu1": bleu1_val, + "jaccard": jaccard_val, + "locomo_f1": locomo_f1_val + }, + "retrieval": { + "num_docs": len(retrieved_info), + "context_length": len(context_text) + }, + "timing": { + "search_ms": search_latency, + "llm_ms": llm_latency + } + }) + + finally: + # Close connector + await connector.close() + + # Step 5: Aggregate results + print(f"\n{'='*60}") + print("📊 Aggregating Results") + print(f"{'='*60}\n") + + # Overall metrics + overall_metrics = { + "f1": sum(f1_scores) / max(len(f1_scores), 1) if f1_scores else 0.0, + "bleu1": sum(bleu1_scores) / max(len(bleu1_scores), 1) if bleu1_scores else 0.0, + "jaccard": sum(jaccard_scores) / max(len(jaccard_scores), 1) if jaccard_scores else 0.0, + "locomo_f1": sum(locomo_f1_scores) / max(len(locomo_f1_scores), 1) if locomo_f1_scores else 0.0 + } + + # Per-category metrics + by_category: Dict[str, Dict[str, Any]] = {} + for cat in category_counts: + f1_list = category_f1.get(cat, []) + b1_list = category_bleu1.get(cat, []) + j_list = category_jaccard.get(cat, []) + lf_list = category_locomo_f1.get(cat, []) + + by_category[cat] = { + "count": category_counts[cat], + "f1": sum(f1_list) / max(len(f1_list), 1) if f1_list else 0.0, + "bleu1": sum(b1_list) / max(len(b1_list), 1) if b1_list else 0.0, + "jaccard": sum(j_list) / max(len(j_list), 1) if j_list else 0.0, + "locomo_f1": sum(lf_list) / max(len(lf_list), 1) if lf_list else 0.0 + } + + # Latency statistics + latency = { + "search": latency_stats(latencies_search), + "llm": latency_stats(latencies_llm) + } + + # Context statistics + context_stats = { + "avg_retrieved_docs": sum(context_counts) / max(len(context_counts), 1) if context_counts else 0.0, + "avg_context_chars": sum(context_chars) / max(len(context_chars), 1) if context_chars else 0.0, + "avg_context_tokens": sum(context_tokens) / max(len(context_tokens), 1) if context_tokens else 0.0 + } + + # Build result dictionary + result = { + "dataset": "locomo", + "sample_size": len(qa_items), + "timestamp": datetime.now().isoformat(), + "params": { + "group_id": group_id, + "search_type": search_type, + "search_limit": search_limit, + "context_char_budget": context_char_budget, + "llm_id": SELECTED_LLM_ID, + "embedding_id": SELECTED_EMBEDDING_ID + }, + "overall_metrics": overall_metrics, + "by_category": by_category, + "latency": latency, + "context_stats": context_stats, + "samples": samples + } + + # Step 6: Save results + if output_dir is None: + output_dir = os.path.join( + os.path.dirname(__file__), + "results" + ) + + os.makedirs(output_dir, exist_ok=True) + + # Generate timestamped filename + timestamp_str = datetime.now().strftime("%Y%m%d_%H%M%S") + output_path = os.path.join(output_dir, f"locomo_{timestamp_str}.json") + + try: + with open(output_path, "w", encoding="utf-8") as f: + json.dump(result, f, ensure_ascii=False, indent=2) + print(f"✅ Results saved to: {output_path}\n") + except Exception as e: + print(f"❌ Failed to save results: {e}") + print("📊 Printing results to console instead:\n") + print(json.dumps(result, ensure_ascii=False, indent=2)) + + return result + + +def main(): + """ + Parse command-line arguments and run benchmark. + + This function provides a CLI interface for running LoCoMo benchmarks + with configurable parameters. + """ + parser = argparse.ArgumentParser( + description="Run LoCoMo benchmark evaluation", + formatter_class=argparse.ArgumentDefaultsHelpFormatter + ) + + parser.add_argument( + "--sample_size", + type=int, + default=20, + help="Number of QA pairs to evaluate" + ) + parser.add_argument( + "--group_id", + type=str, + default=None, + help="Database group ID for retrieval (uses default if not specified)" + ) + parser.add_argument( + "--search_type", + type=str, + default="hybrid", + choices=["keyword", "embedding", "hybrid"], + help="Search strategy to use" + ) + parser.add_argument( + "--search_limit", + type=int, + default=12, + help="Maximum number of documents to retrieve per query" + ) + parser.add_argument( + "--context_char_budget", + type=int, + default=8000, + help="Maximum characters for context" + ) + parser.add_argument( + "--reset_group", + action="store_true", + help="Clear and re-ingest data (not implemented)" + ) + parser.add_argument( + "--skip_ingest", + action="store_true", + help="Skip data ingestion and use existing data in Neo4j" + ) + parser.add_argument( + "--output_dir", + type=str, + default=None, + help="Directory to save results (uses default if not specified)" + ) + + args = parser.parse_args() + + # Load environment variables + load_dotenv() + + # Run benchmark + result = asyncio.run(run_locomo_benchmark( + sample_size=args.sample_size, + group_id=args.group_id, + search_type=args.search_type, + search_limit=args.search_limit, + context_char_budget=args.context_char_budget, + reset_group=args.reset_group, + skip_ingest=args.skip_ingest, + output_dir=args.output_dir + )) + + # Print summary + print(f"\n{'='*60}") + + # Check if there was an error + if 'error' in result: + print("❌ Benchmark Failed!") + print(f"{'='*60}") + print(f"Error: {result['error']}") + return + + print("🎉 Benchmark Complete!") + print(f"{'='*60}") + print("📊 Final Results:") + print(f" Sample size: {result.get('sample_size', 0)}") + print(f" F1: {result['overall_metrics']['f1']:.3f}") + print(f" BLEU-1: {result['overall_metrics']['bleu1']:.3f}") + print(f" Jaccard: {result['overall_metrics']['jaccard']:.3f}") + print(f" LoCoMo F1: {result['overall_metrics']['locomo_f1']:.3f}") + + if result.get('context_stats'): + print("\n📈 Context Statistics:") + print(f" Avg retrieved docs: {result['context_stats']['avg_retrieved_docs']:.1f}") + print(f" Avg context chars: {result['context_stats']['avg_context_chars']:.0f}") + print(f" Avg context tokens: {result['context_stats']['avg_context_tokens']:.0f}") + + if result.get('latency'): + print("\n⏱️ Latency Statistics:") + print(f" Search - Mean: {result['latency']['search']['mean']:.1f}ms, " + f"P50: {result['latency']['search']['p50']:.1f}ms, " + f"P95: {result['latency']['search']['p95']:.1f}ms") + print(f" LLM - Mean: {result['latency']['llm']['mean']:.1f}ms, " + f"P50: {result['latency']['llm']['p50']:.1f}ms, " + f"P95: {result['latency']['llm']['p95']:.1f}ms") + + if result.get('by_category'): + print("\n📂 Results by Category:") + for cat, metrics in result['by_category'].items(): + print(f" {cat}:") + print(f" Count: {metrics['count']}") + print(f" F1: {metrics['f1']:.3f}") + print(f" LoCoMo F1: {metrics['locomo_f1']:.3f}") + print(f" Jaccard: {metrics['jaccard']:.3f}") + + print(f"\n{'='*60}\n") + + +if __name__ == "__main__": + main() diff --git a/api/app/core/memory/evaluation/locomo/locomo_metrics.py b/api/app/core/memory/evaluation/locomo/locomo_metrics.py new file mode 100644 index 00000000..20d5f2b5 --- /dev/null +++ b/api/app/core/memory/evaluation/locomo/locomo_metrics.py @@ -0,0 +1,225 @@ +""" +LoCoMo-specific metric calculations. + +This module provides clean, simplified implementations of metrics used for +LoCoMo benchmark evaluation, including text normalization and F1 score variants. +""" + +import re +from typing import Dict, Any + + +def normalize_text(text: str) -> str: + """ + Normalize text for LoCoMo evaluation. + + Normalization steps: + - Convert to lowercase + - Remove commas + - Remove stop words (a, an, the, and) + - Remove punctuation + - Normalize whitespace + + Args: + text: Input text to normalize + + Returns: + Normalized text string with consistent formatting + + Examples: + >>> normalize_text("The cat, and the dog") + 'cat dog' + >>> normalize_text("Hello, World!") + 'hello world' + """ + # Ensure input is a string + text = str(text) if text is not None else "" + + # Convert to lowercase + text = text.lower() + + # Remove commas + text = re.sub(r"[\,]", " ", text) + + # Remove stop words + text = re.sub(r"\b(a|an|the|and)\b", " ", text) + + # Remove punctuation (keep only word characters and whitespace) + text = re.sub(r"[^\w\s]", " ", text) + + # Normalize whitespace (collapse multiple spaces to single space) + text = " ".join(text.split()) + + return text + + +def locomo_f1_score(prediction: str, ground_truth: str) -> float: + """ + Calculate LoCoMo F1 score for single-answer questions. + + Uses token-level precision and recall based on normalized text. + Treats tokens as sets (no duplicate counting). + + Args: + prediction: Model's predicted answer + ground_truth: Correct answer + + Returns: + F1 score between 0.0 and 1.0 + + Examples: + >>> locomo_f1_score("Paris", "Paris") + 1.0 + >>> locomo_f1_score("The cat", "cat") + 1.0 + >>> locomo_f1_score("dog", "cat") + 0.0 + """ + # Ensure inputs are strings + pred_str = str(prediction) if prediction is not None else "" + truth_str = str(ground_truth) if ground_truth is not None else "" + + # Normalize and tokenize + pred_tokens = normalize_text(pred_str).split() + truth_tokens = normalize_text(truth_str).split() + + # Handle empty cases + if not pred_tokens or not truth_tokens: + return 0.0 + + # Convert to sets for comparison + pred_set = set(pred_tokens) + truth_set = set(truth_tokens) + + # Calculate true positives (intersection) + true_positives = len(pred_set & truth_set) + + # Calculate precision and recall + precision = true_positives / len(pred_set) if pred_set else 0.0 + recall = true_positives / len(truth_set) if truth_set else 0.0 + + # Calculate F1 score + if precision + recall == 0: + return 0.0 + + f1 = 2 * precision * recall / (precision + recall) + return f1 + + +def locomo_multi_f1(prediction: str, ground_truth: str) -> float: + """ + Calculate LoCoMo F1 score for multi-answer questions. + + Handles comma-separated answers by: + 1. Splitting both prediction and ground truth by commas + 2. For each ground truth answer, finding the best matching prediction + 3. Averaging the F1 scores across all ground truth answers + + Args: + prediction: Model's predicted answer (may contain multiple comma-separated answers) + ground_truth: Correct answer (may contain multiple comma-separated answers) + + Returns: + Average F1 score across all ground truth answers (0.0 to 1.0) + + Examples: + >>> locomo_multi_f1("Paris, London", "Paris, London") + 1.0 + >>> locomo_multi_f1("Paris", "Paris, London") + 0.5 + >>> locomo_multi_f1("Paris, Berlin", "Paris, London") + 0.5 + """ + # Ensure inputs are strings + pred_str = str(prediction) if prediction is not None else "" + truth_str = str(ground_truth) if ground_truth is not None else "" + + # Split by commas and strip whitespace + predictions = [p.strip() for p in pred_str.split(',') if p.strip()] + ground_truths = [g.strip() for g in truth_str.split(',') if g.strip()] + + # Handle empty cases + if not predictions or not ground_truths: + return 0.0 + + # For each ground truth, find the best matching prediction + f1_scores = [] + for gt in ground_truths: + # Calculate F1 with each prediction and take the maximum + best_f1 = max(locomo_f1_score(pred, gt) for pred in predictions) + f1_scores.append(best_f1) + + # Return average F1 across all ground truths + return sum(f1_scores) / len(f1_scores) + + +def get_category_name(item: Dict[str, Any]) -> str: + """ + Extract and normalize category name from QA item. + + Handles both numeric categories (1-4) and string categories with various formats. + Supports multiple field names: "cat", "category", "type". + + Category mapping: + - 1 or "multi-hop" -> "Multi-Hop" + - 2 or "temporal" -> "Temporal" + - 3 or "open domain" -> "Open Domain" + - 4 or "single-hop" -> "Single-Hop" + + Args: + item: QA item dictionary containing category information + + Returns: + Standardized category name or "unknown" if not found + + Examples: + >>> get_category_name({"category": 1}) + 'Multi-Hop' + >>> get_category_name({"cat": "temporal"}) + 'Temporal' + >>> get_category_name({"type": "Single-Hop"}) + 'Single-Hop' + """ + # Numeric category mapping + CATEGORY_MAP = { + 1: "Multi-Hop", + 2: "Temporal", + 3: "Open Domain", + 4: "Single-Hop", + } + + # String category aliases (case-insensitive) + TYPE_ALIASES = { + "single-hop": "Single-Hop", + "singlehop": "Single-Hop", + "single hop": "Single-Hop", + "multi-hop": "Multi-Hop", + "multihop": "Multi-Hop", + "multi hop": "Multi-Hop", + "open domain": "Open Domain", + "opendomain": "Open Domain", + "temporal": "Temporal", + } + + # Try "cat" field first (string category) + cat = item.get("cat") + if isinstance(cat, str) and cat.strip(): + name = cat.strip() + lower = name.lower() + return TYPE_ALIASES.get(lower, name) + + # Try "category" field (can be int or string) + cat_num = item.get("category") + if isinstance(cat_num, int): + return CATEGORY_MAP.get(cat_num, "unknown") + elif isinstance(cat_num, str) and cat_num.strip(): + lower = cat_num.strip().lower() + return TYPE_ALIASES.get(lower, cat_num.strip()) + + # Try "type" field as fallback + cat_type = item.get("type") + if isinstance(cat_type, str) and cat_type.strip(): + lower = cat_type.strip().lower() + return TYPE_ALIASES.get(lower, cat_type.strip()) + + return "unknown" diff --git a/api/app/core/memory/evaluation/locomo/locomo_test.py b/api/app/core/memory/evaluation/locomo/locomo_test.py new file mode 100644 index 00000000..ad51931a --- /dev/null +++ b/api/app/core/memory/evaluation/locomo/locomo_test.py @@ -0,0 +1,796 @@ +# file name: check_neo4j_connection_fixed.py +import asyncio +import os +import sys +import json +import time +import math +import re +from datetime import datetime, timedelta +from typing import List, Dict, Any +from dotenv import load_dotenv +# 1 +# 添加项目根目录到路径 +current_dir = os.path.dirname(os.path.abspath(__file__)) +project_root = os.path.dirname(current_dir) +if project_root not in sys.path: + sys.path.insert(0, project_root) +# 关键：将 src 目录置于最前，确保从当前仓库加载模块 +src_dir = os.path.join(project_root, "src") +if src_dir not in sys.path: + sys.path.insert(0, src_dir) + +load_dotenv() + +# 首先定义 _loc_normalize 函数，因为其他函数依赖它 +def _loc_normalize(text: str) -> str: + text = str(text) if text is not None else "" + text = text.lower() + text = re.sub(r"[\,]", " ", text) + text = re.sub(r"\b(a|an|the|and)\b", " ", text) + text = re.sub(r"[^\w\s]", " ", text) + text = " ".join(text.split()) + return text + +# 尝试从 metrics.py 导入基础指标 +try: + from common.metrics import f1_score, bleu1, jaccard + print("✅ 从 metrics.py 导入基础指标成功") +except ImportError as e: + print(f"❌ 从 metrics.py 导入失败: {e}") + # 回退到本地实现 + def f1_score(pred: str, ref: str) -> float: + pred_str = str(pred) if pred is not None else "" + ref_str = str(ref) if ref is not None else "" + + p_tokens = _loc_normalize(pred_str).split() + r_tokens = _loc_normalize(ref_str).split() + if not p_tokens and not r_tokens: + return 1.0 + if not p_tokens or not r_tokens: + return 0.0 + p_set = set(p_tokens) + r_set = set(r_tokens) + tp = len(p_set & r_set) + precision = tp / len(p_set) if p_set else 0.0 + recall = tp / len(r_set) if r_set else 0.0 + if precision + recall == 0: + return 0.0 + return 2 * precision * recall / (precision + recall) + + def bleu1(pred: str, ref: str) -> float: + pred_str = str(pred) if pred is not None else "" + ref_str = str(ref) if ref is not None else "" + + p_tokens = _loc_normalize(pred_str).split() + r_tokens = _loc_normalize(ref_str).split() + if not p_tokens: + return 0.0 + + r_counts = {} + for t in r_tokens: + r_counts[t] = r_counts.get(t, 0) + 1 + + clipped = 0 + p_counts = {} + for t in p_tokens: + p_counts[t] = p_counts.get(t, 0) + 1 + + for t, c in p_counts.items(): + clipped += min(c, r_counts.get(t, 0)) + + precision = clipped / max(len(p_tokens), 1) + ref_len = len(r_tokens) + pred_len = len(p_tokens) + + if pred_len > ref_len or pred_len == 0: + bp = 1.0 + else: + bp = math.exp(1 - ref_len / max(pred_len, 1)) + + return bp * precision + + def jaccard(pred: str, ref: str) -> float: + pred_str = str(pred) if pred is not None else "" + ref_str = str(ref) if ref is not None else "" + + p = set(_loc_normalize(pred_str).split()) + r = set(_loc_normalize(ref_str).split()) + if not p and not r: + return 1.0 + if not p or not r: + return 0.0 + return len(p & r) / len(p | r) + +# 尝试从 qwen_search_eval.py 导入 LoCoMo 特定指标 +try: + # 添加 evaluation 目录路径 + evaluation_dir = os.path.join(project_root, "evaluation") + if evaluation_dir not in sys.path: + sys.path.insert(0, evaluation_dir) + + # 尝试从不同位置导入 + try: + from locomo.qwen_search_eval import loc_f1_score, loc_multi_f1, _resolve_relative_times + print("✅ 从 locomo.qwen_search_eval 导入 LoCoMo 特定指标成功") + except ImportError: + from qwen_search_eval import loc_f1_score, loc_multi_f1, _resolve_relative_times + print("✅ 从 qwen_search_eval 导入 LoCoMo 特定指标成功") + +except ImportError as e: + print(f"❌ 从 qwen_search_eval.py 导入失败: {e}") + # 回退到本地实现 LoCoMo 特定函数 + def _resolve_relative_times(text: str, anchor: datetime) -> str: + t = str(text) if text is not None else "" + t = re.sub(r"\btoday\b", anchor.date().isoformat(), t, flags=re.IGNORECASE) + t = re.sub(r"\byesterday\b", (anchor - timedelta(days=1)).date().isoformat(), t, flags=re.IGNORECASE) + t = re.sub(r"\btomorrow\b", (anchor + timedelta(days=1)).date().isoformat(), t, flags=re.IGNORECASE) + + def _ago_repl(m: re.Match[str]) -> str: + n = int(m.group(1)) + return (anchor - timedelta(days=n)).date().isoformat() + def _in_repl(m: re.Match[str]) -> str: + n = int(m.group(1)) + return (anchor + timedelta(days=n)).date().isoformat() + + t = re.sub(r"\b(\d+)\s+days\s+ago\b", _ago_repl, t, flags=re.IGNORECASE) + t = re.sub(r"\bin\s+(\d+)\s+days\b", _in_repl, t, flags=re.IGNORECASE) + t = re.sub(r"\blast\s+week\b", (anchor - timedelta(days=7)).date().isoformat(), t, flags=re.IGNORECASE) + t = re.sub(r"\bnext\s+week\b", (anchor + timedelta(days=7)).date().isoformat(), t, flags=re.IGNORECASE) + return t + + def loc_f1_score(prediction: str, ground_truth: str) -> float: + p_tokens = _loc_normalize(prediction).split() + g_tokens = _loc_normalize(ground_truth).split() + if not p_tokens or not g_tokens: + return 0.0 + p = set(p_tokens) + g = set(g_tokens) + tp = len(p & g) + precision = tp / len(p) if p else 0.0 + recall = tp / len(g) if g else 0.0 + return (2 * precision * recall / (precision + recall)) if (precision + recall) > 0 else 0.0 + + def loc_multi_f1(prediction: str, ground_truth: str) -> float: + predictions = [p.strip() for p in str(prediction).split(',') if p.strip()] + ground_truths = [g.strip() for g in str(ground_truth).split(',') if g.strip()] + if not predictions or not ground_truths: + return 0.0 + def _f1(a: str, b: str) -> float: + return loc_f1_score(a, b) + vals = [] + for gt in ground_truths: + vals.append(max(_f1(pred, gt) for pred in predictions)) + return sum(vals) / len(vals) + + +def smart_context_selection(contexts: List[str], question: str, max_chars: int = 8000) -> str: + """基于问题关键词智能选择上下文""" + if not contexts: + return "" + + # 提取问题关键词（只保留有意义的词） + question_lower = question.lower() + stop_words = {'what', 'when', 'where', 'who', 'why', 'how', 'did', 'do', 'does', 'is', 'are', 'was', 'were', 'the', 'a', 'an', 'and', 'or', 'but'} + question_words = set(re.findall(r'\b\w+\b', question_lower)) + question_words = {word for word in question_words if word not in stop_words and len(word) > 2} + + print(f"🔍 问题关键词: {question_words}") + + # 给每个上下文打分 + scored_contexts = [] + for i, context in enumerate(contexts): + context_lower = context.lower() + score = 0 + + # 关键词匹配得分 + keyword_matches = 0 + for word in question_words: + if word in context_lower: + keyword_matches += 1 + # 关键词出现次数越多，得分越高 + score += context_lower.count(word) * 2 + + # 上下文长度得分（适中的长度更好） + context_len = len(context) + if 100 < context_len < 2000: # 理想长度范围 + score += 5 + elif context_len >= 2000: # 太长可能包含无关信息 + score += 2 + + # 如果是前几个上下文，给予额外分数（通常相关性更高） + if i < 3: + score += 3 + + scored_contexts.append((score, context, keyword_matches)) + + # 按得分排序 + scored_contexts.sort(key=lambda x: x[0], reverse=True) + + # 选择高得分的上下文，直到达到字符限制 + selected = [] + total_chars = 0 + selected_count = 0 + + print("📊 上下文相关性分析:") + for score, context, matches in scored_contexts[:5]: # 只显示前5个 + print(f" - 得分: {score}, 关键词匹配: {matches}, 长度: {len(context)}") + + for score, context, matches in scored_contexts: + if total_chars + len(context) <= max_chars: + selected.append(context) + total_chars += len(context) + selected_count += 1 + else: + # 如果这个上下文得分很高但放不下，尝试截取 + if score > 10 and total_chars < max_chars - 500: + remaining = max_chars - total_chars + # 找到包含关键词的部分 + lines = context.split('\n') + relevant_lines = [] + current_chars = 0 + + for line in lines: + line_lower = line.lower() + line_relevance = any(word in line_lower for word in question_words) + + if line_relevance and current_chars < remaining - 100: + relevant_lines.append(line) + current_chars += len(line) + + if relevant_lines: + truncated = '\n'.join(relevant_lines) + if len(truncated) > 100: # 确保有足够内容 + selected.append(truncated + "\n[相关内容截断...]") + total_chars += len(truncated) + selected_count += 1 + break # 不再尝试添加更多上下文 + + result = "\n\n".join(selected) + print(f"✅ 智能选择: {selected_count}个上下文, 总长度: {total_chars}字符") + return result + + +def get_dynamic_search_params(question: str, question_index: int, total_questions: int): + """根据问题复杂度和进度动态调整检索参数""" + + # 分析问题复杂度 + word_count = len(question.split()) + has_temporal = any(word in question.lower() for word in ['when', 'date', 'time', 'ago']) + has_multi_hop = any(word in question.lower() for word in ['and', 'both', 'also', 'while']) + + # 根据进度调整 - 后期问题可能需要更精确的检索 + progress_factor = question_index / total_questions + + base_limit = 12 + if has_temporal and has_multi_hop: + base_limit = 20 + elif word_count > 8: + base_limit = 16 + + # 随着测试进行，逐渐收紧检索范围 + adjusted_limit = max(8, int(base_limit * (1 - progress_factor * 0.3))) + + # 动态调整最大字符数 + max_chars = 8000 + 4000 * (1 - progress_factor) + + return { + "limit": adjusted_limit, + "max_chars": int(max_chars) + } + + +class EnhancedEvaluationMonitor: + def __init__(self, reset_interval=5, performance_threshold=0.6): + self.question_count = 0 + self.reset_interval = reset_interval + self.performance_threshold = performance_threshold + self.consecutive_low_scores = 0 + self.performance_history = [] + self.recent_f1_scores = [] + + def should_reset_connections(self, current_f1=None): + """基于计数和性能双重判断""" + # 定期重置 + if self.question_count % self.reset_interval == 0: + return True + + # 性能驱动的重置 + if current_f1 is not None and current_f1 < self.performance_threshold: + self.consecutive_low_scores += 1 + if self.consecutive_low_scores >= 2: # 连续2个低分就重置 + print("🚨 连续低分，触发紧急重置") + self.consecutive_low_scores = 0 + return True + else: + self.consecutive_low_scores = 0 + + return False + + def record_performance(self, question_index, metrics, context_length, retrieved_docs): + """记录性能指标，检测衰减""" + self.performance_history.append({ + 'index': question_index, + 'metrics': metrics, + 'context_length': context_length, + 'retrieved_docs': retrieved_docs, + 'timestamp': time.time() + }) + + # 记录最近的F1分数 + self.recent_f1_scores.append(metrics['f1']) + if len(self.recent_f1_scores) > 5: + self.recent_f1_scores.pop(0) + + def get_recent_performance(self): + """获取近期平均性能""" + if not self.recent_f1_scores: + return 0.5 + return sum(self.recent_f1_scores) / len(self.recent_f1_scores) + + def get_performance_trend(self): + """分析性能趋势""" + if len(self.performance_history) < 2: + return "stable" + + recent_metrics = [item['metrics']['f1'] for item in self.performance_history[-5:]] + earlier_metrics = [item['metrics']['f1'] for item in self.performance_history[-10:-5]] + + if len(recent_metrics) < 2 or len(earlier_metrics) < 2: + return "stable" + + recent_avg = sum(recent_metrics) / len(recent_metrics) + earlier_avg = sum(earlier_metrics) / len(earlier_metrics) + + if recent_avg < earlier_avg * 0.8: + return "degrading" + elif recent_avg > earlier_avg * 1.1: + return "improving" + else: + return "stable" + + +def get_enhanced_search_params(question: str, question_index: int, total_questions: int, recent_performance: float): + """基于问题复杂度和近期性能动态调整检索参数""" + + # 基础参数 + base_params = get_dynamic_search_params(question, question_index, total_questions) + + # 性能自适应调整 + if recent_performance < 0.5: # 近期表现差 + # 增加检索范围，尝试获取更多上下文 + base_params["limit"] = min(base_params["limit"] + 5, 25) + base_params["max_chars"] = min(base_params["max_chars"] + 2000, 12000) + print(f"📈 性能自适应：增加检索范围 (limit={base_params['limit']}, max_chars={base_params['max_chars']})") + + elif recent_performance > 0.8: # 近期表现好 + # 收紧检索，提高精度 + base_params["limit"] = max(base_params["limit"] - 2, 8) + base_params["max_chars"] = max(base_params["max_chars"] - 1000, 6000) + print(f"🎯 性能自适应：提高检索精度 (limit={base_params['limit']}, max_chars={base_params['max_chars']})") + + # 中间阶段特殊处理 + mid_sequence_factor = abs(question_index / total_questions - 0.5) + if mid_sequence_factor < 0.2: # 在中间30%的问题 + print("🎯 中间阶段：使用更精确的检索策略") + base_params["limit"] = max(base_params["limit"] - 2, 10) # 减少数量，提高质量 + base_params["max_chars"] = max(base_params["max_chars"] - 1000, 7000) + + return base_params + + +def enhanced_context_selection(contexts: List[str], question: str, question_index: int, total_questions: int, max_chars: int = 8000) -> str: + """考虑问题序列位置的智能选择""" + + if not contexts: + return "" + + # 在序列中间阶段使用更严格的筛选 + mid_sequence_factor = abs(question_index / total_questions - 0.5) # 距离中心的距离 + + if mid_sequence_factor < 0.2: # 在中间30%的问题 + print("🎯 中间阶段：使用严格上下文筛选") + + # 提取问题关键词 + question_lower = question.lower() + stop_words = {'what', 'when', 'where', 'who', 'why', 'how', 'did', 'do', 'does', 'is', 'are', 'was', 'were', 'the', 'a', 'an', 'and', 'or', 'but'} + question_words = set(re.findall(r'\b\w+\b', question_lower)) + question_words = {word for word in question_words if word not in stop_words and len(word) > 2} + + # 只保留高度相关的上下文 + filtered_contexts = [] + for context in contexts: + context_lower = context.lower() + relevance_score = sum(3 if word in context_lower else 0 for word in question_words) + + # 额外加分给包含数字、日期的上下文（对事实性问题更重要） + if any(char.isdigit() for char in context): + relevance_score += 2 + + # 提高阈值：只有得分>=3的上下文才保留 + if relevance_score >= 3: + filtered_contexts.append(context) + else: + print(f" - 过滤低分上下文: 得分={relevance_score}") + + contexts = filtered_contexts + print(f"🔍 严格筛选后保留 {len(contexts)} 个上下文") + + # 使用原有的智能选择逻辑 + return smart_context_selection(contexts, question, max_chars) + + +async def run_enhanced_evaluation(): + """使用增强方法进行完整评估 - 解决中间性能衰减问题""" + try: + from dotenv import load_dotenv + except Exception: + def load_dotenv(): + return None + + # 修正导入路径：使用 app.core.memory.src 前缀 + from app.repositories.neo4j.neo4j_connector import Neo4jConnector + from app.repositories.neo4j.graph_search import search_graph_by_embedding + from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient + from app.core.models.base import RedBearModelConfig + from app.core.memory.utils.llm.llm_utils import get_llm_client + from app.core.memory.utils.config.config_utils import get_embedder_config + from app.core.memory.utils.config.definitions import SELECTED_LLM_ID, SELECTED_EMBEDDING_ID + + # 加载数据 + # 获取项目根目录 + current_file = os.path.abspath(__file__) + evaluation_dir = os.path.dirname(os.path.dirname(current_file)) # evaluation目录 + memory_dir = os.path.dirname(evaluation_dir) # memory目录 + data_path = os.path.join(memory_dir, "data", "locomo10.json") + with open(data_path, "r", encoding="utf-8") as f: + raw = json.load(f) + + qa_items = [] + if isinstance(raw, list): + for entry in raw: + qa_items.extend(entry.get("qa", [])) + else: + qa_items.extend(raw.get("qa", [])) + + items = qa_items[:20] # 测试多少个问题 + + # 初始化增强监控器 + monitor = EnhancedEvaluationMonitor(reset_interval=5, performance_threshold=0.6) + + llm = get_llm_client(SELECTED_LLM_ID) + + # 初始化embedder + cfg_dict = get_embedder_config(SELECTED_EMBEDDING_ID) + embedder = OpenAIEmbedderClient( + model_config=RedBearModelConfig.model_validate(cfg_dict) + ) + + # 初始化连接器 + connector = Neo4jConnector() + + # 初始化结果字典 + results = { + "questions": [], + "overall_metrics": {"f1": 0.0, "b1": 0.0, "j": 0.0, "loc_f1": 0.0}, + "category_metrics": {}, + "retrieval_stats": {"total_questions": len(items), "avg_context_length": 0, "avg_retrieved_docs": 0}, + "performance_trend": "stable", + "timestamp": datetime.now().isoformat(), + "enhanced_strategy": True + } + + total_f1 = 0.0 + total_bleu1 = 0.0 + total_jaccard = 0.0 + total_loc_f1 = 0.0 + total_context_length = 0 + total_retrieved_docs = 0 + category_stats = {} + + try: + for i, item in enumerate(items): + monitor.question_count += 1 + + # 获取近期性能用于重置判断 + recent_performance = monitor.get_recent_performance() + + # 增强的重置判断 + should_reset = monitor.should_reset_connections(current_f1=recent_performance) + if should_reset and i > 0: + print(f"🔄 重置Neo4j连接 (问题 {i+1}/{len(items)}, 近期性能: {recent_performance:.3f})...") + await connector.close() + connector = Neo4jConnector() # 创建新连接 + print("✅ 连接重置完成") + + q = item.get("question", "") + ref = item.get("answer", "") + ref_str = str(ref) if ref is not None else "" + + print(f"\n🔍 [{i+1}/{len(items)}] 问题: {q}") + print(f"✅ 真实答案: {ref_str}") + + # 分类别统计 + category = "Unknown" + if item.get("category") == 1: + category = "Multi-Hop" + elif item.get("category") == 2: + category = "Temporal" + elif item.get("category") == 3: + category = "Open Domain" + elif item.get("category") == 4: + category = "Single-Hop" + + # 增强的检索参数 + search_params = get_enhanced_search_params(q, i, len(items), recent_performance) + search_limit = search_params["limit"] + max_chars = search_params["max_chars"] + + print(f"🏷️ 类别: {category}, 检索参数: limit={search_limit}, max_chars={max_chars}") + + # 使用项目标准的混合检索方法 + t0 = time.time() + contexts_all = [] + + try: + # 使用统一的搜索服务 + from app.core.memory.storage_services.search import run_hybrid_search + + print("🔀 使用混合搜索服务...") + + search_results = await run_hybrid_search( + query_text=q, + search_type="hybrid", + group_id="locomo_sk", + limit=20, + include=["statements", "chunks", "entities", "summaries"], + alpha=0.6, # BM25权重 + embedding_id=SELECTED_EMBEDDING_ID + ) + + # 处理搜索结果 - 新的搜索服务返回统一的结构 + chunks = search_results.get("chunks", []) + statements = search_results.get("statements", []) + entities = search_results.get("entities", []) + summaries = search_results.get("summaries", []) + + print(f"✅ 混合检索成功: {len(chunks)} chunks, {len(statements)} 条陈述, {len(entities)} 个实体, {len(summaries)} 个摘要") + + # 构建上下文：优先使用 chunks、statements 和 summaries + for c in chunks: + content = str(c.get("content", "")).strip() + if content: + contexts_all.append(content) + + for s in statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + + for sm in summaries: + summary_text = str(sm.get("summary", "")).strip() + if summary_text: + contexts_all.append(summary_text) + + # 实体摘要：最多加入前3个高分实体，避免噪声 + scored = [e for e in entities if e.get("score") is not None] + top_entities = sorted(scored, key=lambda x: x.get("score", 0), reverse=True)[:3] if scored else entities[:3] + if top_entities: + summary_lines = [] + for e in top_entities: + name = str(e.get("name", "")).strip() + etype = str(e.get("entity_type", "")).strip() + score = e.get("score") + if name: + meta = [] + if etype: + meta.append(f"type={etype}") + if isinstance(score, (int, float)): + meta.append(f"score={score:.3f}") + summary_lines.append(f"EntitySummary: {name}{(' [' + ' '.join(meta) + ']') if meta else ''}") + if summary_lines: + contexts_all.append("\n".join(summary_lines)) + + print(f"📊 有效上下文数量: {len(contexts_all)}") + except Exception as e: + print(f"❌ 检索失败: {e}") + contexts_all = [] + + t1 = time.time() + search_time = (t1 - t0) * 1000 + + # 增强的上下文选择 + context_text = "" + if contexts_all: + # 使用增强的上下文选择 + context_text = enhanced_context_selection(contexts_all, q, i, len(items), max_chars=max_chars) + + # 如果智能选择后仍然过长，进行最终保护性截断 + if len(context_text) > max_chars: + print(f"⚠️ 智能选择后仍然过长 ({len(context_text)}字符)，进行最终截断") + context_text = context_text[:max_chars] + "\n\n[最终截断...]" + + # 时间解析 + anchor_date = datetime(2023, 5, 8) # 使用固定日期确保一致性 + context_text = _resolve_relative_times(context_text, anchor_date) + + context_text = f"Reference date: {anchor_date.date().isoformat()}\n\n" + context_text + + print(f"📝 最终上下文长度: {len(context_text)} 字符") + + # 显示不同上下文的预览（不只是第一条） + print("🔍 上下文预览:") + for j, context in enumerate(contexts_all[:3]): # 显示前3个上下文 + preview = context[:150].replace('\n', ' ') + print(f" 上下文{j+1}: {preview}...") + + # 🔍 调试：检查答案是否在上下文中 + if ref_str and ref_str.strip(): + answer_found = any(ref_str.lower() in ctx.lower() for ctx in contexts_all) + print(f"🔍 调试：答案 '{ref_str}' 是否在检索到的上下文中？ {'✅ 是' if answer_found else '❌ 否'}") + + else: + print("❌ 没有检索到有效上下文") + context_text = "No relevant context found." + + # LLM 回答 + messages = [ + {"role": "system", "content": ( + "You are a precise QA assistant. Answer following these rules:\n" + "1) Extract the EXACT information mentioned in the context\n" + "2) For time questions: calculate actual dates from relative times\n" + "3) Return ONLY the answer text in simplest form\n" + "4) For dates, use format 'DD Month YYYY' (e.g., '7 May 2023')\n" + "5) If no clear answer found, respond with 'Unknown'" + )}, + {"role": "user", "content": f"Question: {q}\n\nContext:\n{context_text}"}, + ] + + t2 = time.time() + try: + # 使用异步调用 + resp = await llm.chat(messages=messages) + # 兼容不同的响应格式 + pred = resp.content.strip() if hasattr(resp, 'content') else (resp["choices"][0]["message"]["content"].strip() if isinstance(resp, dict) else "Unknown") + except Exception as e: + print(f"❌ LLM 生成失败: {e}") + pred = "Unknown" + t3 = time.time() + llm_time = (t3 - t2) * 1000 + + # 计算指标 - 使用导入的指标函数 + f1_val = f1_score(pred, ref_str) + bleu1_val = bleu1(pred, ref_str) + jaccard_val = jaccard(pred, ref_str) + loc_f1_val = loc_f1_score(pred, ref_str) + + print(f"🤖 LLM 回答: {pred}") + print(f"📈 指标 - F1: {f1_val:.3f}, BLEU-1: {bleu1_val:.3f}, Jaccard: {jaccard_val:.3f}, LoCoMo F1: {loc_f1_val:.3f}") + print(f"⏱️ 时间 - 检索: {search_time:.1f}ms, LLM: {llm_time:.1f}ms") + + # 更新统计 + total_f1 += f1_val + total_bleu1 += bleu1_val + total_jaccard += jaccard_val + total_loc_f1 += loc_f1_val + total_context_length += len(context_text) + total_retrieved_docs += len(contexts_all) + + if category not in category_stats: + category_stats[category] = {"count": 0, "f1_sum": 0.0, "b1_sum": 0.0, "j_sum": 0.0, "loc_f1_sum": 0.0} + + category_stats[category]["count"] += 1 + category_stats[category]["f1_sum"] += f1_val + category_stats[category]["b1_sum"] += bleu1_val + category_stats[category]["j_sum"] += jaccard_val + category_stats[category]["loc_f1_sum"] += loc_f1_val + + # 记录性能指标 + metrics = {"f1": f1_val, "bleu1": bleu1_val, "jaccard": jaccard_val, "loc_f1": loc_f1_val} + monitor.record_performance(i, metrics, len(context_text), len(contexts_all)) + + # 保存结果 + question_result = { + "question": q, + "ground_truth": ref_str, + "prediction": pred, + "category": category, + "metrics": metrics, + "retrieval": { + "retrieved_documents": len(contexts_all), + "context_length": len(context_text), + "search_limit": search_limit, + "max_chars": max_chars, + "recent_performance": recent_performance + }, + "timing": { + "search_ms": search_time, + "llm_ms": llm_time + } + } + + results["questions"].append(question_result) + + print("="*60) + + except Exception as e: + print(f"❌ 评估过程中发生错误: {e}") + # 即使出错，也返回已有的结果 + import traceback + traceback.print_exc() + + finally: + await connector.close() + + # 计算总体指标 + n = len(items) + if n > 0: + results["overall_metrics"] = { + "f1": total_f1 / n, + "b1": total_bleu1 / n, + "j": total_jaccard / n, + "loc_f1": total_loc_f1 / n + } + + for category, stats in category_stats.items(): + count = stats["count"] + results["category_metrics"][category] = { + "count": count, + "f1": stats["f1_sum"] / count, + "bleu1": stats["b1_sum"] / count, + "jaccard": stats["j_sum"] / count, + "loc_f1": stats["loc_f1_sum"] / count + } + + results["retrieval_stats"]["avg_context_length"] = total_context_length / n + results["retrieval_stats"]["avg_retrieved_docs"] = total_retrieved_docs / n + + # 分析性能趋势 + results["performance_trend"] = monitor.get_performance_trend() + results["reset_interval"] = monitor.reset_interval + results["total_questions_processed"] = monitor.question_count + + return results + + +if __name__ == "__main__": + print("🚀 运行增强版完整评估（解决中间性能衰减问题）...") + print("📋 增强特性:") + print(" - 双重重置策略：定期重置 + 性能驱动重置") + print(" - 动态检索参数：基于近期性能自适应调整") + print(" - 中间阶段严格筛选：提高上下文质量要求") + print(" - 连续性能监控：实时检测性能衰减") + + result = asyncio.run(run_enhanced_evaluation()) + + print("\n📊 最终评估结果:") + print("总体指标:") + print(f" F1: {result['overall_metrics']['f1']:.4f}") + print(f" BLEU-1: {result['overall_metrics']['b1']:.4f}") + print(f" Jaccard: {result['overall_metrics']['j']:.4f}") + print(f" LoCoMo F1: {result['overall_metrics']['loc_f1']:.4f}") + + print("\n分类别指标:") + for category, metrics in result['category_metrics'].items(): + print(f" {category}: F1={metrics['f1']:.4f}, BLEU-1={metrics['bleu1']:.4f}, Jaccard={metrics['jaccard']:.4f}, LoCoMo F1={metrics['loc_f1']:.4f} (样本数: {metrics['count']})") + + print("\n检索统计:") + stats = result['retrieval_stats'] + print(f" 平均上下文长度: {stats['avg_context_length']:.0f} 字符") + print(f" 平均检索文档数: {stats['avg_retrieved_docs']:.1f}") + + print(f"\n性能趋势: {result['performance_trend']}") + print(f"重置间隔: 每{result['reset_interval']}个问题") + print(f"处理问题总数: {result['total_questions_processed']}") + print(f"增强策略: {'启用' if result.get('enhanced_strategy', False) else '未启用'}") + + + # 保存结果到指定目录 + # 使用代码文件所在目录的绝对路径 + current_file_dir = os.path.dirname(os.path.abspath(__file__)) + output_dir = os.path.join(current_file_dir, "results") + os.makedirs(output_dir, exist_ok=True) + output_file = os.path.join(output_dir, "enhanced_evaluation_results.json") + with open(output_file, "w", encoding="utf-8") as f: + json.dump(result, f, ensure_ascii=False, indent=2) + print(f"\n详细结果已保存到: {output_file}") diff --git a/api/app/core/memory/evaluation/locomo/locomo_utils.py b/api/app/core/memory/evaluation/locomo/locomo_utils.py new file mode 100644 index 00000000..69be5da9 --- /dev/null +++ b/api/app/core/memory/evaluation/locomo/locomo_utils.py @@ -0,0 +1,626 @@ +""" +LoCoMo Utilities Module + +This module provides helper functions for the LoCoMo benchmark evaluation: +- Data loading from JSON files +- Conversation extraction for ingestion +- Temporal reference resolution +- Context selection and formatting +- Retrieval wrapper functions +- Ingestion wrapper functions +""" + +import os +import json +import re +from datetime import datetime, timedelta +from typing import List, Dict, Any, Optional + +from app.core.memory.utils.definitions import PROJECT_ROOT +from app.core.memory.evaluation.extraction_utils import ingest_contexts_via_full_pipeline + + +def load_locomo_data( + data_path: str, + sample_size: int, + conversation_index: int = 0 +) -> List[Dict[str, Any]]: + """ + Load LoCoMo dataset from JSON file. + + The LoCoMo dataset structure is a list of conversation objects, where each + object contains a "qa" list of question-answer pairs. + + Args: + data_path: Path to locomo10.json file + sample_size: Number of QA pairs to load (limits total QA items returned) + conversation_index: Which conversation to load QA pairs from (default: 0 for first) + + Returns: + List of QA item dictionaries, each containing: + - question: str + - answer: str + - category: int (1-4) + - evidence: List[str] + + Raises: + FileNotFoundError: If data_path does not exist + json.JSONDecodeError: If file is not valid JSON + IndexError: If conversation_index is out of range + """ + if not os.path.exists(data_path): + raise FileNotFoundError(f"LoCoMo data file not found: {data_path}") + + with open(data_path, "r", encoding="utf-8") as f: + raw = json.load(f) + + # LoCoMo data structure: list of objects, each with a "qa" list + qa_items: List[Dict[str, Any]] = [] + + if isinstance(raw, list): + # Only load QA pairs from the specified conversation + if conversation_index < len(raw): + entry = raw[conversation_index] + if isinstance(entry, dict) and "qa" in entry: + qa_items.extend(entry.get("qa", [])) + else: + raise IndexError( + f"Conversation index {conversation_index} out of range. " + f"Dataset has {len(raw)} conversations." + ) + else: + # Fallback: single object with qa list + if conversation_index == 0: + qa_items.extend(raw.get("qa", [])) + else: + raise IndexError( + f"Conversation index {conversation_index} out of range. " + f"Dataset has only 1 conversation." + ) + + # Return only the requested sample size + return qa_items[:sample_size] + + +def extract_conversations(data_path: str, max_dialogues: int = 1) -> List[str]: + """ + Extract conversation texts from LoCoMo data for ingestion. + + This function extracts the raw conversation dialogues from the LoCoMo dataset + so they can be ingested into the memory system. Each conversation is formatted + as a multi-line string with "role: message" format. + + Args: + data_path: Path to locomo10.json file + max_dialogues: Maximum number of dialogues to extract (default: 1) + + Returns: + List of conversation strings formatted for ingestion. + Each string contains multiple lines in format "role: message" + + Example output: + [ + "User: I went to the store yesterday.\\nAI: What did you buy?\\n...", + "User: I love hiking.\\nAI: Where do you like to hike?\\n..." + ] + """ + if not os.path.exists(data_path): + raise FileNotFoundError(f"LoCoMo data file not found: {data_path}") + + with open(data_path, "r", encoding="utf-8") as f: + raw = json.load(f) + + # Ensure we have a list of entries + entries = raw if isinstance(raw, list) else [raw] + + contents: List[str] = [] + + for i, entry in enumerate(entries[:max_dialogues]): + if not isinstance(entry, dict): + continue + + conv = entry.get("conversation", {}) + + if not isinstance(conv, dict): + continue + + lines: List[str] = [] + + # Collect all session_* messages + for key, val in sorted(conv.items()): + if isinstance(val, list) and key.startswith("session_"): + for msg in val: + if not isinstance(msg, dict): + continue + + role = msg.get("speaker") or "User" + text = msg.get("text") or "" + text = str(text).strip() + + if not text: + continue + + lines.append(f"{role}: {text}") + + if lines: + contents.append("\n".join(lines)) + + return contents + + +def resolve_temporal_references(text: str, anchor_date: datetime) -> str: + """ + Resolve relative temporal references to absolute dates. + + This function converts relative time expressions (like "today", "yesterday", + "3 days ago") into absolute ISO date strings based on an anchor date. + + Supported patterns: + - today, yesterday, tomorrow + - X days ago, in X days + - last week, next week + + Args: + text: Text containing temporal references + anchor_date: Reference date for resolution (datetime object) + + Returns: + Text with temporal references replaced by ISO dates (YYYY-MM-DD format) + + Example: + >>> anchor = datetime(2023, 5, 8) + >>> resolve_temporal_references("I saw him yesterday", anchor) + "I saw him 2023-05-07" + """ + # Ensure input is a string + t = str(text) if text is not None else "" + + # today / yesterday / tomorrow + t = re.sub( + r"\btoday\b", + anchor_date.date().isoformat(), + t, + flags=re.IGNORECASE + ) + t = re.sub( + r"\byesterday\b", + (anchor_date - timedelta(days=1)).date().isoformat(), + t, + flags=re.IGNORECASE + ) + t = re.sub( + r"\btomorrow\b", + (anchor_date + timedelta(days=1)).date().isoformat(), + t, + flags=re.IGNORECASE + ) + + # X days ago + def _ago_repl(m: re.Match[str]) -> str: + n = int(m.group(1)) + return (anchor_date - timedelta(days=n)).date().isoformat() + + # in X days + def _in_repl(m: re.Match[str]) -> str: + n = int(m.group(1)) + return (anchor_date + timedelta(days=n)).date().isoformat() + + t = re.sub( + r"\b(\d+)\s+days?\s+ago\b", + _ago_repl, + t, + flags=re.IGNORECASE + ) + t = re.sub( + r"\bin\s+(\d+)\s+days?\b", + _in_repl, + t, + flags=re.IGNORECASE + ) + + # last week / next week (approximate as 7 days) + t = re.sub( + r"\blast\s+week\b", + (anchor_date - timedelta(days=7)).date().isoformat(), + t, + flags=re.IGNORECASE + ) + t = re.sub( + r"\bnext\s+week\b", + (anchor_date + timedelta(days=7)).date().isoformat(), + t, + flags=re.IGNORECASE + ) + + return t + + +def select_and_format_information( + retrieved_info: List[str], + question: str, + max_chars: int = 8000 +) -> str: + """ + Intelligently select and format most relevant retrieved information for LLM prompt. + + This function scores each piece of retrieved information based on keyword matching + with the question, then selects the highest-scoring pieces up to the character limit. + + Scoring criteria: + - Keyword matches (higher weight for multiple occurrences) + - Context length (moderate length preferred) + - Position (earlier contexts get bonus points) + + Args: + retrieved_info: List of retrieved information strings (chunks, statements, entities) + question: Question being answered + max_chars: Maximum total characters to include in final prompt + + Returns: + Formatted string combining the most relevant information for LLM prompt. + Contexts are separated by double newlines. + + Example: + >>> contexts = ["Alice went to Paris", "Bob likes pizza", "Alice visited the Eiffel Tower"] + >>> question = "Where did Alice go?" + >>> select_and_format_information(contexts, question, max_chars=100) + "Alice went to Paris\\n\\nAlice visited the Eiffel Tower" + """ + if not retrieved_info: + return "" + + # Extract question keywords (filter out stop words and short words) + question_lower = question.lower() + stop_words = { + 'what', 'when', 'where', 'who', 'why', 'how', + 'did', 'do', 'does', 'is', 'are', 'was', 'were', + 'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at' + } + question_words = set(re.findall(r'\b\w+\b', question_lower)) + question_words = { + word for word in question_words + if word not in stop_words and len(word) > 2 + } + + # Score each context + scored_contexts = [] + for i, context in enumerate(retrieved_info): + context_lower = context.lower() + score = 0 + + # Keyword matching score + keyword_matches = 0 + for word in question_words: + if word in context_lower: + keyword_matches += 1 + # Multiple occurrences increase score + score += context_lower.count(word) * 2 + + # Length score (prefer moderate length) + context_len = len(context) + if 100 < context_len < 2000: + score += 5 + elif context_len >= 2000: + score += 2 + + # Position bonus (earlier contexts often more relevant) + if i < 3: + score += 3 + + scored_contexts.append((score, context, keyword_matches)) + + # Sort by score (descending) + scored_contexts.sort(key=lambda x: x[0], reverse=True) + + # Select contexts up to character limit + selected = [] + total_chars = 0 + + for score, context, matches in scored_contexts: + if total_chars + len(context) <= max_chars: + selected.append(context) + total_chars += len(context) + else: + # Try to include high-scoring context by truncating + if score > 10 and total_chars < max_chars - 500: + remaining = max_chars - total_chars + # Find lines with keywords + lines = context.split('\n') + relevant_lines = [] + current_chars = 0 + + for line in lines: + line_lower = line.lower() + line_relevance = any(word in line_lower for word in question_words) + + if line_relevance and current_chars < remaining - 100: + relevant_lines.append(line) + current_chars += len(line) + + if relevant_lines and len('\n'.join(relevant_lines)) > 100: + truncated = '\n'.join(relevant_lines) + selected.append(truncated + "\n[Content truncated...]") + total_chars += len(truncated) + break + + return "\n\n".join(selected) + + +async def retrieve_relevant_information( + question: str, + group_id: str, + search_type: str, + search_limit: int, + connector: Any, + embedder: Any +) -> List[str]: + """ + Retrieve relevant information from memory graph for a question. + + This function searches the Neo4j memory graph (populated during ingestion) and + returns relevant chunks, statements, and entity information that might help + answer the question. + + The function supports three search types: + - "keyword": Full-text search using Cypher queries + - "embedding": Vector similarity search using embeddings + - "hybrid": Combination of keyword and embedding search with reranking + + Args: + question: Question to search for + group_id: Database group ID (identifies which conversation memory to search) + search_type: "keyword", "embedding", or "hybrid" + search_limit: Max memory pieces to retrieve + connector: Neo4j connector instance + embedder: Embedder client instance + + Returns: + List of text strings (chunks, statements, entity summaries) from memory graph. + Each string represents a piece of retrieved information. + + Raises: + Exception: If search fails (caught and returns empty list) + """ + from app.repositories.neo4j.graph_search import ( + search_graph, + search_graph_by_embedding + ) + from app.core.memory.storage_services.search import run_hybrid_search + + contexts_all: List[str] = [] + + try: + if search_type == "embedding": + # Embedding-based search + search_results = await search_graph_by_embedding( + connector=connector, + embedder_client=embedder, + query_text=question, + group_id=group_id, + limit=search_limit, + include=["chunks", "statements", "entities", "summaries"], + ) + + chunks = search_results.get("chunks", []) + statements = search_results.get("statements", []) + entities = search_results.get("entities", []) + summaries = search_results.get("summaries", []) + + # Build context from chunks + for c in chunks: + content = str(c.get("content", "")).strip() + if content: + contexts_all.append(content) + + # Add statements + for s in statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + + # Add summaries + for sm in summaries: + summary_text = str(sm.get("summary", "")).strip() + if summary_text: + contexts_all.append(summary_text) + + # Add top entities (limit to 3 to avoid noise) + if entities: + scored = [e for e in entities if e.get("score") is not None] + top_entities = ( + sorted(scored, key=lambda x: x.get("score", 0), reverse=True)[:3] + if scored else entities[:3] + ) + if top_entities: + summary_lines = [] + for e in top_entities: + name = str(e.get("name", "")).strip() + etype = str(e.get("entity_type", "")).strip() + score = e.get("score") + if name: + meta = [] + if etype: + meta.append(f"type={etype}") + if isinstance(score, (int, float)): + meta.append(f"score={score:.3f}") + summary_lines.append( + f"EntitySummary: {name}" + f"{(' [' + '; '.join(meta) + ']') if meta else ''}" + ) + if summary_lines: + contexts_all.append("\n".join(summary_lines)) + + elif search_type == "keyword": + # Keyword-based search + search_results = await search_graph( + connector=connector, + q=question, + group_id=group_id, + limit=search_limit + ) + + dialogs = search_results.get("dialogues", []) + statements = search_results.get("statements", []) + entities = search_results.get("entities", []) + + # Build context from dialogues + for d in dialogs: + content = str(d.get("content", "")).strip() + if content: + contexts_all.append(content) + + # Add statements + for s in statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + + # Add entity names + if entities: + entity_names = [ + str(e.get("name", "")).strip() + for e in entities[:5] + if e.get("name") + ] + if entity_names: + contexts_all.append(f"EntitySummary: {', '.join(entity_names)}") + + else: # hybrid + # Hybrid search with fallback to embedding + try: + search_results = await run_hybrid_search( + query_text=question, + search_type=search_type, + group_id=group_id, + limit=search_limit, + include=["chunks", "statements", "entities", "summaries"], + output_path=None, + ) + + # Handle flat structure (new API format) + if search_results and isinstance(search_results, dict): + chunks = search_results.get("chunks", []) + statements = search_results.get("statements", []) + entities = search_results.get("entities", []) + summaries = search_results.get("summaries", []) + + # Check if we got results + if not (chunks or statements or entities or summaries): + # Try nested structure (backward compatibility) + reranked = search_results.get("reranked_results", {}) + if reranked and isinstance(reranked, dict): + chunks = reranked.get("chunks", []) + statements = reranked.get("statements", []) + entities = reranked.get("entities", []) + summaries = reranked.get("summaries", []) + else: + raise ValueError("Hybrid search returned empty results") + else: + raise ValueError("Hybrid search returned empty results") + + except Exception as e: + # Fallback to embedding search + search_results = await search_graph_by_embedding( + connector=connector, + embedder_client=embedder, + query_text=question, + group_id=group_id, + limit=search_limit, + include=["chunks", "statements", "entities", "summaries"], + ) + chunks = search_results.get("chunks", []) + statements = search_results.get("statements", []) + entities = search_results.get("entities", []) + summaries = search_results.get("summaries", []) + + # Build context (same for both hybrid and fallback) + for c in chunks: + content = str(c.get("content", "")).strip() + if content: + contexts_all.append(content) + + for s in statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + + for sm in summaries: + summary_text = str(sm.get("summary", "")).strip() + if summary_text: + contexts_all.append(summary_text) + + # Add top entities + if entities: + scored = [e for e in entities if e.get("score") is not None] + top_entities = ( + sorted(scored, key=lambda x: x.get("score", 0), reverse=True)[:3] + if scored else entities[:3] + ) + if top_entities: + summary_lines = [] + for e in top_entities: + name = str(e.get("name", "")).strip() + etype = str(e.get("entity_type", "")).strip() + score = e.get("score") + if name: + meta = [] + if etype: + meta.append(f"type={etype}") + if isinstance(score, (int, float)): + meta.append(f"score={score:.3f}") + summary_lines.append( + f"EntitySummary: {name}" + f"{(' [' + '; '.join(meta) + ']') if meta else ''}" + ) + if summary_lines: + contexts_all.append("\n".join(summary_lines)) + + except Exception as e: + # Return empty list on error + contexts_all = [] + + return contexts_all + + +async def ingest_conversations_if_needed( + conversations: List[str], + group_id: str, + reset: bool = False +) -> bool: + """ + Wrapper for conversation ingestion using external extraction pipeline. + + This function populates the Neo4j database with processed conversation data + (chunks, statements, entities) so that the retrieval system has memory to search. + + The ingestion process: + 1. Parses conversation text into dialogue messages + 2. Chunks the dialogues into semantic units + 3. Extracts statements and entities using LLM + 4. Generates embeddings for all content + 5. Stores everything in Neo4j graph database + + Args: + conversations: List of raw conversation texts from LoCoMo dataset + Example: ["User: I went to Paris. AI: When was that?", ...] + group_id: Target group ID for database storage + reset: Whether to clear existing data first (not implemented in wrapper) + + Returns: + True if successful, False otherwise + + Note: + The external function uses "contexts" to mean "conversation texts". + This runs the full extraction pipeline: chunking → entity extraction → + statement extraction → embedding → Neo4j storage. + """ + try: + success = await ingest_contexts_via_full_pipeline( + contexts=conversations, + group_id=group_id, + save_chunk_output=True + ) + return success + except Exception as e: + print(f"[Ingestion] Failed to ingest conversations: {e}") + return False diff --git a/api/app/core/memory/evaluation/locomo/qwen_search_eval.py b/api/app/core/memory/evaluation/locomo/qwen_search_eval.py new file mode 100644 index 00000000..cbc0bfbd --- /dev/null +++ b/api/app/core/memory/evaluation/locomo/qwen_search_eval.py @@ -0,0 +1,858 @@ +import argparse +import asyncio +import json +import os +import time +from datetime import datetime, timedelta +from typing import List, Dict, Any +import statistics +try: + from dotenv import load_dotenv +except Exception: + def load_dotenv(): + return None + +import re +from app.repositories.neo4j.neo4j_connector import Neo4jConnector +from app.repositories.neo4j.graph_search import search_graph, search_graph_by_embedding +from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient +from app.core.models.base import RedBearModelConfig +from app.core.memory.utils.config.config_utils import get_embedder_config +from app.core.memory.storage_services.search import run_hybrid_search +from app.core.memory.utils.config.definitions import PROJECT_ROOT, SELECTED_GROUP_ID, SELECTED_LLM_ID, SELECTED_EMBEDDING_ID +from app.core.memory.utils.llm.llm_utils import get_llm_client +from app.core.memory.evaluation.extraction_utils import ingest_contexts_via_full_pipeline +from app.core.memory.evaluation.common.metrics import f1_score as common_f1, bleu1, jaccard, latency_stats, avg_context_tokens + + +# 参考 evaluation/locomo/evaluation.py 的 F1 计算逻辑（移除外部依赖，内联实现） +def _loc_normalize(text: str) -> str: + import re + # 确保输入是字符串 + text = str(text) if text is not None else "" + text = text.lower() + text = re.sub(r"[\,]", " ", text) # 去掉逗号 + text = re.sub(r"\b(a|an|the|and)\b", " ", text) + text = re.sub(r"[^\w\s]", " ", text) + text = " ".join(text.split()) + return text + +# 追加：相对时间归一化为绝对日期（有限支持：today/yesterday/tomorrow/X days ago/in X days/last week/next week） +def _resolve_relative_times(text: str, anchor: datetime) -> str: + import re + # 确保输入是字符串 + t = str(text) if text is not None else "" + # today / yesterday / tomorrow + t = re.sub(r"\btoday\b", anchor.date().isoformat(), t, flags=re.IGNORECASE) + t = re.sub(r"\byesterday\b", (anchor - timedelta(days=1)).date().isoformat(), t, flags=re.IGNORECASE) + t = re.sub(r"\btomorrow\b", (anchor + timedelta(days=1)).date().isoformat(), t, flags=re.IGNORECASE) + # X days ago / in X days + def _ago_repl(m: re.Match[str]) -> str: + n = int(m.group(1)) + return (anchor - timedelta(days=n)).date().isoformat() + def _in_repl(m: re.Match[str]) -> str: + n = int(m.group(1)) + return (anchor + timedelta(days=n)).date().isoformat() + t = re.sub(r"\b(\d+)\s+days\s+ago\b", _ago_repl, t, flags=re.IGNORECASE) + t = re.sub(r"\bin\s+(\d+)\s+days\b", _in_repl, t, flags=re.IGNORECASE) + # last week / next week（以7天近似） + t = re.sub(r"\blast\s+week\b", (anchor - timedelta(days=7)).date().isoformat(), t, flags=re.IGNORECASE) + t = re.sub(r"\bnext\s+week\b", (anchor + timedelta(days=7)).date().isoformat(), t, flags=re.IGNORECASE) + return t + +def loc_f1_score(prediction: str, ground_truth: str) -> float: + # 单答案 F1：按词集合计算（近似原始实现，去除词干依赖） + # 确保输入是字符串 + pred_str = str(prediction) if prediction is not None else "" + truth_str = str(ground_truth) if ground_truth is not None else "" + + p_tokens = _loc_normalize(pred_str).split() + g_tokens = _loc_normalize(truth_str).split() + if not p_tokens or not g_tokens: + return 0.0 + p = set(p_tokens) + g = set(g_tokens) + tp = len(p & g) + precision = tp / len(p) if p else 0.0 + recall = tp / len(g) if g else 0.0 + return (2 * precision * recall / (precision + recall)) if (precision + recall) > 0 else 0.0 + +def loc_multi_f1(prediction: str, ground_truth: str) -> float: + # 多答案 F1：prediction 与 ground_truth 以逗号分隔，逐一匹配取最大，再对多个 GT 取平均 + # 确保输入是字符串 + pred_str = str(prediction) if prediction is not None else "" + truth_str = str(ground_truth) if ground_truth is not None else "" + + predictions = [p.strip() for p in str(pred_str).split(',') if p.strip()] + ground_truths = [g.strip() for g in str(truth_str).split(',') if g.strip()] + if not predictions or not ground_truths: + return 0.0 + def _f1(a: str, b: str) -> float: + return loc_f1_score(a, b) + vals = [] + for gt in ground_truths: + vals.append(max(_f1(pred, gt) for pred in predictions)) + return sum(vals) / len(vals) + +# 标准化 LoCoMo 类别名：支持数字 category 与字符串 cat/type +CATEGORY_MAP_NUM_TO_NAME = { + 4: "Single-Hop", + 1: "Multi-Hop", + 3: "Open Domain", + 2: "Temporal", +} + +_TYPE_ALIASES = { + "single-hop": "Single-Hop", + "singlehop": "Single-Hop", + "single hop": "Single-Hop", + "multi-hop": "Multi-Hop", + "multihop": "Multi-Hop", + "multi hop": "Multi-Hop", + "open domain": "Open Domain", + "opendomain": "Open Domain", + "temporal": "Temporal", +} + +def get_category_label(item: Dict[str, Any]) -> str: + # 1) 直接用字符串 cat + cat = item.get("cat") + if isinstance(cat, str) and cat.strip(): + name = cat.strip() + lower = name.lower() + return _TYPE_ALIASES.get(lower, name) + # 2) 数字 category 转名称 + cat_num = item.get("category") + if isinstance(cat_num, int): + return CATEGORY_MAP_NUM_TO_NAME.get(cat_num, "unknown") + # 3) 备用 type 字段 + t = item.get("type") + if isinstance(t, str) and t.strip(): + lower = t.strip().lower() + return _TYPE_ALIASES.get(lower, t.strip()) + return "unknown" + + +def smart_context_selection(contexts: List[str], question: str, max_chars: int = 12000) -> str: + """基于问题关键词智能选择上下文""" + if not contexts: + return "" + + # 提取问题关键词（只保留有意义的词） + question_lower = question.lower() + stop_words = {'what', 'when', 'where', 'who', 'why', 'how', 'did', 'do', 'does', 'is', 'are', 'was', 'were', 'the', 'a', 'an', 'and', 'or', 'but'} + question_words = set(re.findall(r'\b\w+\b', question_lower)) + question_words = {word for word in question_words if word not in stop_words and len(word) > 2} + + print(f"🔍 问题关键词: {question_words}") + + # 给每个上下文打分 + scored_contexts = [] + for i, context in enumerate(contexts): + context_lower = context.lower() + score = 0 + + # 关键词匹配得分 + keyword_matches = 0 + for word in question_words: + if word in context_lower: + keyword_matches += 1 + # 关键词出现次数越多，得分越高 + score += context_lower.count(word) * 2 + + # 上下文长度得分（适中的长度更好） + context_len = len(context) + if 100 < context_len < 2000: # 理想长度范围 + score += 5 + elif context_len >= 2000: # 太长可能包含无关信息 + score += 2 + + # 如果是前几个上下文，给予额外分数（通常相关性更高） + if i < 3: + score += 3 + + scored_contexts.append((score, context, keyword_matches)) + + # 按得分排序 + scored_contexts.sort(key=lambda x: x[0], reverse=True) + + # 选择高得分的上下文，直到达到字符限制 + selected = [] + total_chars = 0 + selected_count = 0 + + print("📊 上下文相关性分析:") + for score, context, matches in scored_contexts[:5]: # 只显示前5个 + print(f" - 得分: {score}, 关键词匹配: {matches}, 长度: {len(context)}") + + for score, context, matches in scored_contexts: + if total_chars + len(context) <= max_chars: + selected.append(context) + total_chars += len(context) + selected_count += 1 + else: + # 如果这个上下文得分很高但放不下，尝试截取 + if score > 10 and total_chars < max_chars - 500: + remaining = max_chars - total_chars + # 找到包含关键词的部分 + lines = context.split('\n') + relevant_lines = [] + current_chars = 0 + + for line in lines: + line_lower = line.lower() + line_relevance = any(word in line_lower for word in question_words) + + if line_relevance and current_chars < remaining - 100: + relevant_lines.append(line) + current_chars += len(line) + + if relevant_lines: + truncated = '\n'.join(relevant_lines) + if len(truncated) > 100: # 确保有足够内容 + selected.append(truncated + "\n[相关内容截断...]") + total_chars += len(truncated) + selected_count += 1 + break # 不再尝试添加更多上下文 + + result = "\n\n".join(selected) + print(f"✅ 智能选择: {selected_count}个上下文, 总长度: {total_chars}字符") + return result + + +def get_search_params_by_category(category: str): + """根据问题类别调整检索参数""" + params_map = { + "Multi-Hop": {"limit": 20, "max_chars": 15000}, + "Temporal": {"limit": 16, "max_chars": 10000}, + "Open Domain": {"limit": 24, "max_chars": 18000}, + "Single-Hop": {"limit": 12, "max_chars": 8000}, + } + return params_map.get(category, {"limit": 16, "max_chars": 12000}) + + +async def run_locomo_eval( + sample_size: int = 1, + group_id: str | None = None, + search_limit: int = 8, + context_char_budget: int = 4000, # 保持默认值不变 + llm_temperature: float = 0.0, + llm_max_tokens: int = 32, + search_type: str = "hybrid", # 保持默认值不变 + output_path: str | None = None, + skip_ingest_if_exists: bool = True, + llm_timeout: float = 10.0, + llm_max_retries: int = 1 +) -> Dict[str, Any]: + + # 函数内部使用三路检索逻辑，但保持参数签名不变 + group_id = group_id or SELECTED_GROUP_ID + data_path = os.path.join(PROJECT_ROOT, "data", "locomo10.json") + if not os.path.exists(data_path): + data_path = os.path.join(os.getcwd(), "data", "locomo10.json") + with open(data_path, "r", encoding="utf-8") as f: + raw = json.load(f) + # LoCoMo 数据结构：顶层为若干对象，每个对象下有 qa 列表 + qa_items: List[Dict[str, Any]] = [] + if isinstance(raw, list): + for entry in raw: + qa_items.extend(entry.get("qa", [])) + else: + qa_items.extend(raw.get("qa", [])) + items: List[Dict[str, Any]] = qa_items[:sample_size] + + # === 保持原来的数据摄入逻辑 === + entries = raw if isinstance(raw, list) else [raw] + + # 只摄入前1条对话（保持原样） + max_dialogues_to_ingest = 1 + contents: List[str] = [] + print(f"📊 找到 {len(entries)} 个对话对象，只摄入前 {max_dialogues_to_ingest} 条") + + for i, entry in enumerate(entries[:max_dialogues_to_ingest]): + if not isinstance(entry, dict): + continue + + conv = entry.get("conversation", {}) + sample_id = entry.get("sample_id", f"unknown_{i}") + + print(f"🔍 处理对话 {i+1}: {sample_id}") + + lines: List[str] = [] + if isinstance(conv, dict): + # 收集所有 session_* 的消息 + session_count = 0 + for key, val in conv.items(): + if isinstance(val, list) and key.startswith("session_"): + session_count += 1 + for msg in val: + role = msg.get("speaker") or "用户" + text = msg.get("text") or "" + text = str(text).strip() + if not text: + continue + lines.append(f"{role}: {text}") + + print(f" - 包含 {session_count} 个session, {len(lines)} 条消息") + + if not lines: + print(f"⚠️ 警告: 对话 {sample_id} 没有对话内容，跳过摄入") + continue + + contents.append("\n".join(lines)) + + print(f"📥 总共摄入 {len(contents)} 个对话的conversation内容") + + # 选择要评测的QA对（从所有对话中选取） + indexed_items: List[tuple[int, Dict[str, Any]]] = [] + if isinstance(raw, list): + for e_idx, entry in enumerate(raw): + for qa in entry.get("qa", []): + indexed_items.append((e_idx, qa)) + else: + for qa in raw.get("qa", []): + indexed_items.append((0, qa)) + + # 这里使用sample_size来限制评测的QA数量 + selected = indexed_items[:sample_size] + items: List[Dict[str, Any]] = [qa for _, qa in selected] + + print(f"🎯 将评测 {len(items)} 个QA对，数据库中只包含 {len(contents)} 个对话") + # === 修改结束 === + + connector = Neo4jConnector() + + # 关键修复：强制重新摄入纯净的对话数据 + print("🔄 强制重新摄入纯净的对话数据...") + await ingest_contexts_via_full_pipeline(contents, group_id, save_chunk_output=True) + + # 使用异步LLM客户端 + llm_client = get_llm_client(SELECTED_LLM_ID) + # 初始化embedder用于直接调用 + cfg_dict = get_embedder_config(SELECTED_EMBEDDING_ID) + embedder = OpenAIEmbedderClient( + model_config=RedBearModelConfig.model_validate(cfg_dict) + ) + + # connector initialized above + latencies_llm: List[float] = [] + latencies_search: List[float] = [] + # 上下文诊断收集 + per_query_context_counts: List[int] = [] + per_query_context_avg_tokens: List[float] = [] + per_query_context_chars: List[int] = [] + per_query_context_tokens_total: List[int] = [] + # 详细样本调试信息 + samples: List[Dict[str, Any]] = [] + # 通用指标 + f1s: List[float] = [] + b1s: List[float] = [] + jss: List[float] = [] + # 参考 LoCoMo 评测的类别专用 F1（multi-hop 使用多答案 F1） + loc_f1s: List[float] = [] + # Per-category aggregation + cat_counts: Dict[str, int] = {} + cat_f1s: Dict[str, List[float]] = {} + cat_b1s: Dict[str, List[float]] = {} + cat_jss: Dict[str, List[float]] = {} + cat_loc_f1s: Dict[str, List[float]] = {} + try: + for item in items: + q = item.get("question", "") + ref = item.get("answer", "") + # 确保答案是字符串 + ref_str = str(ref) if ref is not None else "" + cat = get_category_label(item) + + print(f"\n=== 处理问题: {q} ===") + + # 根据类别调整检索参数 + search_params = get_search_params_by_category(cat) + adjusted_limit = search_params["limit"] + max_chars = search_params["max_chars"] + + print(f"🏷️ 类别: {cat}, 检索参数: limit={adjusted_limit}, max_chars={max_chars}") + + # 改进的检索逻辑：使用三路检索（statements, dialogues, entities） + t0 = time.time() + contexts_all: List[str] = [] + search_results = None # 保存完整的检索结果 + + try: + if search_type == "embedding": + # 直接调用嵌入检索，包含三路数据 + search_results = await search_graph_by_embedding( + connector=connector, + embedder_client=embedder, + query_text=q, + group_id=group_id, + limit=adjusted_limit, + include=["chunks", "statements", "entities", "summaries"], # 修复：使用正确的类型 + ) + chunks = search_results.get("chunks", []) + statements = search_results.get("statements", []) + entities = search_results.get("entities", []) + summaries = search_results.get("summaries", []) + + print(f"✅ 嵌入检索成功: {len(chunks)} chunks, {len(statements)} 条陈述, {len(entities)} 个实体, {len(summaries)} 个摘要") + + # 构建上下文：优先使用 chunks、statements 和 summaries + for c in chunks: + content = str(c.get("content", "")).strip() + if content: + contexts_all.append(content) + + for s in statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + + for sm in summaries: + summary_text = str(sm.get("summary", "")).strip() + if summary_text: + contexts_all.append(summary_text) + + # 实体摘要：最多加入前3个高分实体，避免噪声 + scored = [e for e in entities if e.get("score") is not None] + top_entities = sorted(scored, key=lambda x: x.get("score", 0), reverse=True)[:3] if scored else entities[:3] + if top_entities: + summary_lines = [] + for e in top_entities: + name = str(e.get("name", "")).strip() + etype = str(e.get("entity_type", "")).strip() + score = e.get("score") + if name: + meta = [] + if etype: + meta.append(f"type={etype}") + if isinstance(score, (int, float)): + meta.append(f"score={score:.3f}") + summary_lines.append(f"EntitySummary: {name}{(' [' + '; '.join(meta) + ']') if meta else ''}") + if summary_lines: + contexts_all.append("\n".join(summary_lines)) + + elif search_type == "keyword": + # 直接调用关键词检索 + search_results = await search_graph( + connector=connector, + q=q, + group_id=group_id, + limit=adjusted_limit + ) + dialogs = search_results.get("dialogues", []) + statements = search_results.get("statements", []) + entities = search_results.get("entities", []) + print(f"🔤 关键词检索找到 {len(dialogs)} 条对话, {len(statements)} 条陈述, {len(entities)} 个实体") + + # 构建上下文 + for d in dialogs: + content = str(d.get("content", "")).strip() + if content: + contexts_all.append(content) + for s in statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + # 实体处理（关键词检索的实体可能没有分数） + if entities: + entity_names = [str(e.get("name", "")).strip() for e in entities[:5] if e.get("name")] + if entity_names: + contexts_all.append(f"EntitySummary: {', '.join(entity_names)}") + + else: # hybrid + # 🎯 关键修复：混合检索使用更严格的回退机制 + print("🔀 使用混合检索（带回退机制）...") + try: + search_results = await run_hybrid_search( + query_text=q, + search_type=search_type, + group_id=group_id, + limit=adjusted_limit, + include=["chunks", "statements", "entities", "summaries"], + output_path=None, + ) + + # 🎯 关键修复：正确处理混合检索的扁平结构 + # 新的API返回扁平结构，直接从顶层获取结果 + if search_results and isinstance(search_results, dict): + # 新API返回扁平结构：直接从顶层获取 + chunks = search_results.get("chunks", []) + statements = search_results.get("statements", []) + entities = search_results.get("entities", []) + summaries = search_results.get("summaries", []) + + # 检查是否有有效结果 + if chunks or statements or entities or summaries: + print(f"✅ 混合检索成功: {len(chunks)} chunks, {len(statements)} 陈述, {len(entities)} 实体, {len(summaries)} 摘要") + else: + # 如果顶层没有结果，尝试旧的嵌套结构（向后兼容） + reranked = search_results.get("reranked_results", {}) + if reranked and isinstance(reranked, dict): + chunks = reranked.get("chunks", []) + statements = reranked.get("statements", []) + entities = reranked.get("entities", []) + summaries = reranked.get("summaries", []) + print(f"✅ 混合检索成功（使用旧格式reranked结果）: {len(chunks)} chunks, {len(statements)} 陈述") + else: + raise ValueError("混合检索返回空结果") + else: + raise ValueError("混合检索返回空结果") + + except Exception as e: + print(f"❌ 混合检索失败: {e}，回退到嵌入检索") + search_results = await search_graph_by_embedding( + connector=connector, + embedder_client=embedder, + query_text=q, + group_id=group_id, + limit=adjusted_limit, + include=["chunks", "statements", "entities", "summaries"], + ) + chunks = search_results.get("chunks", []) + statements = search_results.get("statements", []) + entities = search_results.get("entities", []) + summaries = search_results.get("summaries", []) + print(f"✅ 回退嵌入检索成功: {len(chunks)} chunks, {len(statements)} 陈述") + + # 🎯 统一处理：构建上下文（所有检索类型共用） + for c in chunks: + content = str(c.get("content", "")).strip() + if content: + contexts_all.append(content) + + for s in statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + + for sm in summaries: + summary_text = str(sm.get("summary", "")).strip() + if summary_text: + contexts_all.append(summary_text) + + # 实体摘要：最多加入前3个高分实体 + if entities: + scored = [e for e in entities if e.get("score") is not None] + top_entities = sorted(scored, key=lambda x: x.get("score", 0), reverse=True)[:3] if scored else entities[:3] + if top_entities: + summary_lines = [] + for e in top_entities: + name = str(e.get("name", "")).strip() + etype = str(e.get("entity_type", "")).strip() + score = e.get("score") + if name: + meta = [] + if etype: + meta.append(f"type={etype}") + if isinstance(score, (int, float)): + meta.append(f"score={score:.3f}") + summary_lines.append(f"EntitySummary: {name}{(' [' + '; '.join(meta) + ']') if meta else ''}") + if summary_lines: + contexts_all.append("\n".join(summary_lines)) + + # 关键修复：过滤掉包含当前问题答案的上下文 + filtered_contexts = [] + for context in contexts_all: + content = str(context) + # 排除包含当前问题标准答案的上下文 + if ref_str and ref_str.strip() and ref_str.strip() in content: + print("🚫 过滤掉包含标准答案的上下文") + continue + filtered_contexts.append(context) + + print(f"📊 过滤后保留 {len(filtered_contexts)} 个上下文 (原 {len(contexts_all)} 个)") + contexts_all = filtered_contexts + + # 输出完整的检索结果信息 + print("🔍 检索结果详情:") + if search_results: + output_data = { + "statements": [ + { + "statement": s.get("statement", "")[:200] + "..." if len(s.get("statement", "")) > 200 else s.get("statement", ""), + "score": s.get("score", 0.0) + } + for s in (statements[:2] if 'statements' in locals() else []) + ], + "dialogues": [ + { + "uuid": d.get("uuid", ""), + "group_id": d.get("group_id", ""), + "content": d.get("content", "")[:200] + "..." if len(d.get("content", "")) > 200 else d.get("content", ""), + "score": d.get("score", 0.0) + } + for d in (dialogs[:2] if 'dialogs' in locals() else []) + ], + "entities": [ + { + "name": e.get("name", ""), + "entity_type": e.get("entity_type", ""), + "score": e.get("score", 0.0) + } + for e in (entities[:2] if 'entities' in locals() else []) + ] + } + print(json.dumps(output_data, ensure_ascii=False, indent=2)) + else: + print(" 无检索结果") + + except Exception as e: + print(f"❌ {search_type}检索失败: {e}") + contexts_all = [] + search_results = None + + t1 = time.time() + latencies_search.append((t1 - t0) * 1000) + + # 使用智能上下文选择 + context_text = "" + if contexts_all: + context_text = smart_context_selection(contexts_all, q, max_chars=max_chars) + + # 如果智能选择后仍然过长，进行最终保护性截断 + if len(context_text) > max_chars: + print(f"⚠️ 智能选择后仍然过长 ({len(context_text)}字符)，进行最终截断") + context_text = context_text[:max_chars] + "\n\n[最终截断...]" + + # 时间解析 + anchor_date = datetime(2023, 5, 8) # 使用固定日期确保一致性 + context_text = _resolve_relative_times(context_text, anchor_date) + + context_text = f"Reference date: {anchor_date.date().isoformat()}\n\n" + context_text + + print(f"📝 最终上下文长度: {len(context_text)} 字符") + + # 显示不同上下文的预览 + print("🔍 上下文预览:") + for j, context in enumerate(contexts_all[:3]): # 显示前3个上下文 + preview = context[:150].replace('\n', ' ') + print(f" 上下文{j+1}: {preview}...") + + else: + print("❌ 没有检索到有效上下文") + context_text = "No relevant context found." + + # 记录上下文诊断信息 + per_query_context_counts.append(len(contexts_all)) + per_query_context_avg_tokens.append(avg_context_tokens([context_text])) + per_query_context_chars.append(len(context_text)) + per_query_context_tokens_total.append(len(_loc_normalize(context_text).split())) + + # LLM 提示词 + messages = [ + {"role": "system", "content": ( + "You are a precise QA assistant. Answer following these rules:\n" + "1) Extract the EXACT information mentioned in the context\n" + "2) For time questions: calculate actual dates from relative times\n" + "3) Return ONLY the answer text in simplest form\n" + "4) For dates, use format 'DD Month YYYY' (e.g., '7 May 2023')\n" + "5) If no clear answer found, respond with 'Unknown'" + )}, + {"role": "user", "content": f"Question: {q}\n\nContext:\n{context_text}"}, + ] + + t2 = time.time() + # 使用异步调用 + resp = await llm_client.chat(messages=messages) + t3 = time.time() + latencies_llm.append((t3 - t2) * 1000) + + # 兼容不同的响应格式 + pred = resp.content.strip() if hasattr(resp, 'content') else (resp["choices"][0]["message"]["content"].strip() if isinstance(resp, dict) else "Unknown") + + # 计算指标（确保使用字符串） + f1_val = common_f1(str(pred), ref_str) + b1_val = bleu1(str(pred), ref_str) + j_val = jaccard(str(pred), ref_str) + + f1s.append(f1_val) + b1s.append(b1_val) + jss.append(j_val) + + # Accumulate by category + cat_counts[cat] = cat_counts.get(cat, 0) + 1 + cat_f1s.setdefault(cat, []).append(f1_val) + cat_b1s.setdefault(cat, []).append(b1_val) + cat_jss.setdefault(cat, []).append(j_val) + + # LoCoMo 专用 F1：multi-hop(1) 使用多答案 F1，其它(2/3/4)使用单答案 F1 + if item.get("category") in [2, 3, 4]: + loc_val = loc_f1_score(str(pred), ref_str) + elif item.get("category") in [1]: + loc_val = loc_multi_f1(str(pred), ref_str) + else: + loc_val = loc_f1_score(str(pred), ref_str) + loc_f1s.append(loc_val) + cat_loc_f1s.setdefault(cat, []).append(loc_val) + + # 保存完整的检索结果信息 + samples.append({ + "question": q, + "answer": ref_str, + "category": cat, + "prediction": pred, + "metrics": { + "f1": f1_val, + "b1": b1_val, + "j": j_val, + "loc_f1": loc_val + }, + "retrieval": { + "retrieved_documents": len(contexts_all), + "context_length": len(context_text), + "search_limit": adjusted_limit, + "max_chars": max_chars + }, + "timing": { + "search_ms": (t1 - t0) * 1000, + "llm_ms": (t3 - t2) * 1000 + } + }) + + print(f"🤖 LLM 回答: {pred}") + print(f"✅ 正确答案: {ref_str}") + print(f"📈 当前指标 - F1: {f1_val:.3f}, BLEU-1: {b1_val:.3f}, Jaccard: {j_val:.3f}, LoCoMo F1: {loc_val:.3f}") + + # Compute per-category averages and dispersion (std, iqr) + def _percentile(sorted_vals: List[float], p: float) -> float: + if not sorted_vals: + return 0.0 + if len(sorted_vals) == 1: + return sorted_vals[0] + k = (len(sorted_vals) - 1) * p + f = int(k) + c = f + 1 if f + 1 < len(sorted_vals) else f + if f == c: + return sorted_vals[f] + return sorted_vals[f] + (sorted_vals[c] - sorted_vals[f]) * (k - f) + + by_category: Dict[str, Dict[str, float | int]] = {} + for c in cat_counts: + f_list = cat_f1s.get(c, []) + b_list = cat_b1s.get(c, []) + j_list = cat_jss.get(c, []) + lf_list = cat_loc_f1s.get(c, []) + j_sorted = sorted(j_list) + j_std = statistics.stdev(j_list) if len(j_list) > 1 else 0.0 + j_q75 = _percentile(j_sorted, 0.75) + j_q25 = _percentile(j_sorted, 0.25) + by_category[c] = { + "count": cat_counts[c], + "f1": (sum(f_list) / max(len(f_list), 1)) if f_list else 0.0, + "b1": (sum(b_list) / max(len(b_list), 1)) if b_list else 0.0, + "j": (sum(j_list) / max(len(j_list), 1)) if j_list else 0.0, + "j_std": j_std, + "j_iqr": (j_q75 - j_q25) if j_list else 0.0, + # 参考 LoCoMo 评测的类别专用 F1 + "loc_f1": (sum(lf_list) / max(len(lf_list), 1)) if lf_list else 0.0, + } + + # 累加命中（cum accuracy by category）：与 evaluation_stats.py 输出形式相仿 + cum_accuracy_by_category = {c: sum(cat_loc_f1s.get(c, [])) for c in cat_counts} + + result = { + "dataset": "locomo", + "items": len(items), + "metrics": { + "f1": sum(f1s) / max(len(f1s), 1), + "b1": sum(b1s) / max(len(b1s), 1), + "j": sum(jss) / max(len(jss), 1), + # LoCoMo 类别专用 F1 的总体 + "loc_f1": sum(loc_f1s) / max(len(loc_f1s), 1), + }, + "by_category": by_category, + "category_counts": cat_counts, + "cum_accuracy_by_category": cum_accuracy_by_category, + "context": { + "avg_tokens": (sum(per_query_context_avg_tokens) / max(len(per_query_context_avg_tokens), 1)) if per_query_context_avg_tokens else 0.0, + "avg_chars": (sum(per_query_context_chars) / max(len(per_query_context_chars), 1)) if per_query_context_chars else 0.0, + "count_avg": (sum(per_query_context_counts) / max(len(per_query_context_counts), 1)) if per_query_context_counts else 0.0, + "avg_memory_tokens": (sum(per_query_context_tokens_total) / max(len(per_query_context_tokens_total), 1)) if per_query_context_tokens_total else 0.0, + }, + "latency": { + "search": latency_stats(latencies_search), + "llm": latency_stats(latencies_llm), + }, + "samples": samples, + "params": { + "group_id": group_id, + "search_limit": search_limit, + "context_char_budget": context_char_budget, + "search_type": search_type, + "llm_id": SELECTED_LLM_ID, + "retrieval_embedding_id": SELECTED_EMBEDDING_ID, + "skip_ingest_if_exists": skip_ingest_if_exists, + "llm_timeout": llm_timeout, + "llm_max_retries": llm_max_retries, + "llm_temperature": llm_temperature, + "llm_max_tokens": llm_max_tokens + }, + "timestamp": datetime.now().isoformat() + } + if output_path: + try: + os.makedirs(os.path.dirname(output_path), exist_ok=True) + with open(output_path, "w", encoding="utf-8") as f: + json.dump(result, f, ensure_ascii=False, indent=2) + print(f"✅ 结果已保存到: {output_path}") + except Exception as e: + print(f"❌ 保存结果失败: {e}") + return result + finally: + await connector.close() + + +def main(): + parser = argparse.ArgumentParser(description="Run LoCoMo evaluation with Qwen search") + parser.add_argument("--sample_size", type=int, default=1, help="Number of samples to evaluate") + parser.add_argument("--group_id", type=str, default=None, help="Group ID for retrieval") + parser.add_argument("--search_limit", type=int, default=8, help="Search limit per query") + parser.add_argument("--context_char_budget", type=int, default=12000, help="Max characters for context") + parser.add_argument("--llm_temperature", type=float, default=0.0, help="LLM temperature") + parser.add_argument("--llm_max_tokens", type=int, default=32, help="LLM max tokens") + parser.add_argument("--search_type", type=str, default="embedding", choices=["keyword", "embedding", "hybrid"], help="Search type") + parser.add_argument("--output_path", type=str, default=None, help="Output path for results") + parser.add_argument("--skip_ingest_if_exists", action="store_true", help="Skip ingest if group exists") + parser.add_argument("--llm_timeout", type=float, default=10.0, help="LLM timeout in seconds") + parser.add_argument("--llm_max_retries", type=int, default=1, help="LLM max retries") + args = parser.parse_args() + + load_dotenv() + + result = asyncio.run(run_locomo_eval( + sample_size=args.sample_size, + group_id=args.group_id, + search_limit=args.search_limit, + context_char_budget=args.context_char_budget, + llm_temperature=args.llm_temperature, + llm_max_tokens=args.llm_max_tokens, + search_type=args.search_type, + output_path=args.output_path, + skip_ingest_if_exists=args.skip_ingest_if_exists, + llm_timeout=args.llm_timeout, + llm_max_retries=args.llm_max_retries + )) + + print("\n" + "="*50) + print("📊 最终评测结果:") + print(f" 样本数量: {result['items']}") + print(f" F1: {result['metrics']['f1']:.3f}") + print(f" BLEU-1: {result['metrics']['b1']:.3f}") + print(f" Jaccard: {result['metrics']['j']:.3f}") + print(f" LoCoMo F1: {result['metrics']['loc_f1']:.3f}") + print(f" 平均上下文长度: {result['context']['avg_chars']:.0f} 字符") + print(f" 平均检索延迟: {result['latency']['search']['mean']:.1f}ms") + print(f" 平均LLM延迟: {result['latency']['llm']['mean']:.1f}ms") + + if result['by_category']: + print("\n📈 按类别细分:") + for cat, metrics in result['by_category'].items(): + print(f" {cat}:") + print(f" 样本数: {metrics['count']}") + print(f" F1: {metrics['f1']:.3f}") + print(f" LoCoMo F1: {metrics['loc_f1']:.3f}") + print(f" Jaccard: {metrics['j']:.3f} (±{metrics['j_std']:.3f}, IQR={metrics['j_iqr']:.3f})") + + +if __name__ == "__main__": + main() diff --git a/api/app/core/memory/evaluation/longmemeval/qwen_search_eval.py b/api/app/core/memory/evaluation/longmemeval/qwen_search_eval.py new file mode 100644 index 00000000..d7cd711b --- /dev/null +++ b/api/app/core/memory/evaluation/longmemeval/qwen_search_eval.py @@ -0,0 +1,1344 @@ +import argparse +import asyncio +import json +import os +import time +import re +import statistics +from datetime import datetime, timedelta +from typing import List, Dict, Any + +try: + from dotenv import load_dotenv +except Exception: + def load_dotenv(): + return None + +# 确保可以找到 src 及项目根路径 +import sys +_THIS_DIR = os.path.dirname(os.path.abspath(__file__)) +_PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(_THIS_DIR))) +_SRC_DIR = os.path.join(_PROJECT_ROOT, "src") +for _p in (_SRC_DIR, _PROJECT_ROOT): + if _p not in sys.path: + sys.path.insert(0, _p) + +# 与现有评估脚本保持一致的导入方式 +from app.repositories.neo4j.neo4j_connector import Neo4jConnector +try: + # 优先从 extraction_utils1 导入 + from app.core.memory.evaluation.extraction_utils import ingest_contexts_via_full_pipeline # type: ignore +except Exception: + ingest_contexts_via_full_pipeline = None # 在运行时做兜底检查 +from app.repositories.neo4j.graph_search import search_graph, search_graph_by_embedding +from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient +from app.core.models.base import RedBearModelConfig +from app.core.memory.utils.config.config_utils import get_embedder_config +from app.core.memory.utils.llm.llm_utils import get_llm_client +from app.core.memory.evaluation.dialogue_queries import SEARCH_ENTITIES_BY_NAME +from app.core.memory.utils.config.definitions import PROJECT_ROOT, SELECTED_LLM_ID, SELECTED_EMBEDDING_ID +from app.core.memory.evaluation.common.metrics import f1_score as common_f1, jaccard, latency_stats, avg_context_tokens +try: + from app.core.memory.evaluation.common.metrics import exact_match +except Exception: + # 兜底：简单的大小写不敏感比较 + def exact_match(pred: str, ref: str) -> bool: + return str(pred).strip().lower() == str(ref).strip().lower() + + +def load_dataset_any(path: str) -> List[Dict[str, Any]]: + """健壮地加载数据集（兼容 list 或多段 JSON）。""" + with open(path, "r", encoding="utf-8") as f: + s = f.read().strip() + try: + obj = json.loads(s) + if isinstance(obj, list): + return obj + elif isinstance(obj, dict): + return [obj] + except json.JSONDecodeError: + pass + dec = json.JSONDecoder() + idx = 0 + items: List[Dict[str, Any]] = [] + while idx < len(s): + while idx < len(s) and s[idx].isspace(): + idx += 1 + if idx >= len(s): + break + try: + obj, end = dec.raw_decode(s, idx) + if isinstance(obj, list): + for it in obj: + if isinstance(it, dict): + items.append(it) + elif isinstance(obj, dict): + items.append(obj) + idx = end + except json.JSONDecodeError: + nl = s.find("\n", idx) + if nl == -1: + break + idx = nl + 1 + return items + + +def is_chinese_text(s: str) -> bool: + return bool(re.search(r"[\u4e00-\u9fff]", s or "")) + + +def build_context_from_sessions(item: Dict[str, Any]) -> List[str]: + """从数据项的 haystack_sessions 构建上下文片段。 + - 优先返回包含 has_answer 的消息 + - 其次返回拼接后的整段会话 + """ + contexts: List[str] = [] + sessions = item.get("haystack_sessions", []) or item.get("sessions", []) + for session in sessions: + parts: List[str] = [] + if isinstance(session, list): + for msg in session: + role = msg.get("role", "") + content = msg.get("content", "") or msg.get("text", "") + if content: + parts.append(f"{role}: {content}" if role else str(content)) + if msg.get("has_answer", False): + contexts.append(f"{role}: {content}" if role else str(content)) + elif isinstance(session, dict): + role = session.get("role", "") + content = session.get("content", "") or session.get("text", "") + if content: + parts.append(f"{role}: {content}" if role else str(content)) + if session.get("has_answer", False): + contexts.append(f"{role}: {content}" if role else str(content)) + if parts: + contexts.append("\n".join(parts)) + # 兜底：存在单字段上下文 + if not contexts: + single_ctx = item.get("context") or item.get("dialogue") or item.get("conversation") + if isinstance(single_ctx, str) and single_ctx.strip(): + contexts.append(single_ctx.strip()) + return contexts + + +def extract_candidate_options(question: str) -> List[str]: + """从问题中提取候选选项（A-or-B 类问题）。""" + q = (question or "").strip() + options: List[str] = [] + + # 1) 引号包裹的片段 + for pat in [r"'([^']+)'", r'\"([^\"]+)\"', r'“([^”]+)”', r'‘([^’]+)’']: + for m in re.findall(pat, q): + val = (m or "").strip() + if val: + options.append(val) + + # 2) or/还是/或者 连接词 + if len(options) < 2: + pats = [ + r"([^,;，；]+?)\s+or\s+([^,;，；\?\.!.。！]+)", + r"([^,;，；]+?)\s+还是\s+([^,;，；\?\.!.。！]+)", + r"([^,;，；]+?)\s+或者\s+([^,;，；\?\.!.。！]+)", + ] + for pat in pats: + matches = list(re.finditer(pat, q, flags=re.IGNORECASE)) + if matches: + m = matches[-1] + cand1 = m.group(1).strip().strip("?？.,，;； ") + cand2 = m.group(2).strip().strip("?？.,，;； ") + options.extend([cand1, cand2]) + break + + # 去重 + seen = set() + uniq: List[str] = [] + for o in options: + o2 = o.strip() + key = o2.lower() if not is_chinese_text(o2) else o2 + if o2 and key not in seen: + uniq.append(o2) + seen.add(key) + return uniq + + +def extract_time_entities(text: str) -> List[Dict[str, Any]]: + """增强时间实体提取，专门用于时间推理问题""" + time_entities = [] + + # 日期模式 + date_patterns = [ + (r'\b(\d{4})-(\d{1,2})-(\d{1,2})\b', 'date'), # YYYY-MM-DD + (r'\b(\d{1,2})月(\d{1,2})日\b', 'date'), # 中文日期 + (r'\b(January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{1,2}),?\s+(\d{4})?', 'date'), # 英文月份 + (r'\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(\d{1,2}),?\s+(\d{4})?', 'date'), # 英文月份缩写 + ] + + # 时间间隔模式 + duration_patterns = [ + (r'(\d+)\s*天', 'days'), + (r'(\d+)\s*周', 'weeks'), + (r'(\d+)\s*个月', 'months'), + (r'(\d+)\s*年', 'years'), + (r'(\d+)\s*days?', 'days'), + (r'(\d+)\s*weeks?', 'weeks'), + (r'(\d+)\s*months?', 'months'), + (r'(\d+)\s*years?', 'years'), + ] + + # 事件时间关系模式 + temporal_relation_patterns = [ + (r'(之前|以前|前)\s*(\d+)\s*天', 'days_before'), + (r'(之后|以后|后)\s*(\d+)\s*天', 'days_after'), + (r'(\d+)\s*天\s*(之前|以前|前)', 'days_before'), + (r'(\d+)\s*天\s*(之后|以后|后)', 'days_after'), + (r'(\d+)\s*days?\s*(before|ago)', 'days_before'), + (r'(\d+)\s*days?\s*(after|later)', 'days_after'), + ] + + # 提取日期 + for pattern, entity_type in date_patterns: + matches = re.finditer(pattern, text, re.IGNORECASE) + for match in matches: + time_entities.append({ + 'text': match.group(), + 'type': entity_type, + 'start': match.start(), + 'end': match.end() + }) + + # 提取时间间隔 + for pattern, entity_type in duration_patterns: + matches = re.finditer(pattern, text, re.IGNORECASE) + for match in matches: + time_entities.append({ + 'text': match.group(), + 'type': entity_type, + 'value': int(match.group(1)), + 'start': match.start(), + 'end': match.end() + }) + + # 提取时间关系 + for pattern, entity_type in temporal_relation_patterns: + matches = re.finditer(pattern, text, re.IGNORECASE) + for match in matches: + time_entities.append({ + 'text': match.group(), + 'type': entity_type, + 'value': int(match.group(2)) if match.groups() >= 2 else int(match.group(1)), + 'start': match.start(), + 'end': match.end() + }) + + return time_entities + + +def calculate_time_difference(date1: str, date2: str) -> int: + """计算两个日期之间的天数差""" + try: + # 解析日期格式 + def parse_date(date_str: str) -> datetime: + # 尝试多种日期格式 + formats = [ + '%Y-%m-%d', + '%m月%d日', + '%B %d, %Y', + '%b %d, %Y', + '%Y年%m月%d日' + ] + + for fmt in formats: + try: + return datetime.strptime(date_str, fmt) + except ValueError: + continue + + # 如果都无法解析，返回当前日期 + return datetime.now() + + d1 = parse_date(date1) + d2 = parse_date(date2) + + # 计算天数差（绝对值） + return abs((d2 - d1).days) + except Exception: + return -1 # 表示计算失败 + + +def smart_context_selection(contexts: List[str], question: str, max_chars: int = 4000) -> str: + """增强版上下文选择：特别优化时间推理问题的处理""" + if not contexts: + return "" + + # 检测是否为时间推理问题 + is_temporal_question = any(keyword in question.lower() for keyword in + ['days', 'day', 'before', 'after', 'first', '先后', '顺序', '间隔', '多久', '多少天']) + + # 提取时间实体从问题中 + question_time_entities = extract_time_entities(question) + + # 英文关键词（去停用词） + question_lower = question.lower() + stop_words = { + 'what','when','where','who','why','how','did','do','does','is','are','was','were', + 'the','a','an','and','or','but','many','which','first' + } + eng_words = [w for w in set(re.findall(r'\b\w+\b', question_lower)) + if w not in stop_words and len(w) > 2] + + # 中文片段与候选选项 + cn_tokens = generate_query_keywords_cn(question) + options = extract_candidate_options(question) + + # 时间推理问题的特殊处理 + if is_temporal_question: + # 为时间问题添加时间相关关键词 + time_keywords = ['天', '日', '月', '年', 'before', 'after', 'days', 'first', '先后'] + eng_words = [w for w in eng_words if w not in ['days', 'first']] # 避免重复 + cn_tokens.extend([kw for kw in time_keywords if kw not in cn_tokens]) + + # 限制关键词数量，优先时间相关 + tokens = time_keywords[:2] + cn_tokens[:2] + eng_words[:1] + options[:1] + else: + # 常规问题处理 + tokens = cn_tokens[:3] + options[:2] + eng_words[:1] + + # 去重 + seen = set() + final_tokens: List[str] = [] + for t in tokens: + t2 = t.strip() + if t2 and t2 not in seen: + final_tokens.append(t2) + seen.add(t2) + + scored_contexts: List[tuple[float, str]] = [] + + # 时间推理问题的权重映射 + temporal_weight_map = { + "天": 2.0, "日": 2.0, "月": 1.8, "年": 1.8, "days": 2.0, + "before": 1.5, "after": 1.5, "first": 1.5, "先后": 1.5 + } + + # 常规问题的权重映射 + normal_weight_map = { + "问题": 2.0, "故障": 2.0, "异常": 1.8, "不正常": 1.8, "坏了": 1.8, + "系统": 1.3, "GPS": 1.5, "保养": 1.4, "设备": 1.2, "模块": 1.2, "功能": 1.1 + } + + weight_map = temporal_weight_map if is_temporal_question else normal_weight_map + + for i, context in enumerate(contexts): + context_str = str(context) + lines = re.split(r'[\r\n]+', context_str) + hit_lines: List[str] = [] + kw_hits: float = 0.0 + time_entity_count = 0 + + for line in lines: + ln = line.strip() + if not ln: + continue + + has_keyword = False + # 关键词匹配 + for tok in final_tokens: + if tok and tok in ln: + w = weight_map.get(tok, 1.0) + kw_hits += ln.count(tok) * w + has_keyword = True + + # 时间实体检测（特别针对时间推理问题） + if is_temporal_question: + time_entities = extract_time_entities(ln) + time_entity_count += len(time_entities) + if time_entities: + has_keyword = True + + if has_keyword: + # 对于时间推理问题，保留包含时间信息的完整行 + hit_lines.append(ln) + + snippet = "\n".join(hit_lines) if hit_lines else context_str.strip() + + # 限制单段长度，但对时间推理问题稍微放宽限制 + max_snippet_len = 600 if is_temporal_question else 500 + if len(snippet) > max_snippet_len: + snippet = snippet[:max_snippet_len] + + # 评分逻辑 + has_number = 1 if re.search(r'\d', snippet) else 0 + has_date = 1 if (re.search(r'\b\d{4}-\d{1,2}-\d{1,2}\b', snippet) or + re.search(r'\d{1,2}月\d{1,2}日', snippet)) else 0 + + # 时间推理问题的特殊评分 + if is_temporal_question: + time_bonus = time_entity_count * 2.0 # 时间实体奖励 + temporal_coherence = 3 if (has_date and time_entity_count >= 2) else 0 + else: + time_bonus = 0 + temporal_coherence = 0 + + length_bonus = 5 if 50 < len(snippet) < 1000 else (2 if len(snippet) >= 1000 else 0) + pos_bonus = 3 if i < 3 else 0 + + score = (kw_hits * 0.8 + (has_number + has_date) * 1.5 + + length_bonus + pos_bonus + time_bonus + temporal_coherence) + + scored_contexts.append((score, snippet)) + + # 选择累计至总字符预算 + scored_contexts.sort(key=lambda x: x[0], reverse=True) + selected: List[str] = [] + total_chars = 0 + + for score, snippet in scored_contexts: + if total_chars + len(snippet) <= max_chars: + selected.append(snippet) + total_chars += len(snippet) + else: + if not selected and len(snippet) > max_chars: + selected.append(snippet[:max_chars]) + break + + final_context = "\n\n".join(selected) + + # 对于时间推理问题，添加时间计算提示 + if is_temporal_question and question_time_entities: + time_prompt = "\n\n[时间推理提示：请仔细分析上述上下文中的日期和时间关系，计算时间间隔或确定事件顺序]" + if total_chars + len(time_prompt) <= max_chars: + final_context += time_prompt + + return final_context + + +# 中文关键词提取（短语级，含数词/日期/常见领域词） +def _extract_cn_tokens(text: str) -> List[str]: + if not text: + return [] + t = str(text) + # 去掉常见功能词（粗略，不依赖分词库） + stop_words = [ + "我","我们","你","他","她","它","这","那","哪","一个","一次","一些","什么","怎么","是否","吗","呢", + "很","更","最","已经","正在","将要","马上","尽快","最近","关于","有关","以及","并且","或者","还是", + "因为","所以","如果","但是","而且","然后","之后","之前","同时","另外","并","但","却","被","把","让","给", + "和","与","跟","及","还有","就","都","在","对","对于","的","了","着","过","到","于","从","以","为","向","至","是" + ] + for sw in stop_words: + t = t.replace(sw, " ") + # 去标点 + t = re.sub(r"[，。！？、；：,.!?;:\"'（）()［］\[\]\-—…·]", " ", t) + # 基础中文片段（>=2） + base = re.findall(r"[\u4e00-\u9fff]{2,}", t) + # 特殊组合：第X次XXXX + specials = re.findall(r"第[一二三四五六七八九十]+次[\u4e00-\u9fff]{2,6}", text) + # 领域词（简单词典） + # 日期与数字 + dates = re.findall(r"\d{4}年\d{1,2}月\d{1,2}日|\d{1,2}月\d{1,2}日|\d{4}-\d{1,2}-\d{1,2}", text) + numbers = re.findall(r"\b\d+\b", text) + + tokens: List[str] = specials + base + dates + numbers + + generic = {"建议","推荐","帮助","提升","技能","有效","团队","参与度","喜欢","开始"} + tokens: List[str] = specials + base + dates + numbers + uniq: List[str] = [] + seen = set() + for tok in tokens: + tok2 = tok.strip() + if len(tok2) < 2 or len(tok2) > 6: + continue + if tok2 in generic: + continue + if tok2 not in seen: + uniq.append(tok2) + seen.add(tok2) + # 排除常见疑问型短语 + blacklist_exact = {"是什么","多少","多少天","哪个","哪些","之间","先","后","之前","之后"} + uniq2: List[str] = [u for u in uniq if u not in blacklist_exact] + return uniq2[:12] + + +# 面向检索的中文关键词生成：强调"短语、核心名词、问题/故障" +def generate_query_keywords_cn(question: str) -> List[str]: + if not question: + return [] + raw = _extract_cn_tokens(question) + core: List[str] = [] + seen = set() + + def push(x: str): + x2 = x.strip() + if not x2: + return + if 2 <= len(x2) <= 6 and x2 not in seen: + core.append(x2) + seen.add(x2) + + # 检测时间推理问题 + is_temporal = any(keyword in question for keyword in ['天', '日', 'before', 'after', 'first', '先后', '间隔']) + if is_temporal: + push("天") + push("日") + push("先后") + + # 明确优先的核心词 + if "新车" in question: + push("新车") + # 第X次保养/维修 + specials = re.findall(r"第[一二三四五六七八九十]+次[\u4e00-\u9fff]{2,6}", question) + for s in specials: + if "保养" in s or "维修" in s: + push(s) + if "保养" in question: + push("保养") + # 问题/故障类词，如题含"问题"则扩展同义词 + if "问题" in question: + for w in ["问题","故障","异常","不正常"]: + push(w) + + # 补充：从原始片段筛更短的名词短语（过滤疑问型词） + blacklist = {"是什么","多少","哪个","还是","或者","之间","先","后","之前","之后"} + for tok in raw: + if tok in blacklist: + continue + push(tok) + + # 限制数量，避免过长列表影响检索稳定性 + return core[:4] # 稍微增加限制 + + +# 通过别名匹配进行实体关键词检索（多token合并） +async def _search_entities_by_aliases(connector: Neo4jConnector, tokens: List[str], group_id: str | None, limit: int) -> List[Dict[str, Any]]: + results: List[Dict[str, Any]] = [] + try: + for tok in tokens: + rows = await connector.execute_query(SEARCH_ENTITIES_BY_NAME, q=tok, group_id=group_id, limit=limit) + if rows: + results.extend(rows) + except Exception: + pass + + # 按 name 去重 + deduped: List[Dict[str, Any]] = [] + seen = set() + for r in results: + k = str(r.get("name", "")) + if k and k not in seen: + deduped.append(r) + seen.add(k) + return deduped + + +# 通过对话/陈述中的entity_ids反查实体名称 +_FETCH_ENTITIES_BY_IDS = """ +MATCH (e:ExtractedEntity) +WHERE e.id IN $ids AND ($group_id IS NULL OR e.group_id = $group_id) +RETURN e.id AS id, e.name AS name, e.group_id AS group_id, e.entity_type AS entity_type +""" + +async def _fetch_entities_by_ids(connector: Neo4jConnector, ids: List[str], group_id: str | None) -> List[Dict[str, Any]]: + if not ids: + return [] + try: + rows = await connector.execute_query(_FETCH_ENTITIES_BY_IDS, ids=list({i for i in ids if i}), group_id=group_id) + return rows or [] + except Exception: + return [] + + +# 增强的时间实体检索 +_TIME_ENTITY_SEARCH = """ +MATCH (e:ExtractedEntity) +WHERE e.entity_type CONTAINS "TIME" OR e.entity_type CONTAINS "DATE" OR e.name =~ $date_pattern +AND ($group_id IS NULL OR e.group_id = $group_id) +RETURN e.id AS id, e.name AS name, e.group_id AS group_id, e.entity_type AS entity_type +LIMIT $limit +""" + +async def _search_time_entities(connector: Neo4jConnector, group_id: str | None, limit: int = 5) -> List[Dict[str, Any]]: + """专门搜索时间相关的实体""" + try: + date_pattern = r".*\d{4}.*|.*\d{1,2}月\d{1,2}日.*" + rows = await connector.execute_query(_TIME_ENTITY_SEARCH, + date_pattern=date_pattern, + group_id=group_id, + limit=limit) + return rows or [] + except Exception: + return [] + + +# 中英相对时间解析：today/昨天/上周/3天后 等简单归一化为日期 +def _resolve_relative_times_cn_en(text: str, anchor: datetime) -> str: + t = str(text) if text is not None else "" + # 英文 today/yesterday/tomorrow + t = re.sub(r"\btoday\b", anchor.date().isoformat(), t, flags=re.IGNORECASE) + t = re.sub(r"\byesterday\b", (anchor - timedelta(days=1)).date().isoformat(), t, flags=re.IGNORECASE) + t = re.sub(r"\btomorrow\b", (anchor + timedelta(days=1)).date().isoformat(), t, flags=re.IGNORECASE) + + # 英文 X days ago / in X days + def _ago_repl(m: re.Match[str]) -> str: + n = int(m.group(1)) + return (anchor - timedelta(days=n)).date().isoformat() + def _in_repl(m: re.Match[str]) -> str: + n = int(m.group(1)) + return (anchor + timedelta(days=n)).date().isoformat() + t = re.sub(r"\b(\d+)\s+days\s+ago\b", _ago_repl, t, flags=re.IGNORECASE) + t = re.sub(r"\bin\s+(\d+)\s+days\b", _in_repl, t, flags=re.IGNORECASE) + t = re.sub(r"\blast\s+week\b", (anchor - timedelta(days=7)).date().isoformat(), t, flags=re.IGNORECASE) + t = re.sub(r"\bnext\s+week\b", (anchor + timedelta(days=7)).date().isoformat(), t, flags=re.IGNORECASE) + + # 中文 今天/昨天/明天 + t = re.sub(r"今天", anchor.date().isoformat(), t) + t = re.sub(r"昨日|昨天", (anchor - timedelta(days=1)).date().isoformat(), t) + t = re.sub(r"明天", (anchor + timedelta(days=1)).date().isoformat(), t) + # 中文 X天前 / X天后 + t = re.sub(r"(\d+)天前", lambda m: (anchor - timedelta(days=int(m.group(1)))).date().isoformat(), t) + t = re.sub(r"(\d+)天后", lambda m: (anchor + timedelta(days=int(m.group(1)))).date().isoformat(), t) + # 中文 上周 / 下周（近似7天） + t = re.sub(r"上周", (anchor - timedelta(days=7)).date().isoformat(), t) + t = re.sub(r"下周", (anchor + timedelta(days=7)).date().isoformat(), t) + # 中文 月日（无年份）补全年份 + def _md_repl(m: re.Match[str]) -> str: + mon = int(m.group(1)); day = int(m.group(2)) + return f"{anchor.year}-{mon:02d}-{day:02d}" + t = re.sub(r"(\d{1,2})月(\d{1,2})日", _md_repl, t) + return t + + +async def run_longmemeval_test( + sample_size: int = 3, + group_id: str = "longmemeval_zh_bak_3", + search_limit: int = 8, + context_char_budget: int = 4000, + llm_temperature: float = 0.0, + llm_max_tokens: int = 16, + search_type: str = "hybrid", + data_path: str | None = None, + start_index: int = 0, + max_contexts_per_item: int = 2, + save_chunk_output: bool = True, + save_chunk_output_path: str | None = None, + reset_group_before_ingest: bool = False, + skip_ingest: bool = False, +) -> Dict[str, Any]: + """LongMemEval 评估测试：增强时间推理能力""" + + # 数据路径 + if not data_path: + # 固定使用中文数据集：data/longmemeval_oracle_zh.json + zh_proj = os.path.join(PROJECT_ROOT, "data", "longmemeval_oracle_zh.json") + zh_cwd = os.path.join(os.getcwd(), "data", "longmemeval_oracle_zh.json") + if os.path.exists(zh_proj): + data_path = zh_proj + elif os.path.exists(zh_cwd): + data_path = zh_cwd + else: + raise FileNotFoundError("未找到数据集: data/longmemeval_oracle_zh.json，请确保其存在于项目根目录或当前工作目录的 data 目录下。") + + qa_list: List[Dict[str, Any]] = load_dataset_any(data_path) + # 支持评估全部样本：当 sample_size <= 0 时，取从 start_index 到末尾 + if sample_size is None or sample_size <= 0: + items = qa_list[start_index:] + else: + items = qa_list[start_index:start_index + sample_size] + + # 可选：摄入上下文（默认启用） + if not skip_ingest: + # 选择上下文并限量 + contexts: List[str] = [] + for it in items: + built = build_context_from_sessions(it) + full_transcripts = [c for c in built if "\n" in c] + evidence_msgs = [c for c in built if "\n" not in c] + selected: List[str] = [] + take_e = min(len(evidence_msgs), max_contexts_per_item) + selected.extend(evidence_msgs[:take_e]) + remain = max_contexts_per_item - len(selected) + if remain > 0 and full_transcripts: + selected.extend(full_transcripts[:remain]) + if not selected and built: + selected.append(built[0]) + contexts.extend(selected) + + print(f"📥 摄入 {len(contexts)} 个上下文到数据库") + if reset_group_before_ingest and group_id: + try: + _tmp_conn = Neo4jConnector() + await _tmp_conn.delete_group(group_id) + print(f"🧹 已清空组 {group_id} 的历史图数据") + except Exception as _e: + print(f"⚠️ 清空组数据失败（忽略继续）: {group_id} - {_e}") + finally: + try: + await _tmp_conn.close() + except Exception: + pass + _ingest_fn = ingest_contexts_via_full_pipeline + if _ingest_fn is None: + print("⚠️ 摄入函数不可用，已跳过摄入。请确认 PYTHONPATH 包含 'src' 或从项目根运行。") + else: + await _ingest_fn( + contexts, + group_id, + save_chunk_output=save_chunk_output, + save_chunk_output_path=save_chunk_output_path, + ) + + # 初始化组件（摄入后再初始化连接器）- 使用异步LLM客户端 + llm_client = get_llm_client(SELECTED_LLM_ID) + connector = Neo4jConnector() + cfg_dict = get_embedder_config(SELECTED_EMBEDDING_ID) + embedder = OpenAIEmbedderClient( + model_config=RedBearModelConfig.model_validate(cfg_dict) + ) + + # 指标收集 + latencies_llm: List[float] = [] + latencies_search: List[float] = [] + per_query_context_counts: List[int] = [] + per_query_context_avg_tokens: List[float] = [] + per_query_context_chars: List[int] = [] + + type_correct: Dict[str, List[float]] = {} + type_f1: Dict[str, List[float]] = {} + type_jacc: Dict[str, List[float]] = {} + + samples: List[Dict[str, Any]] = [] + # 统计重复的上下文预览（跨样本），便于诊断"相同上下文"问题 + preview_counter: Dict[str, int] = {} + + try: + for item in items: + question = item.get("question", "") + reference = item.get("answer", "") + qtype = item.get("question_type") or item.get("type", "unknown") + + print(f"\n=== 处理问题: {question} ===") + + # 检测问题类型 + is_temporal = any(keyword in question.lower() for keyword in + ['days', 'day', 'before', 'after', 'first', '先后', '顺序', '间隔', '多久', '多少天']) + + # 检索 + t0 = time.time() + contexts_all: List[str] = [] + dialogs, statements, entities = [], [], [] + + try: + if search_type == "embedding": + search_results = await search_graph_by_embedding( + connector=connector, + embedder_client=embedder, + query_text=question, + group_id=group_id, + limit=search_limit, + include=["chunks", "statements", "entities", "summaries"], + ) + chunks = search_results.get("chunks", []) + statements = search_results.get("statements", []) + entities = search_results.get("entities", []) + + for d in dialogs: + content = str(d.get("content", "")).strip() + if content: + contexts_all.append(content) + for s in statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + + for sm in summaries: + summary_text = str(sm.get("summary", "")).strip() + if summary_text: + contexts_all.append(summary_text) + + # 实体摘要（最多3个） + scored = [e for e in entities if e.get("score") is not None] + top_entities = sorted(scored, key=lambda x: x.get("score", 0), reverse=True)[:3] if scored else entities[:3] + if top_entities: + summary_lines = [] + for e in top_entities: + name = str(e.get("name", "")).strip() + etype = str(e.get("entity_type", "")).strip() + score = e.get("score") + if name: + meta = [] + if etype: + meta.append(f"type={etype}") + if isinstance(score, (int, float)): + meta.append(f"score={score:.3f}") + summary_lines.append(f"EntitySummary: {name}{(' [' + '; '.join(meta) + ']') if meta else ''}") + if summary_lines: + contexts_all.append("\n".join(summary_lines)) + + elif search_type == "keyword": + search_results = await search_graph( + connector=connector, + q=question, + group_id=group_id, + limit=search_limit, + ) + chunks = search_results.get("chunks", []) + statements = search_results.get("statements", []) + entities = search_results.get("entities", []) + summaries = search_results.get("summaries", []) + + for c in chunks: + content = str(c.get("content", "")).strip() + if content: + contexts_all.append(content) + for s in statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + for sm in summaries: + summary_text = str(sm.get("summary", "")).strip() + if summary_text: + contexts_all.append(summary_text) + if entities: + entity_names = [str(e.get("name", "")).strip() for e in entities[:5] if e.get("name")] + if entity_names: + contexts_all.append(f"EntitySummary: {', '.join(entity_names)}") + + else: # hybrid（增强版：特别优化时间推理问题） + emb_chunks, emb_statements, emb_entities, emb_summaries, emb_dialogs = [], [], [], [], [] + kw_dialogs, kw_statements, kw_entities = [], [], [] + + # 1) 嵌入检索 + try: + emb_res = await search_graph_by_embedding( + connector=connector, + embedder_client=embedder, + query_text=question, + group_id=group_id, + limit=search_limit, + include=["chunks", "statements", "entities", "summaries"], + ) + if isinstance(emb_res, dict): + emb_chunks = emb_res.get("chunks", []) or [] + emb_statements = emb_res.get("statements", []) or [] + emb_entities = emb_res.get("entities", []) or [] + emb_summaries = emb_res.get("summaries", []) or [] + emb_dialogs = emb_res.get("dialogues", []) or [] + except Exception as e: + print(f"⚠️ 嵌入检索失败，将继续进行关键词检索: {e}") + + # 2) 关键词检索（增强版） + try: + kw_res = await search_graph( + connector=connector, + q=question, + group_id=group_id, + limit=search_limit, + ) + if isinstance(kw_res, dict): + kw_dialogs = kw_res.get("dialogues", []) or [] + kw_statements = kw_res.get("statements", []) or [] + kw_entities = kw_res.get("entities", []) or [] + + # 时间推理问题的特殊处理 + if is_temporal: + # 专门搜索时间实体 + time_entities = await _search_time_entities(connector, group_id, search_limit//2) + if time_entities: + kw_entities.extend(time_entities) + # 添加时间相关关键词检索 + time_keywords = ['天', '日', '月', '年', 'before', 'after', 'first'] + for tk in time_keywords: + try: + time_res = await search_graph( + connector=connector, + q=tk, + group_id=group_id, + limit=2, + ) + if isinstance(time_res, dict): + kw_dialogs.extend(time_res.get("dialogues", []) or []) + kw_statements.extend(time_res.get("statements", []) or []) + except Exception: + pass + + # 中文关键词拆分后做别名匹配 + cn_tokens = _extract_cn_tokens(question) + alias_entities = await _search_entities_by_aliases(connector, cn_tokens, group_id, search_limit) + if alias_entities: + kw_entities.extend(alias_entities) + + # 从对话/陈述中的 entity_ids 反查实体 + ids = [] + try: + for d in kw_dialogs: + ids.extend(d.get("entity_ids", []) or []) + for s in kw_statements: + ids.extend(s.get("entity_ids", []) or []) + except Exception: + pass + if ids: + id_entities = await _fetch_entities_by_ids(connector, ids, group_id) + if id_entities: + kw_entities.extend(id_entities) + + # 多关键词检索 + try: + eng_words = [w for w in set(re.findall(r"\b\w+\b", question.lower())) if len(w) > 2] + kw_list = generate_query_keywords_cn(question)[:3] + eng_words[:1] + for kw in kw_list: + if not kw: + continue + sub_res = await search_graph( + connector=connector, + q=str(kw), + group_id=group_id, + limit=max(3, search_limit // 2), + ) + if isinstance(sub_res, dict): + kw_dialogs.extend(sub_res.get("dialogues", []) or []) + kw_statements.extend(sub_res.get("statements", []) or []) + kw_entities.extend(sub_res.get("entities", []) or []) + except Exception: + pass + + # 选项参与关键词检索 + try: + opt_list = extract_candidate_options(question)[:2] + for opt in opt_list: + if not opt: + continue + opt_res = await search_graph( + connector=connector, + q=str(opt), + group_id=group_id, + limit=max(3, search_limit // 2), + ) + if isinstance(opt_res, dict): + kw_dialogs.extend(opt_res.get("dialogues", []) or []) + kw_statements.extend(opt_res.get("statements", []) or []) + kw_entities.extend(opt_res.get("entities", []) or []) + except Exception: + pass + except Exception as e: + print(f"❌ 关键词检索失败: {e}") + + # 3) 合并、排序并去重 + all_dialogs = emb_dialogs + kw_dialogs + all_statements = emb_statements + kw_statements + all_entities = emb_entities + kw_entities + + def dedup(items: List[Dict[str, Any]], key_field: str = "uuid") -> List[Dict[str, Any]]: + seen = set() + out = [] + for it in items: + key = str(it.get(key_field, "")) + str(it.get("content", "") + str(it.get("statement", ""))) + if key not in seen: + out.append(it) + seen.add(key) + return out + + # 时间推理问题优先排序包含时间信息的文档 + if is_temporal: + def temporal_score(item: Dict[str, Any]) -> float: + base_score = float(item.get("score", 0.0)) + content = str(item.get("content", "") + str(item.get("statement", ""))) + time_entities = extract_time_entities(content) + time_bonus = len(time_entities) * 0.5 + return base_score + time_bonus + + dialogs = dedup(sorted(all_dialogs, key=temporal_score, reverse=True)) + statements = dedup(sorted(all_statements, key=temporal_score, reverse=True)) + else: + dialogs = dedup(sorted(all_dialogs, key=lambda d: float(d.get("score", 0.0)), reverse=True)) + statements = dedup(sorted(all_statements, key=lambda s: float(s.get("score", 0.0)), reverse=True)) + + entities = dedup(all_entities, key_field="name") + + # 4) 构建上下文 + for d in dialogs: + content = str(d.get("content", "")).strip() + if content: + contexts_all.append(content) + for s in statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + # 实体摘要 + try: + scored = [e for e in entities if e.get("score") is not None] + top_entities = sorted(scored, key=lambda x: x.get("score", 0), reverse=True)[:3] if scored else entities[:3] + if top_entities: + summary_lines = [] + for e in top_entities: + name = str(e.get("name", "")).strip() + etype = str(e.get("entity_type", "")).strip() + score = e.get("score") + if name: + meta = [] + if etype: + meta.append(f"type={etype}") + if isinstance(score, (int, float)): + meta.append(f"score={score:.3f}") + summary_lines.append(f"EntitySummary: {name}{(' [' + '; '.join(meta) + ']') if meta else ''}") + if summary_lines: + contexts_all.append("\n".join(summary_lines)) + except Exception: + pass + + # 全局回退 + if not contexts_all and search_type in ("embedding", "hybrid"): + try: + print("🔁 检索为空，回退到关键词检索...") + kw_fallback = await search_graph( + connector=connector, + q=question, + group_id=group_id, + limit=max(search_limit, 5), + ) + fb_dialogs = kw_fallback.get("dialogues", []) or [] + fb_statements = kw_fallback.get("statements", []) or [] + fb_entities = kw_fallback.get("entities", []) or [] + + for d in fb_dialogs: + content = str(d.get("content", "")).strip() + if content: + contexts_all.append(content) + for s in fb_statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + if fb_entities: + entity_names = [str(e.get("name", "")).strip() for e in fb_entities[:5] if e.get("name")] + if entity_names: + contexts_all.append(f"EntitySummary: {', '.join(entity_names)}") + + dialogs = fb_dialogs if fb_dialogs else dialogs + statements = fb_statements if fb_statements else statements + entities = fb_entities if fb_entities else entities + print(f"↩️ 回退到关键词检索: {len(fb_dialogs)} 对话, {len(fb_statements)} 条陈述, {len(fb_entities)} 个实体") + except Exception as fe: + print(f"❌ 关键词回退失败: {fe}") + + ent_count = len(entities) if isinstance(entities, list) else 0 + print(f"✅ {search_type}检索成功: {len(dialogs)} 对话, {len(statements)} 条陈述, {ent_count} 个实体") + if is_temporal: + print("⏰ 检测为时间推理问题，已启用时间优化检索") + + except Exception as e: + print(f"❌ {search_type}检索失败: {e}") + contexts_all = [] + + t1 = time.time() + latencies_search.append((t1 - t0) * 1000) + + # 智能上下文选择 + context_text = "" + if contexts_all: + context_text = smart_context_selection(contexts_all, question, max_chars=context_char_budget) + # 相对时间解析 + try: + context_text = _resolve_relative_times_cn_en(context_text, anchor=datetime.now()) + except Exception: + pass + # 诊断信息 + try: + cn_diag = generate_query_keywords_cn(question)[:3] + opts = extract_candidate_options(question)[:2] + qlw = [w for w in set(re.findall(r'\b\w+\b', question.lower())) if len(w) > 2][:1] + diag_tokens: List[str] = [] + for t in cn_diag + opts + qlw: + if t and t not in diag_tokens: + diag_tokens.append(t) + print(f"🔍 关键词/选项: {', '.join(diag_tokens)}") + preview = context_text[:200].replace('\n', ' ') + print(f"🔎 上下文预览: {preview}...") + key_preview = preview.strip() + if key_preview: + preview_counter[key_preview] = preview_counter.get(key_preview, 0) + 1 + except Exception: + pass + else: + print("❌ 没有检索到有效上下文") + context_text = "No relevant context found." + + # 记录上下文诊断信息 + per_query_context_counts.append(len(contexts_all)) + per_query_context_avg_tokens.append(avg_context_tokens([context_text])) + per_query_context_chars.append(len(context_text)) + + # LLM 推理（增强时间推理提示） + options = extract_candidate_options(question) + if len(options) >= 2: + opt_lines = "\n".join(f"- {o}" for o in options) + # 时间推理问题的特殊提示 + if is_temporal: + system_prompt = ( + "You are a QA assistant specializing in temporal reasoning. Analyze the dates and time relationships in the context carefully. " + "Return ONLY one string: exactly one option from the provided candidates. If the context is insufficient, respond with 'Unknown'. " + "Pay special attention to date sequences and time intervals." + ) + else: + system_prompt = ( + "You are a QA assistant. Respond in the same language as the question. Return ONLY one string: exactly one option from the provided candidates. " + "If the context is insufficient, respond with 'Unknown'. If the context expresses a synonym or paraphrase of a candidate, return the closest candidate. " + "Do not include explanations." + ) + + messages = [ + {"role": "system", "content": system_prompt}, + { + "role": "user", + "content": ( + f"Question: {question}\n\nCandidates:\n{opt_lines}\n\nContext:\n{context_text}\n\nReturn EXACTLY one candidate string (or 'Unknown')." + ), + }, + ] + else: + # 时间推理问题的特殊提示 + if is_temporal: + system_prompt = ( + "You are a QA assistant specializing in temporal reasoning. Analyze the dates and time relationships in the context carefully. " + "If the context contains the answer, return a concise answer phrase focusing on temporal information. " + "If the answer cannot be determined from the context, respond with 'Unknown'. Return ONLY the final answer string, no explanations." + ) + else: + system_prompt = ( + "You are a QA assistant. Respond in the same language as the question. If the context contains the answer, return a concise answer phrase. " + "If the answer cannot be determined from the context, respond with 'Unknown'. Return ONLY the final answer string, no explanations." + ) + + messages = [ + {"role": "system", "content": system_prompt}, + { + "role": "user", + "content": f"Question: {question}\n\nContext:\n{context_text}\n\nReturn ONLY the answer (or 'Unknown').", + }, + ] + + t2 = time.time() + # 使用异步调用 + resp = await llm_client.chat(messages=messages) + t3 = time.time() + latencies_llm.append((t3 - t2) * 1000) + + # 兼容不同的响应格式 + pred_raw = resp.content.strip() if hasattr(resp, 'content') else (resp["choices"][0]["message"]["content"].strip() if isinstance(resp, dict) else "Unknown") + + # 选项题输出规范化 + pred = pred_raw + if len(options) >= 2 and not pred_raw.lower().startswith("unknown"): + def _basic_norm(s: str) -> str: + s = s.lower().strip() + return re.sub(r"[^\w\s]", " ", s) + def _jaccard(a: str, b: str) -> float: + ta = set(t for t in _basic_norm(a).split() if t) + tb = set(t for t in _basic_norm(b).split() if t) + if not ta and not tb: + return 1.0 + if not ta or not tb: + return 0.0 + return len(ta & tb) / len(ta | tb) + best = None + best_score = -1.0 + for o in options: + score = _jaccard(pred_raw, o) + if score > best_score: + best = o + best_score = score + if best is not None and best_score > 0.0: + pred = best + + # 指标 + flag = exact_match(pred, reference) + f1_val = common_f1(str(pred), str(reference)) + j_val = jaccard(str(pred), str(reference)) + + type_correct.setdefault(qtype, []).append(flag) + type_f1.setdefault(qtype, []).append(f1_val) + type_jacc.setdefault(qtype, []).append(j_val) + + samples.append({ + "question": question, + "prediction": pred, + "answer": reference, + "question_type": qtype, + "is_temporal": is_temporal, + "question_id": item.get("question_id"), + "options": options, + "context_count": len(contexts_all), + "context_chars": len(context_text), + "retrieved_dialogue_count": len(dialogs), + "retrieved_statement_count": len(statements), + "metrics": { + "exact_match": bool(flag), + "f1": f1_val, + "jaccard": j_val + }, + "timing": { + "search_ms": (t1 - t0) * 1000, + "llm_ms": (t3 - t2) * 1000 + } + }) + + print(f"🤖 LLM 回答: {pred}") + print(f"✅ 正确答案: {reference}") + print(f"📈 当前指标 - Exact Match: {flag}, F1: {f1_val:.3f}, Jaccard: {j_val:.3f}") + + # 聚合结果 + type_acc = {t: (sum(v) / max(len(v), 1)) for t, v in type_correct.items()} + f1_by_type = {t: (sum(v) / max(len(v), 1)) for t, v in type_f1.items()} + jacc_by_type = {t: (sum(v) / max(len(v), 1)) for t, v in type_jacc.items()} + + result = { + "dataset": "longmemeval", + "items": len(items), + "accuracy_by_type": type_acc, + "f1_by_type": f1_by_type, + "jaccard_by_type": jacc_by_type, + "samples": samples, + "latency": { + "search": latency_stats(latencies_search), + "llm": latency_stats(latencies_llm), + }, + "context": { + "avg_tokens": statistics.mean(per_query_context_avg_tokens) if per_query_context_avg_tokens else 0.0, + "avg_chars": statistics.mean(per_query_context_chars) if per_query_context_chars else 0.0, + "count_avg": statistics.mean(per_query_context_counts) if per_query_context_counts else 0.0, + }, + "params": { + "group_id": group_id, + "search_limit": search_limit, + "context_char_budget": context_char_budget, + "search_type": search_type, + "llm_id": SELECTED_LLM_ID, + "embedding_id": SELECTED_EMBEDDING_ID, + "sample_size": sample_size, + "start_index": start_index, + }, + "timestamp": datetime.now().isoformat() + } + + # 计算汇总指标 + try: + total_items = max(len(samples), 1) + correct_count = sum(1 for s in samples if s.get("metrics", {}).get("exact_match")) + score_accuracy = (correct_count / total_items) * 100.0 + + total_latencies_ms = [] + for s in samples: + t = s.get("timing", {}) + total_latencies_ms.append(float(t.get("search_ms", 0.0)) + float(t.get("llm_ms", 0.0))) + total_lat_stats = latency_stats(total_latencies_ms) if total_latencies_ms else {"p50": 0.0, "iqr": 0.0} + latency_median_s = total_lat_stats.get("p50", 0.0) / 1000.0 + latency_iqr_s = total_lat_stats.get("iqr", 0.0) / 1000.0 + + avg_ctx_tokens = statistics.mean(per_query_context_avg_tokens) if per_query_context_avg_tokens else 0.0 + avg_ctx_tokens_k = avg_ctx_tokens / 1000.0 + + result["metric_summary"] = { + "score_accuracy": score_accuracy, + "latency_median_s": latency_median_s, + "latency_iqr_s": latency_iqr_s, + "avg_context_tokens_k": avg_ctx_tokens_k, + } + except Exception: + result["metric_summary"] = { + "score_accuracy": 0.0, + "latency_median_s": 0.0, + "latency_iqr_s": 0.0, + "avg_context_tokens_k": 0.0, + } + + # 诊断信息 + try: + dups = sorted([(k, c) for k, c in preview_counter.items() if c > 1], key=lambda x: -x[1])[:5] + result["diagnostics"] = { + "duplicate_previews_top": [{"count": c, "preview": k[:120]} for k, c in dups], + "unique_preview_count": len(preview_counter), + } + except Exception: + pass + + return result + + finally: + await connector.close() + +def main(): + load_dotenv() + parser = argparse.ArgumentParser(description="LongMemEval 评估测试脚本（增强时间推理版）") + parser.add_argument("--sample-size", type=int, default=3, help="样本数量（<=0 表示全部）") + parser.add_argument("--all", action="store_true", help="评估全部样本（覆盖 --sample-size）") + parser.add_argument("--start-index", type=int, default=0, help="起始样本索引") + parser.add_argument("--group-id", type=str, default="longmemeval_zh_bak_3", help="图数据库 Group ID") + parser.add_argument("--search-limit", type=int, default=8, help="检索条数上限") + parser.add_argument("--context-char-budget", type=int, default=4000, help="上下文字符预算") + parser.add_argument("--llm-temperature", type=float, default=0.0, help="LLM 温度") + parser.add_argument("--llm-max-tokens", type=int, default=16, help="LLM 最大输出 token") + parser.add_argument("--search-type", type=str, default="hybrid", choices=["embedding","keyword","hybrid"], help="检索类型") + parser.add_argument("--data-path", type=str, default=None, help="数据集路径") + parser.add_argument("--max-contexts-per-item", type=int, default=2, help="每条样本最多摄入的上下文段数") + parser.add_argument("--no-save-chunk-output", action="store_true", help="不保存分块结果（默认保存）") + parser.add_argument("--save-chunk-output-path", type=str, default=None, help="自定义分块输出路径") + parser.add_argument("--reset-group-before-ingest", action="store_true", help="摄入前清空该 Group 在图数据库中的历史数据") + parser.add_argument("--skip-ingest", action="store_true", help="跳过摄入，仅检索评估") + args = parser.parse_args() + + sample_size = 0 if args.all else args.sample_size + + result = asyncio.run( + run_longmemeval_test( + sample_size=sample_size, + group_id=args.group_id, + search_limit=args.search_limit, + context_char_budget=args.context_char_budget, + llm_temperature=args.llm_temperature, + llm_max_tokens=args.llm_max_tokens, + search_type=args.search_type, + data_path=args.data_path, + start_index=args.start_index, + max_contexts_per_item=args.max_contexts_per_item, + save_chunk_output=(not args.no_save_chunk_output), + save_chunk_output_path=args.save_chunk_output_path, + reset_group_before_ingest=args.reset_group_before_ingest, + skip_ingest=args.skip_ingest, + ) + ) + + # 打印结果 + print("\n" + "="*50) + print("📊 LongMemEval 测试结果:") + print(f" 样本数量: {result['items']}") + + if result['accuracy_by_type']: + print("\n📈 按问题类型细分:") + for qtype, acc in result['accuracy_by_type'].items(): + print(f" {qtype}:") + print(f" Score (Accuracy): {acc:.3f}") + + print(f"\n📊 指标总览:") + ms = result.get('metric_summary', {}) + print(f" Score (Accuracy): {ms.get('score_accuracy', 0.0):.1f}%") + print(f" Latency (s): median {ms.get('latency_median_s', 0.0):.3f}s") + print(f" Latency IQR (s): {ms.get('latency_iqr_s', 0.0):.3f}s") + print(f" Avg Context Tokens (k): {ms.get('avg_context_tokens_k', 0.0):.3f}k") + + print(f"\n⏱️ 细分性能指标:") + print(f" 检索延迟(均值): {result['latency']['search']['mean']:.1f}ms") + print(f" LLM延迟(均值): {result['latency']['llm']['mean']:.1f}ms") + print(f" 上下文长度(均值): {result['context']['avg_chars']:.0f} 字符") + + + # 保存结果到文件 + try: + out_dir = os.path.join(PROJECT_ROOT, "evaluation", "longmemeval", "results") + os.makedirs(out_dir, exist_ok=True) + ts = datetime.now().strftime("%Y%m%d_%H%M%S") + out_path = os.path.join(out_dir, f"longmemeval_{result['params']['search_type']}_{ts}.json") + with open(out_path, "w", encoding="utf-8") as f: + json.dump(result, f, ensure_ascii=False, indent=2) + print(f"\n💾 结果已保存: {out_path}") + except Exception as e: + print(f"⚠️ 结果保存失败: {e}") + + +if __name__ == "__main__": + main() diff --git a/api/app/core/memory/evaluation/longmemeval/test_eval.py b/api/app/core/memory/evaluation/longmemeval/test_eval.py new file mode 100644 index 00000000..550de2d2 --- /dev/null +++ b/api/app/core/memory/evaluation/longmemeval/test_eval.py @@ -0,0 +1,1315 @@ +import argparse +import asyncio +import json +import os +import time +import re +import statistics +from datetime import datetime, timedelta +from typing import List, Dict, Any + +try: + from dotenv import load_dotenv +except Exception: + def load_dotenv(): + return None + +# 与现有评估脚本保持一致的导入方式 +from app.repositories.neo4j.neo4j_connector import Neo4jConnector +from app.repositories.neo4j.graph_search import search_graph, search_graph_by_embedding +from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient +from app.core.models.base import RedBearModelConfig +from app.core.memory.utils.config_utils import get_embedder_config +from app.core.memory.utils.llm_utils import get_llm_client +from app.core.memory.evaluation.dialogue_queries import SEARCH_ENTITIES_BY_NAME +from app.core.memory.utils.config.definitions import PROJECT_ROOT, SELECTED_LLM_ID, SELECTED_EMBEDDING_ID +from app.core.memory.evaluation.common.metrics import f1_score as common_f1, jaccard, latency_stats, avg_context_tokens +try: + from app.core.memory.evaluation.common.metrics import exact_match +except Exception: + # 兜底：简单的大小写不敏感比较 + def exact_match(pred: str, ref: str) -> bool: + return str(pred).strip().lower() == str(ref).strip().lower() + + +def load_dataset_any(path: str) -> List[Dict[str, Any]]: + """健壮地加载数据集（兼容 list 或多段 JSON）。""" + with open(path, "r", encoding="utf-8") as f: + s = f.read().strip() + try: + obj = json.loads(s) + if isinstance(obj, list): + return obj + elif isinstance(obj, dict): + return [obj] + except json.JSONDecodeError: + pass + dec = json.JSONDecoder() + idx = 0 + items: List[Dict[str, Any]] = [] + while idx < len(s): + while idx < len(s) and s[idx].isspace(): + idx += 1 + if idx >= len(s): + break + try: + obj, end = dec.raw_decode(s, idx) + if isinstance(obj, list): + for it in obj: + if isinstance(it, dict): + items.append(it) + elif isinstance(obj, dict): + items.append(obj) + idx = end + except json.JSONDecodeError: + nl = s.find("\n", idx) + if nl == -1: + break + idx = nl + 1 + return items + + +def is_chinese_text(s: str) -> bool: + return bool(re.search(r"[\u4e00-\u9fff]", s or "")) + + +def extract_candidate_options(question: str) -> List[str]: + """从问题中提取候选选项（A-or-B 类问题）。""" + q = (question or "").strip() + options: List[str] = [] + + # 1) 引号包裹的片段 + for pat in [r"'([^']+)'", r'\"([^\"]+)\"', r'“([^”]+)”', r'‘([^’]+)’']: + for m in re.findall(pat, q): + val = (m or "").strip() + if val: + options.append(val) + + # 2) or/还是/或者 连接词 + if len(options) < 2: + pats = [ + r"([^,;，；]+?)\s+or\s+([^,;，；\?\.!.。！]+)", + r"([^,;，；]+?)\s+还是\s+([^,;，；\?\.!.。！]+)", + r"([^,;，；]+?)\s+或者\s+([^,;，；\?\.!.。！]+)", + ] + for pat in pats: + matches = list(re.finditer(pat, q, flags=re.IGNORECASE)) + if matches: + m = matches[-1] + cand1 = m.group(1).strip().strip("?？.,，;； ") + cand2 = m.group(2).strip().strip("?？.,，;； ") + options.extend([cand1, cand2]) + break + + # 去重 + seen = set() + uniq: List[str] = [] + for o in options: + o2 = o.strip() + key = o2.lower() if not is_chinese_text(o2) else o2 + if o2 and key not in seen: + uniq.append(o2) + seen.add(key) + return uniq + + +def extract_time_entities(text: str) -> List[Dict[str, Any]]: + """增强时间实体提取，专门用于时间推理问题""" + time_entities = [] + + # 日期模式 + date_patterns = [ + (r'\b(\d{4})-(\d{1,2})-(\d{1,2})\b', 'date'), # YYYY-MM-DD + (r'\b(\d{1,2})月(\d{1,2})日\b', 'date'), # 中文日期 + (r'\b(January|February|March|April|May|June|July|August|September|October|November|December)\s+(\d{1,2}),?\s+(\d{4})?', 'date'), # 英文月份 + (r'\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(\d{1,2}),?\s+(\d{4})?', 'date'), # 英文月份缩写 + ] + + # 时间间隔模式 + duration_patterns = [ + (r'(\d+)\s*天', 'days'), + (r'(\d+)\s*周', 'weeks'), + (r'(\d+)\s*个月', 'months'), + (r'(\d+)\s*年', 'years'), + (r'(\d+)\s*days?', 'days'), + (r'(\d+)\s*weeks?', 'weeks'), + (r'(\d+)\s*months?', 'months'), + (r'(\d+)\s*years?', 'years'), + ] + + # 事件时间关系模式 + temporal_relation_patterns = [ + (r'(之前|以前|前)\s*(\d+)\s*天', 'days_before'), + (r'(之后|以后|后)\s*(\d+)\s*天', 'days_after'), + (r'(\d+)\s*天\s*(之前|以前|前)', 'days_before'), + (r'(\d+)\s*天\s*(之后|以后|后)', 'days_after'), + (r'(\d+)\s*days?\s*(before|ago)', 'days_before'), + (r'(\d+)\s*days?\s*(after|later)', 'days_after'), + ] + + # 提取日期 + for pattern, entity_type in date_patterns: + matches = re.finditer(pattern, text, re.IGNORECASE) + for match in matches: + time_entities.append({ + 'text': match.group(), + 'type': entity_type, + 'start': match.start(), + 'end': match.end() + }) + + # 提取时间间隔 + for pattern, entity_type in duration_patterns: + matches = re.finditer(pattern, text, re.IGNORECASE) + for match in matches: + time_entities.append({ + 'text': match.group(), + 'type': entity_type, + 'value': int(match.group(1)), + 'start': match.start(), + 'end': match.end() + }) + + # 提取时间关系 + for pattern, entity_type in temporal_relation_patterns: + matches = re.finditer(pattern, text, re.IGNORECASE) + for match in matches: + time_entities.append({ + 'text': match.group(), + 'type': entity_type, + 'value': int(match.group(2)) if match.groups() >= 2 else int(match.group(1)), + 'start': match.start(), + 'end': match.end() + }) + + return time_entities + + +def calculate_time_difference(date1: str, date2: str) -> int: + """计算两个日期之间的天数差""" + try: + # 解析日期格式 + def parse_date(date_str: str) -> datetime: + # 尝试多种日期格式 + formats = [ + '%Y-%m-%d', + '%m月%d日', + '%B %d, %Y', + '%b %d, %Y', + '%Y年%m月%d日' + ] + + for fmt in formats: + try: + return datetime.strptime(date_str, fmt) + except ValueError: + continue + + # 如果都无法解析，返回当前日期 + return datetime.now() + + d1 = parse_date(date1) + d2 = parse_date(date2) + + # 计算天数差（绝对值） + return abs((d2 - d1).days) + except Exception: + return -1 # 表示计算失败 + + +def _extract_cn_tokens(text: str) -> List[str]: + """中文关键词提取（短语级，含数词/日期/常见领域词）""" + if not text: + return [] + t = str(text) + # 去掉常见功能词（粗略，不依赖分词库） + stop_words = [ + "我","我们","你","他","她","它","这","那","哪","一个","一次","一些","什么","怎么","是否","吗","呢", + "很","更","最","已经","正在","将要","马上","尽快","最近","关于","有关","以及","并且","或者","还是", + "因为","所以","如果","但是","而且","然后","之后","之前","同时","另外","并","但","却","被","把","让","给", + "和","与","跟","及","还有","就","都","在","对","对于","的","了","着","过","到","于","从","以","为","向","至","是" + ] + for sw in stop_words: + t = t.replace(sw, " ") + # 去标点 + t = re.sub(r"[，。！？、；：,.!?;:\"'（）()［］\[\]\-—…·]", " ", t) + # 基础中文片段（>=2） + base = re.findall(r"[\u4e00-\u9fff]{2,}", t) + # 特殊组合：第X次XXXX + specials = re.findall(r"第[一二三四五六七八九十]+次[\u4e00-\u9fff]{2,6}", text) + # 日期与数字 + dates = re.findall(r"\d{4}年\d{1,2}月\d{1,2}日|\d{1,2}月\d{1,2}日|\d{4}-\d{1,2}-\d{1,2}", text) + numbers = re.findall(r"\b\d+\b", text) + + generic = {"建议","推荐","帮助","提升","技能","有效","团队","参与度","喜欢","开始"} + tokens: List[str] = specials + base + dates + numbers + uniq: List[str] = [] + seen = set() + for tok in tokens: + tok2 = tok.strip() + if len(tok2) < 2 or len(tok2) > 6: + continue + if tok2 in generic: + continue + if tok2 not in seen: + uniq.append(tok2) + seen.add(tok2) + # 排除常见疑问型短语 + blacklist_exact = {"是什么","多少","多少天","哪个","哪些","之间","先","后","之前","之后"} + uniq2: List[str] = [u for u in uniq if u not in blacklist_exact] + return uniq2[:12] + + +def generate_query_keywords_cn(question: str) -> List[str]: + """增强版关键词提取，特别关注技术术语和专有名词""" + if not question: + return [] + + # 提取专有名词（带引号的内容） + quoted_terms = re.findall(r'["""]([^"""]+)["""]', question) + + # 提取技术术语（中英文混合） + tech_terms = re.findall(r'[A-Z][a-zA-Z]+\s+[A-Z][a-zA-Z]+|[A-Za-z]+[\u4e00-\u9fff]+|[\u4e00-\u9fff]+[A-Za-z]+', question) + + # 提取核心名词短语 + core_nouns = re.findall(r'[\u4e00-\u9fff]{2,5}系统|[\u4e00-\u9fff]{2,5}管理|[\u4e00-\u9fff]{2,5}分析|[\u4e00-\u9fff]{2,5}工作坊|[\u4e00-\u9fff]{2,5}研讨会', question) + + # 基础中文片段 + base_tokens = _extract_cn_tokens(question) + + # 特定领域关键词增强 + domain_keywords = [] + # GPS相关 + if any(term in question for term in ["GPS", "导航", "定位系统", "系统运行"]): + domain_keywords.extend(["GPS", "导航系统", "定位", "系统故障", "功能异常"]) + # 活动相关 + if any(term in question for term in ["工作坊", "研讨会", "网络研讨会", "活动"]): + domain_keywords.extend(["工作坊", "研讨会", "参加", "参与", "活动"]) + # 时间顺序相关 + if any(term in question for term in ["先", "后", "第一个", "之前", "首先"]): + domain_keywords.extend(["先", "后", "之前", "之后", "第一次", "首先"]) + # 设备相关 + if any(term in question for term in ["设备", "手机", "电脑", "笔记本电脑"]): + domain_keywords.extend(["设备", "手机", "电脑", "笔记本电脑", "购买"]) + + # 合并并去重 + all_tokens = quoted_terms + tech_terms + core_nouns + base_tokens + domain_keywords + seen = set() + final_tokens = [] + + for token in all_tokens: + token = token.strip() + if len(token) >= 2 and token not in seen: + final_tokens.append(token) + seen.add(token) + + return final_tokens[:8] + + +def smart_context_selection(contexts: List[str], question: str, max_chars: int = 4000) -> str: + """增强版上下文选择：特别优化技术术语和精确匹配""" + if not contexts: + return "" + + # 检测是否为时间推理问题 + is_temporal_question = any(keyword in question.lower() for keyword in + ['days', 'day', 'before', 'after', 'first', '先后', '顺序', '间隔', '多久', '多少天']) + + # 提取时间实体从问题中 + question_time_entities = extract_time_entities(question) + + # 提取关键技术实体 + key_entities = [] + # GPS相关 + if any(term in question for term in ["GPS", "导航", "定位系统", "系统运行"]): + key_entities.extend(["GPS", "导航", "定位", "系统", "功能", "问题", "故障"]) + # 活动相关 + if any(term in question for term in ["工作坊", "研讨会", "网络研讨会", "活动"]): + key_entities.extend(["工作坊", "研讨会", "参加", "参与", "活动", "时间"]) + # 时间顺序相关 + if any(term in question for term in ["先", "后", "第一个", "之前", "首先"]): + key_entities.extend(["先", "后", "之前", "之后", "第一次", "首先"]) + + # 英文关键词（去停用词） + question_lower = question.lower() + stop_words = { + 'what','when','where','who','why','how','did','do','does','is','are','was','were', + 'the','a','an','and','or','but','many','which','first' + } + eng_words = [w for w in set(re.findall(r'\b\w+\b', question_lower)) + if w not in stop_words and len(w) > 2] + + # 中文片段与候选选项 + cn_tokens = generate_query_keywords_cn(question) + options = extract_candidate_options(question) + + # 时间推理问题的特殊处理 + if is_temporal_question: + # 为时间问题添加时间相关关键词 + time_keywords = ['天', '日', '月', '年', 'before', 'after', 'days', 'first', '先后'] + eng_words = [w for w in eng_words if w not in ['days', 'first']] # 避免重复 + cn_tokens.extend([kw for kw in time_keywords if kw not in cn_tokens]) + + # 限制关键词数量，优先时间相关 + tokens = time_keywords[:2] + key_entities[:3] + cn_tokens[:2] + eng_words[:1] + options[:1] + else: + # 常规问题处理，优先关键技术实体 + tokens = key_entities[:4] + cn_tokens[:3] + options[:2] + eng_words[:1] + + # 去重 + seen = set() + final_tokens: List[str] = [] + for t in tokens: + t2 = t.strip() + if t2 and t2 not in seen: + final_tokens.append(t2) + seen.add(t2) + + scored_contexts: List[tuple[float, str]] = [] + + # 关键技术实体权重映射 + key_entity_weights = { + "GPS": 3.0, "导航": 2.5, "系统": 2.0, "功能": 2.0, "问题": 2.0, "故障": 2.5, + "工作坊": 2.5, "研讨会": 2.5, "参加": 2.0, "参与": 2.0, + "先": 2.0, "后": 2.0, "之前": 2.0, "之后": 2.0, "第一次": 2.5 + } + + # 时间推理问题的权重映射 + temporal_weight_map = { + "天": 2.0, "日": 2.0, "月": 1.8, "年": 1.8, "days": 2.0, + "before": 1.5, "after": 1.5, "first": 1.5, "先后": 1.5 + } + + # 常规问题的权重映射 + normal_weight_map = { + "问题": 2.0, "故障": 2.0, "异常": 1.8, "不正常": 1.8, "坏了": 1.8, + "系统": 1.3, "GPS": 1.5, "保养": 1.4, "设备": 1.2, "模块": 1.2, "功能": 1.1 + } + + # 合并权重映射 + weight_map = {**normal_weight_map, **temporal_weight_map, **key_entity_weights} + + for i, context in enumerate(contexts): + context_str = str(context) + lines = re.split(r'[\r\n]+', context_str) + hit_lines: List[str] = [] + kw_hits: float = 0.0 + time_entity_count = 0 + key_entity_hits = 0 + + for line in lines: + ln = line.strip() + if not ln: + continue + + has_keyword = False + # 关键词匹配 + for tok in final_tokens: + if tok and tok in ln: + w = weight_map.get(tok, 1.0) + hit_count = ln.count(tok) + kw_hits += hit_count * w + # 关键技术实体额外奖励 + if tok in key_entity_weights: + key_entity_hits += hit_count + has_keyword = True + + # 时间实体检测（特别针对时间推理问题） + if is_temporal_question: + time_entities = extract_time_entities(ln) + time_entity_count += len(time_entities) + if time_entities: + has_keyword = True + + # 精确匹配奖励（完整问题关键词出现在上下文中） + for q_word in question.split(): + if len(q_word) > 3 and q_word in ln: + kw_hits += 0.5 # 精确匹配奖励 + + if has_keyword: + # 对于包含关键信息的行，保留完整行 + hit_lines.append(ln) + + snippet = "\n".join(hit_lines) if hit_lines else context_str.strip() + + # 限制单段长度，但对包含关键信息的上下文稍微放宽限制 + max_snippet_len = 600 if (key_entity_hits > 0 or time_entity_count > 0) else 500 + if len(snippet) > max_snippet_len: + snippet = snippet[:max_snippet_len] + + # 评分逻辑 + has_number = 1 if re.search(r'\d', snippet) else 0 + has_date = 1 if (re.search(r'\b\d{4}-\d{1,2}-\d{1,2}\b', snippet) or + re.search(r'\d{1,2}月\d{1,2}日', snippet)) else 0 + + # 关键技术实体奖励 + key_entity_bonus = key_entity_hits * 1.0 + + # 时间推理问题的特殊评分 + if is_temporal_question: + time_bonus = time_entity_count * 2.0 # 时间实体奖励 + temporal_coherence = 3 if (has_date and time_entity_count >= 2) else 0 + else: + time_bonus = 0 + temporal_coherence = 0 + + length_bonus = 5 if 50 < len(snippet) < 1000 else (2 if len(snippet) >= 1000 else 0) + pos_bonus = 3 if i < 3 else 0 + + score = (kw_hits * 0.8 + (has_number + has_date) * 1.5 + + length_bonus + pos_bonus + time_bonus + temporal_coherence + key_entity_bonus) + + scored_contexts.append((score, snippet)) + + # 选择累计至总字符预算 + scored_contexts.sort(key=lambda x: x[0], reverse=True) + selected: List[str] = [] + total_chars = 0 + + for score, snippet in scored_contexts: + if total_chars + len(snippet) <= max_chars: + selected.append(snippet) + total_chars += len(snippet) + else: + if not selected and len(snippet) > max_chars: + selected.append(snippet[:max_chars]) + break + + final_context = "\n\n".join(selected) + + # 对于时间推理问题，添加时间计算提示 + if is_temporal_question and question_time_entities: + time_prompt = "\n\n[时间推理提示：请仔细分析上述上下文中的日期和时间关系，计算时间间隔或确定事件顺序]" + if total_chars + len(time_prompt) <= max_chars: + final_context += time_prompt + + return final_context + + +# 通过别名匹配进行实体关键词检索（多token合并） +async def _search_entities_by_aliases(connector: Neo4jConnector, tokens: List[str], group_id: str | None, limit: int) -> List[Dict[str, Any]]: + results: List[Dict[str, Any]] = [] + try: + for tok in tokens: + rows = await connector.execute_query(SEARCH_ENTITIES_BY_NAME, q=tok, group_id=group_id, limit=limit) + if rows: + results.extend(rows) + except Exception: + pass + + # 按 name 去重 + deduped: List[Dict[str, Any]] = [] + seen = set() + for r in results: + k = str(r.get("name", "")) + if k and k not in seen: + deduped.append(r) + seen.add(k) + return deduped + + +# 通过对话/陈述中的entity_ids反查实体名称 +_FETCH_ENTITIES_BY_IDS = """ +MATCH (e:ExtractedEntity) +WHERE e.id IN $ids AND ($group_id IS NULL OR e.group_id = $group_id) +RETURN e.id AS id, e.name AS name, e.group_id AS group_id, e.entity_type AS entity_type +""" + +async def _fetch_entities_by_ids(connector: Neo4jConnector, ids: List[str], group_id: str | None) -> List[Dict[str, Any]]: + if not ids: + return [] + try: + rows = await connector.execute_query(_FETCH_ENTITIES_BY_IDS, ids=list({i for i in ids if i}), group_id=group_id) + return rows or [] + except Exception: + return [] + + +# 增强的时间实体检索 +_TIME_ENTITY_SEARCH = """ +MATCH (e:ExtractedEntity) +WHERE e.entity_type CONTAINS "TIME" OR e.entity_type CONTAINS "DATE" OR e.name =~ $date_pattern +AND ($group_id IS NULL OR e.group_id = $group_id) +RETURN e.id AS id, e.name AS name, e.group_id AS group_id, e.entity_type AS entity_type +LIMIT $limit +""" + +async def _search_time_entities(connector: Neo4jConnector, group_id: str | None, limit: int = 5) -> List[Dict[str, Any]]: + """专门搜索时间相关的实体""" + try: + date_pattern = r".*\d{4}.*|.*\d{1,2}月\d{1,2}日.*" + rows = await connector.execute_query(_TIME_ENTITY_SEARCH, + date_pattern=date_pattern, + group_id=group_id, + limit=limit) + return rows or [] + except Exception: + return [] + + +# 技术术语专门检索 +async def _search_tech_terms(connector: Neo4jConnector, question: str, group_id: str | None, limit: int = 3) -> List[Dict[str, Any]]: + """专门搜索技术术语相关的实体""" + tech_entities = [] + try: + # GPS相关 + if any(term in question for term in ["GPS", "导航", "定位系统"]): + gps_rows = await connector.execute_query(SEARCH_ENTITIES_BY_NAME, q="GPS", group_id=group_id, limit=limit) + if gps_rows: + tech_entities.extend(gps_rows) + + # 活动相关 + if any(term in question for term in ["工作坊", "研讨会", "网络研讨会"]): + workshop_rows = await connector.execute_query(SEARCH_ENTITIES_BY_NAME, q="工作坊", group_id=group_id, limit=limit) + if workshop_rows: + tech_entities.extend(workshop_rows) + + # 时间顺序相关 + if any(term in question for term in ["先", "后", "第一个"]): + time_rows = await connector.execute_query(SEARCH_ENTITIES_BY_NAME, q="第一次", group_id=group_id, limit=limit) + if time_rows: + tech_entities.extend(time_rows) + + except Exception: + pass + + return tech_entities + + +# 中英相对时间解析：today/昨天/上周/3天后 等简单归一化为日期 +def _resolve_relative_times_cn_en(text: str, anchor: datetime) -> str: + t = str(text) if text is not None else "" + # 英文 today/yesterday/tomorrow + t = re.sub(r"\btoday\b", anchor.date().isoformat(), t, flags=re.IGNORECASE) + t = re.sub(r"\byesterday\b", (anchor - timedelta(days=1)).date().isoformat(), t, flags=re.IGNORECASE) + t = re.sub(r"\btomorrow\b", (anchor + timedelta(days=1)).date().isoformat(), t, flags=re.IGNORECASE) + + # 英文 X days ago / in X days + def _ago_repl(m: re.Match[str]) -> str: + n = int(m.group(1)) + return (anchor - timedelta(days=n)).date().isoformat() + def _in_repl(m: re.Match[str]) -> str: + n = int(m.group(1)) + return (anchor + timedelta(days=n)).date().isoformat() + t = re.sub(r"\b(\d+)\s+days\s+ago\b", _ago_repl, t, flags=re.IGNORECASE) + t = re.sub(r"\bin\s+(\d+)\s+days\b", _in_repl, t, flags=re.IGNORECASE) + t = re.sub(r"\blast\s+week\b", (anchor - timedelta(days=7)).date().isoformat(), t, flags=re.IGNORECASE) + t = re.sub(r"\bnext\s+week\b", (anchor + timedelta(days=7)).date().isoformat(), t, flags=re.IGNORECASE) + + # 中文 今天/昨天/明天 + t = re.sub(r"今天", anchor.date().isoformat(), t) + t = re.sub(r"昨日|昨天", (anchor - timedelta(days=1)).date().isoformat(), t) + t = re.sub(r"明天", (anchor + timedelta(days=1)).date().isoformat(), t) + # 中文 X天前 / X天后 + t = re.sub(r"(\d+)天前", lambda m: (anchor - timedelta(days=int(m.group(1)))).date().isoformat(), t) + t = re.sub(r"(\d+)天后", lambda m: (anchor + timedelta(days=int(m.group(1)))).date().isoformat(), t) + # 中文 上周 / 下周（近似7天） + t = re.sub(r"上周", (anchor - timedelta(days=7)).date().isoformat(), t) + t = re.sub(r"下周", (anchor + timedelta(days=7)).date().isoformat(), t) + # 中文 月日（无年份）补全年份 + def _md_repl(m: re.Match[str]) -> str: + mon = int(m.group(1)); day = int(m.group(2)) + return f"{anchor.year}-{mon:02d}-{day:02d}" + t = re.sub(r"(\d{1,2})月(\d{1,2})日", _md_repl, t) + return t + + +async def run_longmemeval_test( + sample_size: int = 3, + group_id: str = "longmemeval_zh_bak_2", + search_limit: int = 8, + context_char_budget: int = 4000, + llm_temperature: float = 0.0, + llm_max_tokens: int = 16, + search_type: str = "hybrid", + data_path: str | None = None, + start_index: int = 0, +) -> Dict[str, Any]: + """LongMemEval 评估测试：增强技术术语检索能力""" + + # 数据路径 + if not data_path: + # 固定使用中文数据集：data/longmemeval_oracle_zh.json + zh_proj = os.path.join(PROJECT_ROOT, "data", "longmemeval_oracle_zh.json") + zh_cwd = os.path.join(os.getcwd(), "data", "longmemeval_oracle_zh.json") + if os.path.exists(zh_proj): + data_path = zh_proj + elif os.path.exists(zh_cwd): + data_path = zh_cwd + else: + raise FileNotFoundError("未找到数据集: data/longmemeval_oracle_zh.json，请确保其存在于项目根目录或当前工作目录的 data 目录下。") + + qa_list: List[Dict[str, Any]] = load_dataset_any(data_path) + # 支持评估全部样本：当 sample_size <= 0 时，取从 start_index 到末尾 + if sample_size is None or sample_size <= 0: + items = qa_list[start_index:] + else: + items = qa_list[start_index:start_index + sample_size] + + # 初始化组件 - 使用异步LLM客户端 + llm_client = get_llm_client(SELECTED_LLM_ID) + connector = Neo4jConnector() + cfg_dict = get_embedder_config(SELECTED_EMBEDDING_ID) + embedder = OpenAIEmbedderClient( + model_config=RedBearModelConfig.model_validate(cfg_dict) + ) + + # 指标收集 + latencies_llm: List[float] = [] + latencies_search: List[float] = [] + per_query_context_counts: List[int] = [] + per_query_context_avg_tokens: List[float] = [] + per_query_context_chars: List[int] = [] + + type_correct: Dict[str, List[float]] = {} + type_f1: Dict[str, List[float]] = {} + type_jacc: Dict[str, List[float]] = {} + + samples: List[Dict[str, Any]] = [] + # 统计重复的上下文预览（跨样本），便于诊断"相同上下文"问题 + preview_counter: Dict[str, int] = {} + + try: + for item in items: + question = item.get("question", "") + reference = item.get("answer", "") + qtype = item.get("question_type") or item.get("type", "unknown") + + print(f"\n=== 处理问题: {question} ===") + + # 检测问题类型 + is_temporal = any(keyword in question.lower() for keyword in + ['days', 'day', 'before', 'after', 'first', '先后', '顺序', '间隔', '多久', '多少天']) + + # 检索 + t0 = time.time() + contexts_all: List[str] = [] + dialogs, statements, entities = [], [], [] + + try: + if search_type == "embedding": + search_results = await search_graph_by_embedding( + connector=connector, + embedder_client=embedder, + query_text=question, + group_id=group_id, + limit=search_limit, + include=["dialogues", "statements", "entities"], + ) + dialogs = search_results.get("dialogues", []) + statements = search_results.get("statements", []) + entities = search_results.get("entities", []) + + for d in dialogs: + content = str(d.get("content", "")).strip() + if content: + contexts_all.append(content) + for s in statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + # 实体摘要（最多3个） + scored = [e for e in entities if e.get("score") is not None] + top_entities = sorted(scored, key=lambda x: x.get("score", 0), reverse=True)[:3] if scored else entities[:3] + if top_entities: + summary_lines = [] + for e in top_entities: + name = str(e.get("name", "")).strip() + etype = str(e.get("entity_type", "")).strip() + score = e.get("score") + if name: + meta = [] + if etype: + meta.append(f"type={etype}") + if isinstance(score, (int, float)): + meta.append(f"score={score:.3f}") + summary_lines.append(f"EntitySummary: {name}{(' [' + '; '.join(meta) + ']') if meta else ''}") + if summary_lines: + contexts_all.append("\n".join(summary_lines)) + + elif search_type == "keyword": + search_results = await search_graph( + connector=connector, + q=question, + group_id=group_id, + limit=search_limit, + ) + dialogs = search_results.get("dialogues", []) + statements = search_results.get("statements", []) + entities = search_results.get("entities", []) + + for d in dialogs: + content = str(d.get("content", "")).strip() + if content: + contexts_all.append(content) + for s in statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + if entities: + entity_names = [str(e.get("name", "")).strip() for e in entities[:5] if e.get("name")] + if entity_names: + contexts_all.append(f"EntitySummary: {', '.join(entity_names)}") + + else: # hybrid（增强版：特别优化技术术语检索） + emb_dialogs, emb_statements, emb_entities = [], [], [] + kw_dialogs, kw_statements, kw_entities = [], [], [] + + # 1) 嵌入检索 + try: + emb_res = await search_graph_by_embedding( + connector=connector, + embedder_client=embedder, + query_text=question, + group_id=group_id, + limit=search_limit, + include=["dialogues", "statements", "entities"], + ) + if isinstance(emb_res, dict): + emb_dialogs = emb_res.get("dialogues", []) or [] + emb_statements = emb_res.get("statements", []) or [] + emb_entities = emb_res.get("entities", []) or [] + except Exception as e: + print(f"⚠️ 嵌入检索失败，将继续进行关键词检索: {e}") + + # 2) 关键词检索（增强版） + try: + kw_res = await search_graph( + connector=connector, + q=question, + group_id=group_id, + limit=search_limit, + ) + if isinstance(kw_res, dict): + kw_dialogs = kw_res.get("dialogues", []) or [] + kw_statements = kw_res.get("statements", []) or [] + kw_entities = kw_res.get("entities", []) or [] + + # 技术术语专门检索 + tech_entities = await _search_tech_terms(connector, question, group_id, search_limit//2) + if tech_entities: + kw_entities.extend(tech_entities) + + # 时间推理问题的特殊处理 + if is_temporal: + # 专门搜索时间实体 + time_entities = await _search_time_entities(connector, group_id, search_limit//2) + if time_entities: + kw_entities.extend(time_entities) + # 添加时间相关关键词检索 + time_keywords = ['天', '日', '月', '年', 'before', 'after', 'first'] + for tk in time_keywords: + try: + time_res = await search_graph( + connector=connector, + q=tk, + group_id=group_id, + limit=2, + ) + if isinstance(time_res, dict): + kw_dialogs.extend(time_res.get("dialogues", []) or []) + kw_statements.extend(time_res.get("statements", []) or []) + except Exception: + pass + + # 中文关键词拆分后做别名匹配 + cn_tokens = generate_query_keywords_cn(question) # 使用增强版关键词提取 + alias_entities = await _search_entities_by_aliases(connector, cn_tokens, group_id, search_limit) + if alias_entities: + kw_entities.extend(alias_entities) + + # 从对话/陈述中的 entity_ids 反查实体 + ids = [] + try: + for d in kw_dialogs: + ids.extend(d.get("entity_ids", []) or []) + for s in kw_statements: + ids.extend(s.get("entity_ids", []) or []) + except Exception: + pass + if ids: + id_entities = await _fetch_entities_by_ids(connector, ids, group_id) + if id_entities: + kw_entities.extend(id_entities) + + # 多关键词检索（使用增强版关键词） + try: + eng_words = [w for w in set(re.findall(r"\b\w+\b", question.lower())) if len(w) > 2] + kw_list = generate_query_keywords_cn(question)[:4] # 使用更多关键词 + for kw in kw_list: + if not kw: + continue + sub_res = await search_graph( + connector=connector, + q=str(kw), + group_id=group_id, + limit=max(3, search_limit // 2), + ) + if isinstance(sub_res, dict): + kw_dialogs.extend(sub_res.get("dialogues", []) or []) + kw_statements.extend(sub_res.get("statements", []) or []) + kw_entities.extend(sub_res.get("entities", []) or []) + except Exception: + pass + + # 选项参与关键词检索 + try: + opt_list = extract_candidate_options(question)[:2] + for opt in opt_list: + if not opt: + continue + opt_res = await search_graph( + connector=connector, + q=str(opt), + group_id=group_id, + limit=max(3, search_limit // 2), + ) + if isinstance(opt_res, dict): + kw_dialogs.extend(opt_res.get("dialogues", []) or []) + kw_statements.extend(opt_res.get("statements", []) or []) + kw_entities.extend(opt_res.get("entities", []) or []) + except Exception: + pass + except Exception as e: + print(f"❌ 关键词检索失败: {e}") + + # 3) 合并、排序并去重 + all_dialogs = emb_dialogs + kw_dialogs + all_statements = emb_statements + kw_statements + all_entities = emb_entities + kw_entities + + def dedup(items: List[Dict[str, Any]], key_field: str = "uuid") -> List[Dict[str, Any]]: + seen = set() + out = [] + for it in items: + key = str(it.get(key_field, "")) + str(it.get("content", "") + str(it.get("statement", ""))) + if key not in seen: + out.append(it) + seen.add(key) + return out + + # 关键技术实体优先排序 + def enhanced_score(item: Dict[str, Any]) -> float: + score_val = item.get("score", 0.0) + base_score = float(score_val) if score_val is not None else 0.0 + content = str(item.get("content", "") + str(item.get("statement", ""))) + + # 关键技术实体奖励 + key_entities = [] + if any(term in question for term in ["GPS", "导航", "系统"]): + key_entities.extend(["GPS", "导航", "系统", "功能"]) + if any(term in question for term in ["工作坊", "研讨会", "活动"]): + key_entities.extend(["工作坊", "研讨会", "参加"]) + + key_bonus = 0 + for key_ent in key_entities: + if key_ent in content: + key_bonus += 1.0 + + # 时间实体奖励 + time_bonus = 0 + if is_temporal: + time_entities = extract_time_entities(content) + time_bonus = len(time_entities) * 0.5 + + return base_score + key_bonus + time_bonus + + dialogs = dedup(sorted(all_dialogs, key=enhanced_score, reverse=True)) + statements = dedup(sorted(all_statements, key=enhanced_score, reverse=True)) + entities = dedup(all_entities, key_field="name") + + # 4) 构建上下文 + for d in dialogs: + content = str(d.get("content", "")).strip() + if content: + contexts_all.append(content) + for s in statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + # 实体摘要 + try: + scored = [e for e in entities if e.get("score") is not None] + top_entities = sorted(scored, key=lambda x: x.get("score", 0), reverse=True)[:3] if scored else entities[:3] + if top_entities: + summary_lines = [] + for e in top_entities: + name = str(e.get("name", "")).strip() + etype = str(e.get("entity_type", "")).strip() + score = e.get("score") + if name: + meta = [] + if etype: + meta.append(f"type={etype}") + if isinstance(score, (int, float)): + meta.append(f"score={score:.3f}") + summary_lines.append(f"EntitySummary: {name}{(' [' + '; '.join(meta) + ']') if meta else ''}") + if summary_lines: + contexts_all.append("\n".join(summary_lines)) + except Exception: + pass + + # 全局回退 + if not contexts_all and search_type in ("embedding", "hybrid"): + try: + print("🔁 检索为空，回退到关键词检索...") + kw_fallback = await search_graph( + connector=connector, + q=question, + group_id=group_id, + limit=max(search_limit, 5), + ) + fb_dialogs = kw_fallback.get("dialogues", []) or [] + fb_statements = kw_fallback.get("statements", []) or [] + fb_entities = kw_fallback.get("entities", []) or [] + + for d in fb_dialogs: + content = str(d.get("content", "")).strip() + if content: + contexts_all.append(content) + for s in fb_statements: + stmt_text = str(s.get("statement", "")).strip() + if stmt_text: + contexts_all.append(stmt_text) + if fb_entities: + entity_names = [str(e.get("name", "")).strip() for e in fb_entities[:5] if e.get("name")] + if entity_names: + contexts_all.append(f"EntitySummary: {', '.join(entity_names)}") + + dialogs = fb_dialogs if fb_dialogs else dialogs + statements = fb_statements if fb_statements else statements + entities = fb_entities if fb_entities else entities + print(f"↩️ 回退到关键词检索: {len(fb_dialogs)} 对话, {len(fb_statements)} 条陈述, {len(fb_entities)} 个实体") + except Exception as fe: + print(f"❌ 关键词回退失败: {fe}") + + ent_count = len(entities) if isinstance(entities, list) else 0 + print(f"✅ {search_type}检索成功: {len(dialogs)} 对话, {len(statements)} 条陈述, {ent_count} 个实体") + if is_temporal: + print("⏰ 检测为时间推理问题，已启用时间优化检索") + + except Exception as e: + print(f"❌ {search_type}检索失败: {e}") + contexts_all = [] + + t1 = time.time() + latencies_search.append((t1 - t0) * 1000) + + # 智能上下文选择 + context_text = "" + if contexts_all: + context_text = smart_context_selection(contexts_all, question, max_chars=context_char_budget) + # 相对时间解析 + try: + context_text = _resolve_relative_times_cn_en(context_text, anchor=datetime.now()) + except Exception: + pass + # 诊断信息 + try: + cn_diag = generate_query_keywords_cn(question)[:4] # 显示更多关键词 + opts = extract_candidate_options(question)[:2] + qlw = [w for w in set(re.findall(r'\b\w+\b', question.lower())) if len(w) > 2][:1] + diag_tokens: List[str] = [] + for t in cn_diag + opts + qlw: + if t and t not in diag_tokens: + diag_tokens.append(t) + print(f"🔍 关键词/选项: {', '.join(diag_tokens)}") + preview = context_text[:200].replace('\n', ' ') + print(f"🔎 上下文预览: {preview}...") + key_preview = preview.strip() + if key_preview: + preview_counter[key_preview] = preview_counter.get(key_preview, 0) + 1 + except Exception: + pass + else: + print("❌ 没有检索到有效上下文") + context_text = "No relevant context found." + + # 记录上下文诊断信息 + per_query_context_counts.append(len(contexts_all)) + per_query_context_avg_tokens.append(avg_context_tokens([context_text])) + per_query_context_chars.append(len(context_text)) + + # LLM 推理（增强技术术语提示） + options = extract_candidate_options(question) + if len(options) >= 2: + opt_lines = "\n".join(f"- {o}" for o in options) + # 技术术语问题的特殊提示 + if any(term in question for term in ["GPS", "系统", "功能", "工作坊", "研讨会"]): + system_prompt = ( + "You are a QA assistant specializing in technical and activity-related questions. " + "Pay special attention to technical terms like GPS, systems, functions, workshops, and seminars. " + "Return ONLY one string: exactly one option from the provided candidates. If the context is insufficient, respond with 'Unknown'. " + "Focus on matching technical details and activity sequences accurately." + ) + elif is_temporal: + system_prompt = ( + "You are a QA assistant specializing in temporal reasoning. Analyze the dates and time relationships in the context carefully. " + "Return ONLY one string: exactly one option from the provided candidates. If the context is insufficient, respond with 'Unknown'. " + "Pay special attention to date sequences and time intervals." + ) + else: + system_prompt = ( + "You are a QA assistant. Respond in the same language as the question. Return ONLY one string: exactly one option from the provided candidates. " + "If the context is insufficient, respond with 'Unknown'. If the context expresses a synonym or paraphrase of a candidate, return the closest candidate. " + "Do not include explanations." + ) + + messages = [ + {"role": "system", "content": system_prompt}, + { + "role": "user", + "content": ( + f"Question: {question}\n\nCandidates:\n{opt_lines}\n\nContext:\n{context_text}\n\nReturn EXACTLY one candidate string (or 'Unknown')." + ), + }, + ] + else: + # 技术术语问题的特殊提示 + if any(term in question for term in ["GPS", "系统", "功能", "工作坊", "研讨会"]): + system_prompt = ( + "You are a QA assistant specializing in technical and activity-related questions. " + "Pay special attention to technical terms like GPS, systems, functions, workshops, and seminars. " + "If the context contains the answer, return a concise answer phrase focusing on technical details. " + "If the answer cannot be determined from the context, respond with 'Unknown'. Return ONLY the final answer string, no explanations." + ) + elif is_temporal: + system_prompt = ( + "You are a QA assistant specializing in temporal reasoning. Analyze the dates and time relationships in the context carefully. " + "If the context contains the answer, return a concise answer phrase focusing on temporal information. " + "If the answer cannot be determined from the context, respond with 'Unknown'. Return ONLY the final answer string, no explanations." + ) + else: + system_prompt = ( + "You are a QA assistant. Respond in the same language as the question. If the context contains the answer, return a concise answer phrase. " + "If the answer cannot be determined from the context, respond with 'Unknown'. Return ONLY the final answer string, no explanations." + ) + + messages = [ + {"role": "system", "content": system_prompt}, + { + "role": "user", + "content": f"Question: {question}\n\nContext:\n{context_text}\n\nReturn ONLY the answer (or 'Unknown').", + }, + ] + + t2 = time.time() + # 使用异步调用 + resp = await llm_client.chat(messages=messages) + t3 = time.time() + latencies_llm.append((t3 - t2) * 1000) + + # 兼容不同的响应格式 + pred_raw = resp.content.strip() if hasattr(resp, 'content') else (resp["choices"][0]["message"]["content"].strip() if isinstance(resp, dict) else "Unknown") + + # 选项题输出规范化 + pred = pred_raw + if len(options) >= 2 and not pred_raw.lower().startswith("unknown"): + def _basic_norm(s: str) -> str: + s = s.lower().strip() + return re.sub(r"[^\w\s]", " ", s) + def _jaccard(a: str, b: str) -> float: + ta = set(t for t in _basic_norm(a).split() if t) + tb = set(t for t in _basic_norm(b).split() if t) + if not ta and not tb: + return 1.0 + if not ta or not tb: + return 0.0 + return len(ta & tb) / len(ta | tb) + best = None + best_score = -1.0 + for o in options: + score = _jaccard(pred_raw, o) + if score > best_score: + best = o + best_score = score + if best is not None and best_score > 0.0: + pred = best + + # 指标 + flag = exact_match(pred, reference) + f1_val = common_f1(str(pred), str(reference)) + j_val = jaccard(str(pred), str(reference)) + + type_correct.setdefault(qtype, []).append(flag) + type_f1.setdefault(qtype, []).append(f1_val) + type_jacc.setdefault(qtype, []).append(j_val) + + samples.append({ + "question": question, + "prediction": pred, + "answer": reference, + "question_type": qtype, + "is_temporal": is_temporal, + "question_id": item.get("question_id"), + "options": options, + "context_count": len(contexts_all), + "context_chars": len(context_text), + "retrieved_dialogue_count": len(dialogs), + "retrieved_statement_count": len(statements), + "metrics": { + "exact_match": bool(flag), + "f1": f1_val, + "jaccard": j_val + }, + "timing": { + "search_ms": (t1 - t0) * 1000, + "llm_ms": (t3 - t2) * 1000 + } + }) + + print(f"🤖 LLM 回答: {pred}") + print(f"✅ 正确答案: {reference}") + print(f"📈 当前指标 - Exact Match: {flag}, F1: {f1_val:.3f}, Jaccard: {j_val:.3f}") + + # 聚合结果 + type_acc = {t: (sum(v) / max(len(v), 1)) for t, v in type_correct.items()} + f1_by_type = {t: (sum(v) / max(len(v), 1)) for t, v in type_f1.items()} + jacc_by_type = {t: (sum(v) / max(len(v), 1)) for t, v in type_jacc.items()} + + result = { + "dataset": "longmemeval", + "items": len(items), + "accuracy_by_type": type_acc, + "f1_by_type": f1_by_type, + "jaccard_by_type": jacc_by_type, + "samples": samples, + "latency": { + "search": latency_stats(latencies_search), + "llm": latency_stats(latencies_llm), + }, + "context": { + "avg_tokens": statistics.mean(per_query_context_avg_tokens) if per_query_context_avg_tokens else 0.0, + "avg_chars": statistics.mean(per_query_context_chars) if per_query_context_chars else 0.0, + "count_avg": statistics.mean(per_query_context_counts) if per_query_context_counts else 0.0, + }, + "params": { + "group_id": group_id, + "search_limit": search_limit, + "context_char_budget": context_char_budget, + "search_type": search_type, + "llm_id": SELECTED_LLM_ID, + "embedding_id": SELECTED_EMBEDDING_ID, + "sample_size": sample_size, + "start_index": start_index, + }, + "timestamp": datetime.now().isoformat() + } + + # 计算汇总指标 + try: + total_items = max(len(samples), 1) + correct_count = sum(1 for s in samples if s.get("metrics", {}).get("exact_match")) + score_accuracy = (correct_count / total_items) * 100.0 + + total_latencies_ms = [] + for s in samples: + t = s.get("timing", {}) + total_latencies_ms.append(float(t.get("search_ms", 0.0)) + float(t.get("llm_ms", 0.0))) + total_lat_stats = latency_stats(total_latencies_ms) if total_latencies_ms else {"p50": 0.0, "iqr": 0.0} + latency_median_s = total_lat_stats.get("p50", 0.0) / 1000.0 + latency_iqr_s = total_lat_stats.get("iqr", 0.0) / 1000.0 + + avg_ctx_tokens = statistics.mean(per_query_context_avg_tokens) if per_query_context_avg_tokens else 0.0 + avg_ctx_tokens_k = avg_ctx_tokens / 1000.0 + + result["metric_summary"] = { + "score_accuracy": score_accuracy, + "latency_median_s": latency_median_s, + "latency_iqr_s": latency_iqr_s, + "avg_context_tokens_k": avg_ctx_tokens_k, + } + except Exception: + result["metric_summary"] = { + "score_accuracy": 0.0, + "latency_median_s": 0.0, + "latency_iqr_s": 0.0, + "avg_context_tokens_k": 0.0, + } + + # 诊断信息 + try: + dups = sorted([(k, c) for k, c in preview_counter.items() if c > 1], key=lambda x: -x[1])[:5] + result["diagnostics"] = { + "duplicate_previews_top": [{"count": c, "preview": k[:120]} for k, c in dups], + "unique_preview_count": len(preview_counter), + } + except Exception: + pass + + return result + + finally: + await connector.close() + + +def main(): + load_dotenv() + parser = argparse.ArgumentParser(description="LongMemEval 评估测试脚本（增强技术术语检索版）") + parser.add_argument("--sample-size", type=int, default=3, help="样本数量（<=0 表示全部）") + parser.add_argument("--all", action="store_true", help="评估全部样本（覆盖 --sample-size）") + parser.add_argument("--start-index", type=int, default=0, help="起始样本索引") + parser.add_argument("--group-id", type=str, default="longmemeval_zh_bak_3", help="图数据库 Group ID") + parser.add_argument("--search-limit", type=int, default=8, help="检索条数上限") + parser.add_argument("--context-char-budget", type=int, default=4000, help="上下文字符预算") + parser.add_argument("--llm-temperature", type=float, default=0.0, help="LLM 温度") + parser.add_argument("--llm-max-tokens", type=int, default=16, help="LLM 最大输出 token") + parser.add_argument("--search-type", type=str, default="hybrid", choices=["embedding","keyword","hybrid"], help="检索类型") + parser.add_argument("--data-path", type=str, default=None, help="数据集路径") + args = parser.parse_args() + + sample_size = 0 if args.all else args.sample_size + + result = asyncio.run( + run_longmemeval_test( + sample_size=sample_size, + group_id=args.group_id, + search_limit=args.search_limit, + context_char_budget=args.context_char_budget, + llm_temperature=args.llm_temperature, + llm_max_tokens=args.llm_max_tokens, + search_type=args.search_type, + data_path=args.data_path, + start_index=args.start_index, + ) + ) + + # 打印结果 + print("\n" + "="*50) + print("📊 LongMemEval 测试结果:") + print(f" 样本数量: {result['items']}") + + if result['accuracy_by_type']: + print("\n📈 按问题类型细分:") + for qtype, acc in result['accuracy_by_type'].items(): + print(f" {qtype}:") + print(f" Score (Accuracy): {acc:.3f}") + + print(f"\n📊 指标总览:") + ms = result.get('metric_summary', {}) + print(f" Score (Accuracy): {ms.get('score_accuracy', 0.0):.1f}%") + print(f" Latency (s): median {ms.get('latency_median_s', 0.0):.3f}s") + print(f" Latency IQR (s): {ms.get('latency_iqr_s', 0.0):.3f}s") + print(f" Avg Context Tokens (k): {ms.get('avg_context_tokens_k', 0.0):.3f}k") + + print(f"\n⏱️ 细分性能指标:") + print(f" 检索延迟(均值): {result['latency']['search']['mean']:.1f}ms") + print(f" LLM延迟(均值): {result['latency']['llm']['mean']:.1f}ms") + print(f" 上下文长度(均值): {result['context']['avg_chars']:.0f} 字符") + + + # 保存结果到文件 + try: + out_dir = os.path.join(PROJECT_ROOT, "evaluation", "longmemeval", "results") + os.makedirs(out_dir, exist_ok=True) + ts = datetime.now().strftime("%Y%m%d_%H%M%S") + out_path = os.path.join(out_dir, f"longmemeval_{result['params']['search_type']}_{ts}.json") + with open(out_path, "w", encoding="utf-8") as f: + json.dump(result, f, ensure_ascii=False, indent=2) + print(f"\n💾 结果已保存: {out_path}") + except Exception as e: + print(f"⚠️ 结果保存失败: {e}") + + +if __name__ == "__main__": + main() diff --git a/api/app/core/memory/evaluation/memsciqa/evaluate_qa.py b/api/app/core/memory/evaluation/memsciqa/evaluate_qa.py new file mode 100644 index 00000000..f41d8f10 --- /dev/null +++ b/api/app/core/memory/evaluation/memsciqa/evaluate_qa.py @@ -0,0 +1,301 @@ +import argparse +import asyncio +import json +import os +import time +from datetime import datetime +from typing import List, Dict, Any +try: + from dotenv import load_dotenv +except Exception: + def load_dotenv(): + return None + +from app.repositories.neo4j.neo4j_connector import Neo4jConnector +from app.core.memory.storage_services.search import run_hybrid_search +from app.core.memory.utils.config.definitions import PROJECT_ROOT, SELECTED_GROUP_ID, SELECTED_EMBEDDING_ID, SELECTED_LLM_ID +from app.core.memory.utils.llm.llm_utils import get_llm_client +from app.core.memory.evaluation.extraction_utils import ingest_contexts_via_full_pipeline +from app.core.memory.evaluation.common.metrics import exact_match, latency_stats, avg_context_tokens + + +def smart_context_selection(contexts: List[str], question: str, max_chars: int = 4000) -> str: + """基于问题关键词对上下文进行评分选择，并在预算内拼接文本。""" + if not contexts: + return "" + import re + # 提取问题关键词（移除停用词） + question_lower = (question or "").lower() + stop_words = { + 'what','when','where','who','why','how','did','do','does','is','are','was','were', + 'the','a','an','and','or','but' + } + question_words = set(re.findall(r"\b\w+\b", question_lower)) + question_words = {w for w in question_words if w not in stop_words and len(w) > 2} + + # 评分 + scored = [] + for i, ctx in enumerate(contexts): + ctx_lower = (ctx or "").lower() + score = 0 + matches = 0 + for w in question_words: + if w in ctx_lower: + matches += 1 + score += ctx_lower.count(w) * 2 + length = len(ctx) + if 100 < length < 2000: + score += 5 + elif length >= 2000: + score += 2 + if i < 3: + score += 3 + scored.append((score, ctx, matches)) + + scored.sort(key=lambda x: x[0], reverse=True) + + # 选择直到达到字符限制，必要时截断包含关键词的段落 + selected: List[str] = [] + total = 0 + for score, ctx, _ in scored: + if total + len(ctx) <= max_chars: + selected.append(ctx) + total += len(ctx) + else: + if score > 10 and total < max_chars - 200: + remaining = max_chars - total + lines = ctx.split('\n') + rel_lines: List[str] = [] + cur = 0 + for line in lines: + l = line.lower() + if any(w in l for w in question_words) and cur < remaining - 50: + rel_lines.append(line) + cur += len(line) + if rel_lines: + truncated = '\n'.join(rel_lines) + if len(truncated) > 50: + selected.append(truncated + "\n[相关内容截断...]") + total += len(truncated) + break + return "\n\n".join(selected) + + +def build_context_from_dialog(dialog_obj: Dict[str, Any]) -> str: + """Compose a text context from `dialog` list in msc_self_instruct item.""" + parts: List[str] = [] + for turn in dialog_obj.get("dialog", []): + speaker = turn.get("speaker", "") + text = turn.get("text", "") + if text: + parts.append(f"{speaker}: {text}") + return "\n".join(parts) + + +def _combine_dialogues_for_hybrid(results: Dict[str, Any]) -> List[Dict[str, Any]]: + """Combine dialogues from embedding and keyword searches (embedding first).""" + if results is None: + return [] + emb = [] + kw = [] + if isinstance(results.get("embedding_search"), dict): + emb = results.get("embedding_search", {}).get("dialogues", []) or [] + elif isinstance(results.get("dialogues"), list): + emb = results.get("dialogues", []) or [] + if isinstance(results.get("keyword_search"), dict): + kw = results.get("keyword_search", {}).get("dialogues", []) or [] + seen = set() + merged: List[Dict[str, Any]] = [] + for d in emb: + k = (str(d.get("uuid", "")), str(d.get("content", ""))) + if k not in seen: + merged.append(d) + seen.add(k) + for d in kw: + k = (str(d.get("uuid", "")), str(d.get("content", ""))) + if k not in seen: + merged.append(d) + seen.add(k) + return merged + + +async def run_memsciqa_eval(sample_size: int = 1, group_id: str | None = None, search_limit: int = 8, context_char_budget: int = 4000, llm_temperature: float = 0.0, llm_max_tokens: int = 64, search_type: str = "hybrid") -> Dict[str, Any]: + group_id = group_id or SELECTED_GROUP_ID + # Load data + data_path = os.path.join(PROJECT_ROOT, "data", "msc_self_instruct.jsonl") + if not os.path.exists(data_path): + data_path = os.path.join(os.getcwd(), "data", "msc_self_instruct.jsonl") + with open(data_path, "r", encoding="utf-8") as f: + lines = f.readlines() + items: List[Dict[str, Any]] = [json.loads(l) for l in lines[:sample_size]] + # 改为：每条样本仅摄入一个上下文（完整对话转录），避免多上下文摄入 + # 说明：memsciqa 数据集的每个样本天然只有一个对话，保持按样本一上下文的策略 + contexts: List[str] = [build_context_from_dialog(item) for item in items] + await ingest_contexts_via_full_pipeline(contexts, group_id) + + # LLM client (使用异步调用) + llm_client = get_llm_client(SELECTED_LLM_ID) + + # Evaluate each item + connector = Neo4jConnector() + latencies_llm: List[float] = [] + latencies_search: List[float] = [] + contexts_used: List[str] = [] + correct_flags: List[float] = [] + f1s: List[float] = [] + b1s: List[float] = [] + jss: List[float] = [] + try: + for item in items: + question = item.get("self_instruct", {}).get("B", "") or item.get("question", "") + reference = item.get("self_instruct", {}).get("A", "") or item.get("answer", "") + # 检索：对齐 locomo 的三路检索（dialogues/statements/entities） + t0 = time.time() + try: + results = await run_hybrid_search( + query_text=question, + search_type=search_type, + group_id=group_id, + limit=search_limit, + include=["dialogues", "statements", "entities"], + output_path=None, + ) + except Exception: + results = None + t1 = time.time() + latencies_search.append((t1 - t0) * 1000) + + # 构建上下文：包含对话、陈述和实体摘要，并智能选择 + contexts_all: List[str] = [] + if results: + if search_type == "hybrid": + emb = results.get("embedding_search", {}) if isinstance(results.get("embedding_search"), dict) else {} + kw = results.get("keyword_search", {}) if isinstance(results.get("keyword_search"), dict) else {} + emb_dialogs = emb.get("dialogues", []) + emb_statements = emb.get("statements", []) + emb_entities = emb.get("entities", []) + kw_dialogs = kw.get("dialogues", []) + kw_statements = kw.get("statements", []) + kw_entities = kw.get("entities", []) + all_dialogs = emb_dialogs + kw_dialogs + all_statements = emb_statements + kw_statements + all_entities = emb_entities + kw_entities + + # 简单去重与限制 + seen_texts = set() + for d in all_dialogs: + text = str(d.get("content", "")).strip() + if text and text not in seen_texts: + contexts_all.append(text) + seen_texts.add(text) + if len(contexts_all) >= search_limit: + break + for s in all_statements: + text = str(s.get("statement", "")).strip() + if text and text not in seen_texts: + contexts_all.append(text) + seen_texts.add(text) + if len(contexts_all) >= search_limit: + break + # 实体摘要（最多3个） + names = [] + merged_entities = all_entities[:] + for e in merged_entities: + name = str(e.get("name", "")).strip() + if name and name not in names: + names.append(name) + if len(names) >= 3: + break + if names: + contexts_all.append("EntitySummary: " + ", ".join(names)) + else: + dialogs = results.get("dialogues", []) + statements = results.get("statements", []) + entities = results.get("entities", []) + for d in dialogs: + text = str(d.get("content", "")).strip() + if text: + contexts_all.append(text) + for s in statements: + text = str(s.get("statement", "")).strip() + if text: + contexts_all.append(text) + names = [str(e.get("name", "")).strip() for e in entities[:3] if e.get("name")] + if names: + contexts_all.append("EntitySummary: " + ", ".join(names)) + + # 智能选择并截断到预算 + context_text = smart_context_selection(contexts_all, question, max_chars=context_char_budget) if contexts_all else "" + if not context_text: + context_text = "No relevant context found." + contexts_used.append(context_text[:200]) + + # Call LLM (使用异步调用) + messages = [ + {"role": "system", "content": "You are a QA assistant. Answer in English. Strictly follow: 1) If the context contains the answer, copy the shortest exact span from the context as the answer; 2) If the answer cannot be determined from the context, respond with 'Unknown'; 3) Return ONLY the answer text, no explanations."}, + {"role": "user", "content": f"Question: {question}\n\nContext:\n{context_text}"}, + ] + t2 = time.time() + resp = await llm_client.chat(messages=messages) + t3 = time.time() + latencies_llm.append((t3 - t2) * 1000) + pred = resp.content.strip() if hasattr(resp, 'content') else (resp["choices"][0]["message"]["content"].strip() if isinstance(resp, dict) else str(resp).strip()) + # Metrics: F1, BLEU-1, Jaccard; keep exact match for reference + correct_flags.append(exact_match(pred, reference)) + from app.core.memory.evaluation.common.metrics import f1_score, bleu1, jaccard + f1s.append(f1_score(str(pred), str(reference))) + b1s.append(bleu1(str(pred), str(reference))) + jss.append(jaccard(str(pred), str(reference))) + + # Aggregate metrics + acc = sum(correct_flags) / max(len(correct_flags), 1) + ctx_avg_tokens = avg_context_tokens(contexts_used) + result = { + "dataset": "memsciqa", + "items": len(items), + "metrics": { + "accuracy": acc, + # Placeholders for extensibility + "f1": (sum(f1s) / max(len(f1s), 1)) if f1s else 0.0, + "bleu1": (sum(b1s) / max(len(b1s), 1)) if b1s else 0.0, + "jaccard": (sum(jss) / max(len(jss), 1)) if jss else 0.0, + }, + "latency": { + "search": latency_stats(latencies_search), + "llm": latency_stats(latencies_llm), + }, + "avg_context_tokens": ctx_avg_tokens, + } + return result + finally: + await connector.close() + + +def main(): + load_dotenv() + parser = argparse.ArgumentParser(description="Evaluate DMR (memsciqa) with graph search and Qwen") + parser.add_argument("--sample-size", type=int, default=1, help="评测样本数量") + parser.add_argument("--group-id", type=str, default=None, help="可选 group_id，默认取 runtime.json") + parser.add_argument("--search-limit", type=int, default=8, help="每类检索最大返回数") + parser.add_argument("--context-char-budget", type=int, default=4000, help="上下文字符预算") + parser.add_argument("--llm-temperature", type=float, default=0.0, help="LLM 温度") + parser.add_argument("--llm-max-tokens", type=int, default=64, help="LLM 最大生成长度") + parser.add_argument("--search-type", type=str, choices=["keyword","embedding","hybrid"], default="hybrid", help="检索类型") + args = parser.parse_args() + + result = asyncio.run( + run_memsciqa_eval( + sample_size=args.sample_size, + group_id=args.group_id, + search_limit=args.search_limit, + context_char_budget=args.context_char_budget, + llm_temperature=args.llm_temperature, + llm_max_tokens=args.llm_max_tokens, + search_type=args.search_type, + ) + ) + print(json.dumps(result, ensure_ascii=False, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/api/app/core/memory/evaluation/memsciqa/memsciqa-test.py b/api/app/core/memory/evaluation/memsciqa/memsciqa-test.py new file mode 100644 index 00000000..c8d89a4d --- /dev/null +++ b/api/app/core/memory/evaluation/memsciqa/memsciqa-test.py @@ -0,0 +1,561 @@ +import argparse +import asyncio +import json +import os +import time +from datetime import datetime +from typing import List, Dict, Any +import re + +try: + from dotenv import load_dotenv +except Exception: + def load_dotenv(): + return None + +# 路径与模块导入保持与现有评估脚本一致 +import sys +_THIS_DIR = os.path.dirname(os.path.abspath(__file__)) +_PROJECT_ROOT = os.path.dirname(os.path.dirname(_THIS_DIR)) +_SRC_DIR = os.path.join(_PROJECT_ROOT, "src") +for _p in (_SRC_DIR, _PROJECT_ROOT): + if _p not in sys.path: + sys.path.insert(0, _p) + +# 对齐 locomo_test 的检索逻辑：直接使用 graph_search 与 Neo4jConnector/Embedder1 +from app.repositories.neo4j.neo4j_connector import Neo4jConnector +from app.repositories.neo4j.graph_search import search_graph, search_graph_by_embedding +from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient +from app.core.models.base import RedBearModelConfig +from app.core.memory.utils.config_utils import get_embedder_config + +from app.core.memory.utils.llm.llm_utils import get_llm_client +from app.core.memory.utils.config.definitions import PROJECT_ROOT, SELECTED_GROUP_ID, SELECTED_EMBEDDING_ID, SELECTED_LLM_ID +from app.core.memory.evaluation.common.metrics import exact_match, latency_stats, avg_context_tokens +try: + from app.core.memory.evaluation.common.metrics import f1_score, bleu1, jaccard +except Exception: + # 兜底：简单实现（必要时） + def f1_score(pred: str, ref: str) -> float: + ps = pred.lower().split() + rs = ref.lower().split() + if not ps or not rs: + return 0.0 + tp = len(set(ps) & set(rs)) + if tp == 0: + return 0.0 + precision = tp / len(ps) + recall = tp / len(rs) + if precision + recall == 0: + return 0.0 + return 2 * precision * recall / (precision + recall) + + def bleu1(pred: str, ref: str) -> float: + ps = pred.lower().split() + rs = ref.lower().split() + if not ps or not rs: + return 0.0 + overlap = len([w for w in ps if w in rs]) + return overlap / max(len(ps), 1) + + def jaccard(pred: str, ref: str) -> float: + ps = set(pred.lower().split()) + rs = set(ref.lower().split()) + union = len(ps | rs) + if union == 0: + return 0.0 + return len(ps & rs) / union + + +def smart_context_selection(contexts: List[str], question: str, max_chars: int = 4000) -> str: + """基于问题关键词对上下文进行评分选择，并在预算内拼接文本。 + + 参考 evaluation/memsciqa/evaluate_qa.py 的实现，避免路径导入带来的不稳定。 + """ + if not contexts: + return "" + question_lower = (question or "").lower() + stop_words = { + 'what','when','where','who','why','how','did','do','does','is','are','was','were', + 'the','a','an','and','or','but' + } + question_words = set(re.findall(r"\b\w+\b", question_lower)) + question_words = {w for w in question_words if w not in stop_words and len(w) > 2} + + scored = [] + for i, ctx in enumerate(contexts): + ctx_lower = (ctx or "").lower() + score = 0 + matches = 0 + for w in question_words: + if w in ctx_lower: + matches += 1 + score += ctx_lower.count(w) * 2 + length = len(ctx) + if 100 < length < 2000: + score += 5 + elif length >= 2000: + score += 2 + if i < 3: + score += 3 + scored.append((score, ctx, matches)) + + scored.sort(key=lambda x: x[0], reverse=True) + + selected: List[str] = [] + total = 0 + for score, ctx, _ in scored: + if total + len(ctx) <= max_chars: + selected.append(ctx) + total += len(ctx) + else: + if score > 10 and total < max_chars - 200: + remaining = max_chars - total + lines = ctx.split('\n') + rel_lines: List[str] = [] + cur = 0 + for line in lines: + l = line.lower() + if any(w in l for w in question_words) and cur < remaining - 50: + rel_lines.append(line) + cur += len(line) + if rel_lines: + truncated = '\n'.join(rel_lines) + if len(truncated) > 50: + selected.append(truncated + "\n[相关内容截断...]") + total += len(truncated) + break + return "\n\n".join(selected) + + +def extract_question_keywords(question: str, max_keywords: int = 8) -> List[str]: + """提取问题中的关键词（简单英文分词，去停用词，长度>=3）。""" + ql = (question or "").lower() + stop_words = { + 'what','when','where','who','why','how','did','do','does','is','are','was','were', + 'the','a','an','and','or','but','of','to','in','on','for','with','from','that','this' + } + words = re.findall(r"\b[\w-]+\b", ql) + kws = [w for w in words if w not in stop_words and len(w) >= 3] + # 去重保序 + seen = set() + uniq = [] + for w in kws: + if w not in seen: + uniq.append(w) + seen.add(w) + if len(uniq) >= max_keywords: + break + return uniq + + +def analyze_contexts_simple(contexts: List[str], keywords: List[str], top_n: int = 5) -> List[Dict[str, int | float]]: + """对上下文进行简单相关性打分，仅用于控制台可视化。 + + 评分: score = match_count*200 + min(len(text), 100000)/100 + """ + results = [] + for ctx in contexts: + tl = (ctx or "").lower() + match_count = sum(1 for k in keywords if k in tl) + length = len(ctx) + score = match_count * 200 + min(length, 100000) / 100.0 + results.append({"score": float(f"{score:.0f}"), "match": match_count, "length": length}) + results.sort(key=lambda x: (x["score"], x["match"], x["length"]), reverse=True) + return results[:max(top_n, 0)] + + +# 纯测试脚本不进行摄入；若需摄入请使用 evaluate_qa.py + + +def load_dataset_memsciqa(data_path: str) -> List[Dict[str, Any]]: + if not os.path.exists(data_path): + raise FileNotFoundError(f"未找到数据集: {data_path}") + items: List[Dict[str, Any]] = [] + with open(data_path, "r", encoding="utf-8") as f: + for line in f: + line = line.strip() + if not line: + continue + try: + items.append(json.loads(line)) + except Exception: + # 跳过坏行但不中断 + continue + return items + + +async def run_memsciqa_test( + sample_size: int = 3, + group_id: str | None = None, + search_limit: int = 8, + context_char_budget: int = 4000, + llm_temperature: float = 0.0, + llm_max_tokens: int = 64, + search_type: str = "embedding", + data_path: str | None = None, + start_index: int = 0, + verbose: bool = True, +) -> Dict[str, Any]: + """memsciqa 增强测试脚本：结合 evaluate_qa 的三路检索与智能上下文选择。 + + - 支持从指定索引开始与评估全部样本（sample_size<=0） + - 支持在摄入前重置组（清空图）与跳过摄入 + - 支持 keyword / embedding / hybrid 三种检索 + """ + + # 默认使用指定的 memsci 组 ID + group_id = group_id or "group_memsci" + + # 数据路径解析（项目根与当前工作目录兜底） + if not data_path: + proj_path = os.path.join(PROJECT_ROOT, "data", "msc_self_instruct.jsonl") + cwd_path = os.path.join(os.getcwd(), "data", "msc_self_instruct.jsonl") + if os.path.exists(proj_path): + data_path = proj_path + elif os.path.exists(cwd_path): + data_path = cwd_path + else: + raise FileNotFoundError("未找到数据集: data/msc_self_instruct.jsonl，请确保其存在于项目根目录或当前工作目录的 data 目录下。") + + # 加载数据 + all_items = load_dataset_memsciqa(data_path) + if sample_size is None or sample_size <= 0: + items = all_items[start_index:] + else: + items = all_items[start_index:start_index + sample_size] + + # 初始化 LLM（纯测试：不进行摄入） + llm = get_llm_client(SELECTED_LLM_ID) + + # 初始化 Neo4j 连接与向量检索 Embedder（对齐 locomo_test） + connector = Neo4jConnector() + embedder = None + if search_type in ("embedding", "hybrid"): + cfg_dict = get_embedder_config(SELECTED_EMBEDDING_ID) + embedder = OpenAIEmbedderClient( + model_config=RedBearModelConfig.model_validate(cfg_dict) + ) + + # 评估循环 + latencies_llm: List[float] = [] + latencies_search: List[float] = [] + # 存储完整上下文文本用于统计 + contexts_used: List[str] = [] + per_query_context_chars: List[int] = [] + per_query_context_counts: List[int] = [] + correct_flags: List[float] = [] + f1s: List[float] = [] + b1s: List[float] = [] + jss: List[float] = [] + samples: List[Dict[str, Any]] = [] + + total_items = len(items) + for idx, item in enumerate(items): + if verbose: + print(f"\n🧪 评估样本: {idx+1}/{total_items}") + question = item.get("self_instruct", {}).get("B", "") or item.get("question", "") + reference = item.get("self_instruct", {}).get("A", "") or item.get("answer", "") + + # 三路检索：chunks/statements/entities/summaries（对齐 qwen_search_eval.py） + t0 = time.time() + results = None + try: + if search_type in ("embedding", "hybrid"): + # 使用嵌入检索（与 qwen_search_eval 对齐） + results = await search_graph_by_embedding( + connector=connector, + embedder_client=embedder, + query_text=question, + group_id=group_id, + limit=search_limit, + include=["chunks", "statements", "entities", "summaries"], # 使用 chunks 而不是 dialogues + ) + elif search_type == "keyword": + # 关键词检索（直接调用 graph_search） + results = await search_graph( + connector=connector, + q=question, + group_id=group_id, + limit=search_limit, + include=["chunks", "statements", "entities", "summaries"], # 使用 chunks 而不是 dialogues + ) + except Exception: + results = None + t1 = time.time() + search_ms = (t1 - t0) * 1000 + latencies_search.append(search_ms) + + # 构建上下文：包含 chunks、陈述、摘要和实体（对齐 qwen_search_eval.py） + contexts_all: List[str] = [] + retrieved_counts: Dict[str, int] = {} + if results: + chunks = results.get("chunks", []) + statements = results.get("statements", []) + entities = results.get("entities", []) + summaries = results.get("summaries", []) + retrieved_counts = { + "chunks": len(chunks), + "statements": len(statements), + "entities": len(entities), + "summaries": len(summaries), + } + # 优先使用 chunks + for c in chunks: + text = str(c.get("content", "")).strip() + if text: + contexts_all.append(text) + # 然后是 statements + for s in statements: + text = str(s.get("statement", "")).strip() + if text: + contexts_all.append(text) + # 然后是 summaries + for sm in summaries: + text = str(sm.get("summary", "")).strip() + if text: + contexts_all.append(text) + # 实体摘要：最多加入前3个高分实体（对齐 qwen_search_eval.py） + scored = [e for e in entities if e.get("score") is not None] + top_entities = sorted(scored, key=lambda x: x.get("score", 0), reverse=True)[:3] if scored else entities[:3] + if top_entities: + summary_lines = [] + for e in top_entities: + name = str(e.get("name", "")).strip() + etype = str(e.get("entity_type", "")).strip() + score = e.get("score") + if name: + meta = [] + if etype: + meta.append(f"type={etype}") + if isinstance(score, (int, float)): + meta.append(f"score={score:.3f}") + summary_lines.append(f"EntitySummary: {name}{(' [' + '; '.join(meta) + ']') if meta else ''}") + if summary_lines: + contexts_all.append("\n".join(summary_lines)) + + if verbose: + if retrieved_counts: + print(f"✅ 检索成功: {retrieved_counts.get('chunks',0)} chunks, {retrieved_counts.get('statements',0)} 条陈述, {retrieved_counts.get('entities',0)} 个实体, {retrieved_counts.get('summaries',0)} 个摘要") + print(f"📊 有效上下文数量: {len(contexts_all)}") + q_keywords = extract_question_keywords(question, max_keywords=8) + if q_keywords: + print(f"🔍 问题关键词: {set(q_keywords)}") + if contexts_all: + analysis = analyze_contexts_simple(contexts_all, q_keywords, top_n=5) + if analysis: + print("📊 上下文相关性分析:") + for a in analysis: + print(f" - 得分: {int(a['score'])}, 关键词匹配: {a['match']}, 长度: {a['length']}") + # 打印检索到的上下文预览，便于定位为何为 Unknown + print("🔎 上下文预览（最多前10条，每条截断展示）:") + for i, ctx in enumerate(contexts_all[:10]): + preview = str(ctx).replace("\n", " ") + if len(preview) > 300: + preview = preview[:300] + "..." + print(f" [{i+1}] 长度: {len(ctx)} | 片段: {preview}") + # 标注参考答案是否出现在任一上下文中 + ref_lower = (str(reference) or "").lower() + if ref_lower: + hits = [] + for i, ctx in enumerate(contexts_all): + if ref_lower in str(ctx).lower(): + hits.append(i+1) + print(f"🔗 参考答案命中上下文条数: {len(hits)}" + (f" | 命中索引: {hits}" if hits else "")) + + context_text = smart_context_selection(contexts_all, question, max_chars=context_char_budget) if contexts_all else "" + if not context_text: + context_text = "No relevant context found." + contexts_used.append(context_text) + per_query_context_chars.append(len(context_text)) + per_query_context_counts.append(len(contexts_all)) + + if verbose: + selected_count = (context_text.count("\n\n") + 1) if context_text else 0 + print(f"✅ 智能选择: {selected_count}个上下文, 总长度: {len(context_text)}字符") + # 展示拼接后的上下文片段，便于核查是否包含答案 + concat_preview = context_text.replace("\n", " ") + if len(concat_preview) > 600: + concat_preview = concat_preview[:600] + "..." + print(f"🧵 拼接上下文预览: {concat_preview}") + + messages = [ + { + "role": "system", + "content": ( + "You are a QA assistant. Answer in English. Follow these guidelines:\n" + "1) If the context contains information to answer the question, provide a concise answer based on the context;\n" + "2) If the context does not contain enough information to answer the question, respond with 'Unknown';\n" + "3) Keep your answer brief and to the point;\n" + "4) Do not add explanations or additional text beyond the answer." + ), + }, + {"role": "user", "content": f"Question: {question}\n\nContext:\n{context_text}"}, + ] + + t2 = time.time() + try: + # 使用异步调用 + resp = await llm.chat(messages=messages) + # 更健壮的响应解析，处理不同的LLM响应格式 + if hasattr(resp, 'content'): + pred = resp.content.strip() + elif isinstance(resp, dict) and "choices" in resp and len(resp["choices"]) > 0: + pred = resp["choices"][0]["message"]["content"].strip() + elif isinstance(resp, dict) and "content" in resp: + pred = resp["content"].strip() + elif isinstance(resp, str): + pred = resp.strip() + else: + pred = "Unknown" + print(f"⚠️ LLM响应格式异常: {type(resp)} - {resp}") + + # 检查预测是否为"Unknown"或空，如果是则检查上下文是否真的没有答案 + if pred.lower() in ["unknown", ""]: + # 如果参考答案在上下文中存在，但LLM返回Unknown，可能是提示词问题 + ref_lower = (str(reference) or "").lower() + if ref_lower and any(ref_lower in ctx.lower() for ctx in contexts_all): + print("⚠️ 参考答案在上下文中存在但LLM返回Unknown，检查提示词") + except Exception as e: + # 更详细的错误处理 + pred = "Unknown" + print(f"⚠️ LLM调用异常: {e}") + t3 = time.time() + llm_ms = (t3 - t2) * 1000 + latencies_llm.append(llm_ms) + + exact = exact_match(pred, reference) + correct_flags.append(exact) + f1_val = f1_score(str(pred), str(reference)) + b1_val = bleu1(str(pred), str(reference)) + j_val = jaccard(str(pred), str(reference)) + f1s.append(f1_val) + b1s.append(b1_val) + jss.append(j_val) + + if verbose: + print(f"🤖 LLM 回答: {pred}") + print(f"✅ 正确答案: {reference}") + print(f"📈 当前指标 - F1: {f1_val:.3f}, BLEU-1: {b1_val:.3f}, Jaccard: {j_val:.3f}") + print(f"⏱️ 延迟 - 检索: {search_ms:.0f}ms, LLM: {llm_ms:.0f}ms") + + # 对齐 locomo/qwen_search_eval.py 的样本输出结构 + samples.append({ + "question": str(question), + "answer": str(reference), + "prediction": str(pred), + "metrics": { + "f1": f1_val, + "b1": b1_val, + "j": j_val + }, + "retrieval": { + "retrieved_documents": len(contexts_all), + "context_length": len(context_text), + "search_limit": search_limit, + "max_chars": context_char_budget + }, + "timing": { + "search_ms": search_ms, + "llm_ms": llm_ms + } + }) + + # 计算总体指标与聚合 + acc = sum(correct_flags) / max(len(correct_flags), 1) + ctx_avg_tokens = avg_context_tokens(contexts_used) + result = { + "dataset": "memsciqa", + "items": len(items), + "metrics": { + "f1": (sum(f1s) / max(len(f1s), 1)) if f1s else 0.0, + "b1": (sum(b1s) / max(len(b1s), 1)) if b1s else 0.0, + "j": (sum(jss) / max(len(jss), 1)) if jss else 0.0, + }, + "context": { + "avg_tokens": ctx_avg_tokens, + "avg_chars": (sum(per_query_context_chars) / max(len(per_query_context_chars), 1)) if per_query_context_chars else 0.0, + "count_avg": (sum(per_query_context_counts) / max(len(per_query_context_counts), 1)) if per_query_context_counts else 0.0, + "avg_memory_tokens": 0.0 + }, + "latency": { + "search": latency_stats(latencies_search), + "llm": latency_stats(latencies_llm), + }, + "samples": samples, + "params": { + "group_id": group_id, + "search_limit": search_limit, + "context_char_budget": context_char_budget, + "llm_temperature": llm_temperature, + "llm_max_tokens": llm_max_tokens, + "search_type": search_type, + "start_index": start_index, + "llm_id": SELECTED_LLM_ID, + "retrieval_embedding_id": SELECTED_EMBEDDING_ID + }, + "timestamp": datetime.now().isoformat(), + } + try: + await connector.close() + except Exception: + pass + return result + + +def main(): + load_dotenv() + parser = argparse.ArgumentParser(description="memsciqa 测试脚本（三路检索 + 智能上下文选择）") + parser.add_argument("--sample-size", type=int, default=30, help="样本数量（<=0 表示全部）") + parser.add_argument("--all", action="store_true", help="评估全部样本（覆盖 --sample-size）") + parser.add_argument("--start-index", type=int, default=0, help="起始样本索引") + parser.add_argument("--group-id", type=str, default="group_memsci", help="图数据库 Group ID（默认 group_memsci）") + parser.add_argument("--search-limit", type=int, default=8, help="检索条数上限") + parser.add_argument("--context-char-budget", type=int, default=4000, help="上下文字符预算") + parser.add_argument("--llm-temperature", type=float, default=0.0, help="LLM 温度") + parser.add_argument("--llm-max-tokens", type=int, default=64, help="LLM 最大输出 token") + parser.add_argument("--search-type", type=str, default="embedding", choices=["embedding","keyword","hybrid"], help="检索类型（hybrid 等同于 embedding）") + parser.add_argument("--data-path", type=str, default=None, help="数据集路径（默认 data/msc_self_instruct.jsonl）") + parser.add_argument("--output", type=str, default=None, help="将评估结果保存到指定文件路径（JSON）") + parser.add_argument("--verbose", action="store_true", default=True, help="打印过程日志（默认开启）") + parser.add_argument("--quiet", action="store_true", help="关闭过程日志") + args = parser.parse_args() + + sample_size = 0 if args.all else args.sample_size + + verbose_flag = False if args.quiet else args.verbose + result = asyncio.run( + run_memsciqa_test( + sample_size=sample_size, + group_id=args.group_id, + search_limit=args.search_limit, + context_char_budget=args.context_char_budget, + llm_temperature=args.llm_temperature, + llm_max_tokens=args.llm_max_tokens, + search_type=args.search_type, + data_path=args.data_path, + start_index=args.start_index, + verbose=verbose_flag, + ) + ) + + print(json.dumps(result, ensure_ascii=False, indent=2)) + + # 结果保存 + out_path = args.output + if not out_path: + eval_dir = os.path.dirname(os.path.abspath(__file__)) + dataset_results_dir = os.path.join(eval_dir, "results") + ts = datetime.now().strftime("%Y%m%d_%H%M%S") + out_path = os.path.join(dataset_results_dir, f"memsciqa_{result['params']['search_type']}_{ts}.json") + try: + os.makedirs(os.path.dirname(out_path), exist_ok=True) + with open(out_path, "w", encoding="utf-8") as f: + json.dump(result, f, ensure_ascii=False, indent=2) + print(f"\n💾 结果已保存: {out_path}") + except Exception as e: + print(f"⚠️ 结果保存失败: {e}") + + +if __name__ == "__main__": + main() diff --git a/api/app/core/memory/evaluation/run_eval.py b/api/app/core/memory/evaluation/run_eval.py new file mode 100644 index 00000000..1de3de89 --- /dev/null +++ b/api/app/core/memory/evaluation/run_eval.py @@ -0,0 +1,150 @@ +import argparse +import asyncio +import json +import os +import sys +from typing import Any, Dict + +# Add src directory to Python path for proper imports when running from evaluation directory +sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'src')) + +try: + from dotenv import load_dotenv +except Exception: + def load_dotenv(): + return None + +from app.repositories.neo4j.neo4j_connector import Neo4jConnector +from app.core.memory.utils.config.definitions import SELECTED_GROUP_ID, PROJECT_ROOT + +from app.core.memory.evaluation.memsciqa.evaluate_qa import run_memsciqa_eval +from app.core.memory.evaluation.longmemeval.qwen_search_eval import run_longmemeval_test +from app.core.memory.evaluation.locomo.qwen_search_eval import run_locomo_eval + + +async def run( + dataset: str, + sample_size: int, + reset_group: bool, + group_id: str | None, + judge_model: str | None = None, + search_limit: int | None = None, + context_char_budget: int | None = None, + llm_temperature: float | None = None, + llm_max_tokens: int | None = None, + search_type: str | None = None, + start_index: int | None = None, + max_contexts_per_item: int | None = None, +) -> Dict[str, Any]: + # 恢复原始风格：统一入口做路由，并沿用各数据集既有默认 + group_id = group_id or SELECTED_GROUP_ID + + if reset_group: + connector = Neo4jConnector() + try: + await connector.delete_group(group_id) + finally: + await connector.close() + + if dataset == "locomo": + kwargs: Dict[str, Any] = {"sample_size": sample_size, "group_id": group_id} + if search_limit is not None: + kwargs["search_limit"] = search_limit + if context_char_budget is not None: + kwargs["context_char_budget"] = context_char_budget + if llm_temperature is not None: + kwargs["llm_temperature"] = llm_temperature + if llm_max_tokens is not None: + kwargs["llm_max_tokens"] = llm_max_tokens + if search_type is not None: + kwargs["search_type"] = search_type + return await run_locomo_eval(**kwargs) + + if dataset == "memsciqa": + kwargs: Dict[str, Any] = {"sample_size": sample_size, "group_id": group_id} + if search_limit is not None: + kwargs["search_limit"] = search_limit + if context_char_budget is not None: + kwargs["context_char_budget"] = context_char_budget + if llm_temperature is not None: + kwargs["llm_temperature"] = llm_temperature + if llm_max_tokens is not None: + kwargs["llm_max_tokens"] = llm_max_tokens + if search_type is not None: + kwargs["search_type"] = search_type + return await run_memsciqa_eval(**kwargs) + + if dataset == "longmemeval": + kwargs: Dict[str, Any] = {"sample_size": sample_size, "group_id": group_id} + if search_limit is not None: + kwargs["search_limit"] = search_limit + if context_char_budget is not None: + kwargs["context_char_budget"] = context_char_budget + if llm_temperature is not None: + kwargs["llm_temperature"] = llm_temperature + if llm_max_tokens is not None: + kwargs["llm_max_tokens"] = llm_max_tokens + if search_type is not None: + kwargs["search_type"] = search_type + if start_index is not None: + kwargs["start_index"] = start_index + if max_contexts_per_item is not None: + kwargs["max_contexts_per_item"] = max_contexts_per_item + return await run_longmemeval_test(**kwargs) + raise ValueError(f"未知数据集: {dataset}") + + +def main(): + load_dotenv() + parser = argparse.ArgumentParser(description="统一评估入口：memsciqa / longmemeval / locomo") + parser.add_argument("--dataset", choices=["memsciqa", "longmemeval", "locomo"], required=True) + parser.add_argument("--sample-size", type=int, default=1, help="先用一条数据跑通") + parser.add_argument("--reset-group", action="store_true", help="运行前清空当前 group_id 的图数据") + parser.add_argument("--group-id", type=str, default=None, help="可选 group_id，默认取 runtime.json") + parser.add_argument("--judge-model", type=str, default=None, help="可选：longmemeval 判别式评测模型名") + parser.add_argument("--search-limit", type=int, default=None, help="检索返回的对话节点数量上限（不提供则使用各脚本默认）") + parser.add_argument("--context-char-budget", type=int, default=None, help="上下文字符预算（不提供则使用各脚本默认）") + parser.add_argument("--llm-temperature", type=float, default=None, help="生成温度（不提供则使用各脚本默认）") + parser.add_argument("--llm-max-tokens", type=int, default=None, help="最大生成 tokens（不提供则使用各脚本默认）") + parser.add_argument("--search-type", type=str, default=None, choices=["keyword", "embedding", "hybrid"], help="检索类型（不提供则使用各脚本默认）") + # 仅透传到 longmemeval；其他数据集忽略 + parser.add_argument("--start-index", type=int, default=None, help="仅 longmemeval：起始样本索引（不提供则用脚本默认）") + parser.add_argument("--max-contexts-per-item", type=int, default=None, help="仅 longmemeval：每条样本摄入的上下文数量上限（不提供则用脚本默认）") + parser.add_argument("--output", type=str, default=None, help="可选：将评估结果保存到指定文件路径（JSON）；不提供时默认保存到 evaluation//results 目录") + args = parser.parse_args() + + result = asyncio.run(run( + args.dataset, + args.sample_size, + args.reset_group, + args.group_id, + args.judge_model, + args.search_limit, + args.context_char_budget, + args.llm_temperature, + args.llm_max_tokens, + args.search_type, + args.start_index, + args.max_contexts_per_item, + )) + print(json.dumps(result, ensure_ascii=False, indent=2)) + + # 结果输出逻辑保持不变 + if args.output: + out_path = args.output + else: + eval_dir = os.path.dirname(os.path.abspath(__file__)) + dataset_results_dir = os.path.join(eval_dir, args.dataset, "results") + out_filename = f"{args.dataset}_{args.sample_size}.json" + out_path = os.path.join(dataset_results_dir, out_filename) + + out_dir = os.path.dirname(out_path) + if out_dir and not os.path.exists(out_dir): + os.makedirs(out_dir, exist_ok=True) + with open(out_path, "w", encoding="utf-8") as f: + json.dump(result, f, ensure_ascii=False, indent=2) + print(f"\n结果已保存到: {out_path}") + + +if __name__ == "__main__": + main() diff --git a/api/app/core/memory/main.py b/api/app/core/memory/main.py index 08f91939..ed61e584 100644 --- a/api/app/core/memory/main.py +++ b/api/app/core/memory/main.py @@ -1,5 +1,8 @@ """ -MemSci 记忆系统主入口 +MemSci 记忆系统主入口 - 重构版本 + +该模块是重构后的记忆系统主入口，使用新的模块化架构。 +旧版本入口（app/core/memory/src/main.py）已删除。 主要功能： 1. 协调整个知识提取流水线 @@ -319,7 +322,7 @@ async def main(dialogue_text: Optional[str] = None, is_pilot_run: bool = False): logger.info(f"Timing details saved to: {log_file}") print("\n" + "=" * 60) - print(f"✓ 流水线执行完成") + print("✓ 流水线执行完成") print(f"✓ 总耗时: {total_time:.2f} 秒") print(f"✓ 详细日志: {log_file}") print("=" * 60) diff --git a/api/app/core/memory/models/dedup_models.py b/api/app/core/memory/models/dedup_models.py index 87dcfb84..0a7388a2 100644 --- a/api/app/core/memory/models/dedup_models.py +++ b/api/app/core/memory/models/dedup_models.py @@ -18,6 +18,10 @@ class EntityDedupDecision(BaseModel): This model represents the LLM's decision on whether two entities refer to the same real-world entity and should be merged. + Note: Aliases are extracted during the triplet extraction phase and automatically + merged during entity merging. LLM only needs to decide whether to merge and which + entity to keep as canonical. + Attributes: same_entity: Whether the two entities refer to the same real-world entity confidence: Model confidence in the decision (0.0 to 1.0) @@ -36,6 +40,10 @@ class EntityDisambDecision(BaseModel): This model represents the LLM's decision on whether two entities with the same name but different types should be merged or kept separate. + Note: Aliases are extracted during the triplet extraction phase and automatically + merged during entity merging. LLM only needs to decide whether to merge and which + entity to keep as canonical. + Attributes: should_merge: Whether the two entities should be merged despite type difference confidence: Model confidence in the decision (0.0 to 1.0) diff --git a/api/app/core/memory/models/graph_models.py b/api/app/core/memory/models/graph_models.py index b1dc5de7..58b8271c 100644 --- a/api/app/core/memory/models/graph_models.py +++ b/api/app/core/memory/models/graph_models.py @@ -27,6 +27,7 @@ from pydantic import BaseModel, Field, field_validator import re from app.core.memory.utils.data.ontology import TemporalInfo +from app.core.memory.utils.alias_utils import validate_aliases def parse_historical_datetime(v): @@ -260,27 +261,66 @@ class ChunkNode(Node): class ExtractedEntityNode(Node): """Node representing an extracted entity in the knowledge graph. + + This class represents entities extracted from dialogue statements. Each entity + has a primary name and can have multiple aliases (alternative names). The aliases + feature enables better entity deduplication and disambiguation by tracking all + known names for an entity. Attributes: entity_idx: Unique numeric identifier for the entity statement_id: ID of the statement this entity was extracted from - entity_type: Type/category of the entity + entity_type: Type/category of the entity (e.g., PERSON, ORGANIZATION, LOCATION) description: Textual description of the entity - aliases: Optional list of alternative names for the entity + aliases: List of alternative names for the entity. This field: + - Stores all known alternative names in the SAME LANGUAGE as the entity name + - Automatically filters out invalid values (None, empty strings) + - Removes duplicates (case-insensitive) and names matching the primary name + - Is used in fuzzy matching to improve entity deduplication + - Is populated during triplet extraction and entity merging processes + - Has a recommended maximum of 50 aliases per entity + - CRITICAL: Aliases must be in the same language as the entity name (no translation) name_embedding: Optional embedding vector for the entity name fact_summary: Summary of facts about this entity - connect_strength: Classification of connection strength ('Strong' or 'Weak') - config_id: Configuration ID used to process this entity + connect_strength: Classification of connection strength ('Strong', 'Weak', or 'Both') + config_id: Configuration ID used to process this entity (integer or string) """ entity_idx: int = Field(..., description="Unique identifier for the entity") statement_id: str = Field(..., description="Statement this entity was extracted from") entity_type: str = Field(..., description="Type of the entity") description: str = Field(..., description="Entity description") - aliases: Optional[List[str]] = Field(default_factory=list, description="Entity aliases") + aliases: List[str] = Field( + default_factory=list, + description="Entity aliases - alternative names for this entity" + ) name_embedding: Optional[List[float]] = Field(default_factory=list, description="Name embedding vector") fact_summary: str = Field(..., 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)") + + @field_validator('aliases', mode='before') + @classmethod + 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. + It filters out: + - None values + - Empty strings + - Non-string types (after converting to string) + - Duplicate values + + Args: + v: The raw aliases value (can be None, list, or other types) + + Returns: + A cleaned list of unique string aliases + + Example: + >>> # Input: [None, "", "alias1", "alias1", 123] + >>> # Output: ["alias1", "123"] + """ + return validate_aliases(v) class MemorySummaryNode(Node): diff --git a/api/app/core/memory/models/triplet_models.py b/api/app/core/memory/models/triplet_models.py index 7439ee34..2325f3bd 100644 --- a/api/app/core/memory/models/triplet_models.py +++ b/api/app/core/memory/models/triplet_models.py @@ -24,6 +24,8 @@ class Entity(BaseModel): name_embedding: Optional embedding vector for the entity name type: Type/category of the entity (e.g., 'Person', 'Organization') description: Textual description of the entity + aliases: List of alternative names for the entity (e.g., abbreviations, full names, + different language expressions). Extracted during triplet extraction phase. Config: extra: Ignore extra fields from LLM output @@ -35,6 +37,10 @@ class Entity(BaseModel): name_embedding: Optional[List[float]] = Field(None, description="Embedding vector for the entity name") type: str = Field(..., description="Type/category of the entity") description: str = Field(..., description="Description of the entity") + aliases: List[str] = Field( + default_factory=list, + description="Alternative names for this entity (abbreviations, full names, translations, etc.)" + ) class Triplet(BaseModel): diff --git a/api/app/core/memory/src/llm_tools/chunker_client.py b/api/app/core/memory/src/llm_tools/chunker_client.py deleted file mode 100644 index 780f3345..00000000 --- a/api/app/core/memory/src/llm_tools/chunker_client.py +++ /dev/null @@ -1,330 +0,0 @@ -from typing import Any, List -import re -import os -import asyncio -import json -import numpy as np - -# Fix tokenizer parallelism warning -os.environ["TOKENIZERS_PARALLELISM"] = "false" - -from chonkie import ( - SemanticChunker, - RecursiveChunker, - RecursiveRules, - LateChunker, - NeuralChunker, - SentenceChunker, - TokenChunker, -) - -from app.core.memory.models.config_models import ChunkerConfig -from app.core.memory.models.message_models import DialogData, Chunk -try: - from app.core.memory.src.llm_tools.openai_client import OpenAIClient -except Exception: - # 在测试或无可用依赖（如 langfuse）环境下，允许惰性导入 - OpenAIClient = Any - - -class LLMChunker: - """基于LLM的智能分块策略""" - def __init__(self, llm_client: OpenAIClient, chunk_size: int = 1000): - self.llm_client = llm_client - self.chunk_size = chunk_size - - async def __call__(self, text: str) -> List[Any]: - # 使用LLM分析文本结构并进行智能分块 - prompt = f""" - 请将以下文本分割成语义连贯的段落。每个段落应该围绕一个主题，长度大约在{self.chunk_size}字符左右。 - 请以JSON格式返回结果，包含chunks数组，每个chunk有text字段。 - - 文本内容： - {text[:5000]} - """ - - messages = [ - {"role": "system", "content": "你是一个专业的文本分析助手，擅长将长文本分割成语义连贯的段落。"}, - {"role": "user", "content": prompt} - ] - - try: - # 使用异步的 achat 方法 - if hasattr(self.llm_client, 'achat'): - response = await self.llm_client.achat(messages) - else: - # 如果没有异步方法，使用同步方法并转换为异步 - response = await asyncio.to_thread(self.llm_client.chat, messages) - - # 检查响应格式并提取内容 - if hasattr(response, 'choices') and len(response.choices) > 0: - content = response.choices[0].message.content - elif hasattr(response, 'content'): - content = response.content - else: - content = str(response) - - # 解析LLM响应 - if "```json" in content: - json_str = content.split("```json")[1].split("```")[0].strip() - elif "```" in content: - json_str = content.split("```")[1].split("```")[0].strip() - else: - json_str = content - - result = json.loads(json_str) - - class SimpleChunk: - def __init__(self, text, index): - self.text = text - self.start_index = index * 100 # 近似位置 - self.end_index = (index + 1) * 100 - - return [SimpleChunk(chunk["text"], i) for i, chunk in enumerate(result.get("chunks", []))] - - except Exception as e: - print(f"LLM分块失败: {e}") - # 失败时返回空列表，外层会处理回退方案 - return [] - - -class HybridChunker: - """混合分块策略：先按结构分块，再按语义合并""" - def __init__(self, semantic_threshold: float = 0.8, base_chunk_size: int = 300): - self.semantic_threshold = semantic_threshold - self.base_chunk_size = base_chunk_size - self.base_chunker = TokenChunker(tokenizer="character", chunk_size=base_chunk_size) - self.semantic_chunker = SemanticChunker(threshold=semantic_threshold) - - def __call__(self, text: str) -> List[Any]: - # 先用基础分块 - base_chunks = self.base_chunker(text) - - # 如果文本不长，直接返回基础分块 - if len(base_chunks) <= 3: - return base_chunks - - # 对基础分块进行语义合并 - combined_text = " ".join([chunk.text for chunk in base_chunks]) - return self.semantic_chunker(combined_text) - - -class ChunkerClient: - def __init__(self, chunker_config: ChunkerConfig, llm_client: OpenAIClient = None): - self.chunker_config = chunker_config - self.embedding_model = chunker_config.embedding_model - self.chunk_size = chunker_config.chunk_size - self.threshold = chunker_config.threshold - self.language = chunker_config.language - self.skip_window = chunker_config.skip_window - self.min_sentences = chunker_config.min_sentences - self.min_characters_per_chunk = chunker_config.min_characters_per_chunk - self.llm_client = llm_client - - # 可选参数（从配置中安全获取，提供默认值） - self.chunk_overlap = getattr(chunker_config, 'chunk_overlap', 0) - self.min_sentences_per_chunk = getattr(chunker_config, 'min_sentences_per_chunk', 1) - self.min_characters_per_sentence = getattr(chunker_config, 'min_characters_per_sentence', 12) - self.delim = getattr(chunker_config, 'delim', [".", "!", "?", "\n"]) - self.include_delim = getattr(chunker_config, 'include_delim', "prev") - self.tokenizer_or_token_counter = getattr(chunker_config, 'tokenizer_or_token_counter', "character") - - # 初始化具体分块器策略 - if chunker_config.chunker_strategy == "TokenChunker": - self.chunker = TokenChunker( - tokenizer=self.tokenizer_or_token_counter, - chunk_size=self.chunk_size, - chunk_overlap=self.chunk_overlap, - ) - elif chunker_config.chunker_strategy == "SemanticChunker": - self.chunker = SemanticChunker( - embedding_model=self.embedding_model, - threshold=self.threshold, - chunk_size=self.chunk_size, - min_sentences=self.min_sentences, - ) - elif chunker_config.chunker_strategy == "RecursiveChunker": - self.chunker = RecursiveChunker( - rules=RecursiveRules(), - min_characters_per_chunk=self.min_characters_per_chunk or 50, - chunk_size=self.chunk_size, - ) - elif chunker_config.chunker_strategy == "LateChunker": - self.chunker = LateChunker( - embedding_model=self.embedding_model, - chunk_size=self.chunk_size, - rules=RecursiveRules(), - min_characters_per_chunk=self.min_characters_per_chunk, - ) - elif chunker_config.chunker_strategy == "NeuralChunker": - self.chunker = NeuralChunker( - model=self.embedding_model, - min_characters_per_chunk=self.min_characters_per_chunk, - ) - elif chunker_config.chunker_strategy == "LLMChunker": - if not llm_client: - raise ValueError("LLMChunker requires an LLM client") - self.chunker = LLMChunker(llm_client, self.chunk_size) - elif chunker_config.chunker_strategy == "HybridChunker": - self.chunker = HybridChunker( - semantic_threshold=self.threshold, - base_chunk_size=self.chunk_size, - ) - elif chunker_config.chunker_strategy == "SentenceChunker": - # 某些 chonkie 版本的 SentenceChunker 不支持 tokenizer_or_token_counter 参数 - # 为了兼容不同版本，这里仅传递广泛支持的参数 - self.chunker = SentenceChunker( - chunk_size=self.chunk_size, - chunk_overlap=self.chunk_overlap, - min_sentences_per_chunk=self.min_sentences_per_chunk, - min_characters_per_sentence=self.min_characters_per_sentence, - delim=self.delim, - include_delim=self.include_delim, - ) - else: - raise ValueError(f"Unknown chunker strategy: {chunker_config.chunker_strategy}") - - async def generate_chunks(self, dialogue: DialogData): - """ - 生成分块，支持异步操作 - """ - try: - # 预处理文本：确保对话标记格式统一 - content = dialogue.content - content = content.replace('AI：', 'AI:').replace('用户：', '用户:') # 统一冒号 - content = re.sub(r'(\n\s*)+\n', '\n\n', content) # 合并多个空行 - - if hasattr(self.chunker, '__call__') and not asyncio.iscoroutinefunction(self.chunker.__call__): - # 同步分块器 - chunks = self.chunker(content) - else: - # 异步分块器（如LLMChunker） - chunks = await self.chunker(content) - - # 过滤空块和过小的块 - valid_chunks = [] - for c in chunks: - chunk_text = getattr(c, 'text', str(c)) if not isinstance(c, str) else c - if isinstance(chunk_text, str) and len(chunk_text.strip()) >= (self.min_characters_per_chunk or 50): - valid_chunks.append(c) - - dialogue.chunks = [ - Chunk( - content=c.text if hasattr(c, 'text') else str(c), - metadata={ - "start_index": getattr(c, "start_index", None), - "end_index": getattr(c, "end_index", None), - "chunker_strategy": self.chunker_config.chunker_strategy, - }, - ) - for c in valid_chunks - ] - return dialogue - - except Exception as e: - print(f"分块失败: {e}") - - # 改进的后备方案：尝试按对话回合分割 - try: - # 简单的按对话分割 - dialogue_pattern = r'(AI:|用户:)(.*?)(?=AI:|用户:|$)' - matches = re.findall(dialogue_pattern, dialogue.content, re.DOTALL) - - class SimpleChunk: - def __init__(self, text, start_index, end_index): - self.text = text - self.start_index = start_index - self.end_index = end_index - - chunks = [] - current_chunk = "" - current_start = 0 - - for match in matches: - speaker, ct = match[0], match[1].strip() - turn_text = f"{speaker} {ct}" - - if len(current_chunk) + len(turn_text) > (self.chunk_size or 500): - if current_chunk: - chunks.append(SimpleChunk(current_chunk, current_start, current_start + len(current_chunk))) - current_chunk = turn_text - current_start = dialogue.content.find(turn_text, current_start) - else: - current_chunk += ("\n" + turn_text) if current_chunk else turn_text - - if current_chunk: - chunks.append(SimpleChunk(current_chunk, current_start, current_start + len(current_chunk))) - - dialogue.chunks = [ - Chunk( - content=c.text, - metadata={ - "start_index": c.start_index, - "end_index": c.end_index, - "chunker_strategy": "DialogueTurnFallback", - }, - ) - for c in chunks - ] - - except Exception: - # 最后的手段：单一大块 - dialogue.chunks = [Chunk( - content=dialogue.content, - metadata={"chunker_strategy": "SingleChunkFallback"}, - )] - - return dialogue - - def evaluate_chunking(self, dialogue: DialogData) -> dict: - """ - 评估分块质量 - """ - if not getattr(dialogue, 'chunks', None): - return {} - - chunks = dialogue.chunks - total_chars = sum(len(chunk.content) for chunk in chunks) - avg_chunk_size = total_chars / len(chunks) - - # 计算各种指标 - chunk_sizes = [len(chunk.content) for chunk in chunks] - - metrics = { - "strategy": self.chunker_config.chunker_strategy, - "num_chunks": len(chunks), - "total_characters": total_chars, - "avg_chunk_size": avg_chunk_size, - "min_chunk_size": min(chunk_sizes), - "max_chunk_size": max(chunk_sizes), - "chunk_size_std": np.std(chunk_sizes) if len(chunk_sizes) > 1 else 0, - "coverage_ratio": total_chars / len(dialogue.content) if dialogue.content else 0, - } - - return metrics - - def save_chunking_results(self, dialogue: DialogData, output_path: str): - """ - 保存分块结果到文件，文件名包含策略名称 - """ - strategy_name = self.chunker_config.chunker_strategy - # 在文件名中添加策略名称 - base_name, ext = os.path.splitext(output_path) - strategy_output_path = f"{base_name}_{strategy_name}{ext}" - - with open(strategy_output_path, 'w', encoding='utf-8') as f: - f.write(f"=== Chunking Strategy: {strategy_name} ===\n") - f.write(f"Total chunks: {len(dialogue.chunks)}\n") - f.write(f"Total characters: {sum(len(chunk.content) for chunk in dialogue.chunks)}\n") - f.write("=" * 60 + "\n\n") - - for i, chunk in enumerate(dialogue.chunks): - f.write(f"Chunk {i+1}:\n") - f.write(f"Size: {len(chunk.content)} characters\n") - if hasattr(chunk, 'metadata') and 'start_index' in chunk.metadata: - f.write(f"Position: {chunk.metadata.get('start_index')}-{chunk.metadata.get('end_index')}\n") - f.write(f"Content: {chunk.content}\n") - f.write("-" * 40 + "\n\n") - - print(f"Chunking results saved to: {strategy_output_path}") - return strategy_output_path diff --git a/api/app/core/memory/src/llm_tools/embedder_client.py b/api/app/core/memory/src/llm_tools/embedder_client.py deleted file mode 100644 index f1033fc6..00000000 --- a/api/app/core/memory/src/llm_tools/embedder_client.py +++ /dev/null @@ -1,22 +0,0 @@ -from abc import ABC, abstractmethod -from typing import List - -from app.core.models.base import RedBearModelConfig -class EmbedderClient(ABC): - def __init__(self, model_config: RedBearModelConfig): - self.config = model_config - - self.model_name = model_config.model_name - self.provider = model_config.provider - self.api_key = model_config.api_key - self.base_url = model_config.base_url - self.max_retries = model_config.max_retries - # self.dimension = model_config.dimension - - - @abstractmethod - async def response( - self, - messages: List[str], - ) -> List[str]: - pass diff --git a/api/app/core/memory/src/llm_tools/llm_client.py b/api/app/core/memory/src/llm_tools/llm_client.py deleted file mode 100644 index 8925de6a..00000000 --- a/api/app/core/memory/src/llm_tools/llm_client.py +++ /dev/null @@ -1,37 +0,0 @@ -from abc import ABC, abstractmethod -from typing import List, Dict, Any -from pydantic import BaseModel -from app.core.memory.models.config_models import LLMConfig - -""" - model_name: str - provider: str - api_key: str - base_url: Optional[str] = None - timeout: float = 30.0 # 请求超时时间（秒） - max_retries: int = 3 # 最大重试次数 - concurrency: int = 5 # 并发限流 - extra_params: Dict[str, Any] = {} -""" -from app.core.models.base import RedBearModelConfig -class LLMClient(ABC): - def __init__(self, model_config: RedBearModelConfig): - self.config = model_config - - self.model_name = self.config.model_name - self.provider = self.config.provider - self.api_key = self.config.api_key - self.base_url = self.config.base_url - self.max_retries = self.config.max_retries - - @abstractmethod - def chat(self, messages: List[Dict[str, str]]) -> Any: - pass - - @abstractmethod - async def response_structured( - self, - messages: List[Dict[str, str]], - response_model: type[BaseModel], - ) -> type[BaseModel]: - pass diff --git a/api/app/core/memory/src/llm_tools/openai_client.py b/api/app/core/memory/src/llm_tools/openai_client.py deleted file mode 100644 index dcb9da27..00000000 --- a/api/app/core/memory/src/llm_tools/openai_client.py +++ /dev/null @@ -1,224 +0,0 @@ -import asyncio -from typing import List, Dict, Any -import json - -from pydantic import BaseModel -from langchain_core.prompts import ChatPromptTemplate -from langchain_core.output_parsers import PydanticOutputParser - -from app.core.models.base import RedBearModelConfig -from app.core.models.llm import RedBearLLM -from app.core.memory.src.llm_tools.llm_client import LLMClient -# from app.core.memory.utils.config.definitions import LANGFUSE_ENABLED -LANGFUSE_ENABLED=False - -class OpenAIClient(LLMClient): - def __init__(self, model_config: RedBearModelConfig, type_: str = "chat"): - super().__init__(model_config) - - # Initialize Langfuse callback handler if enabled - self.langfuse_handler = None - if LANGFUSE_ENABLED: - try: - from langfuse.langchain import CallbackHandler - self.langfuse_handler = CallbackHandler() - except ImportError: - # Langfuse not installed, continue without tracing - pass - except Exception as e: - # Log error but don't fail initialization - import logging - logging.warning(f"Failed to initialize Langfuse handler: {e}") - - # Initialize RedBearLLM client - self.client = RedBearLLM(RedBearModelConfig( - model_name=self.model_name, - provider=self.provider, - api_key=self.api_key, - base_url=self.base_url, - max_retries=self.max_retries, - ), type=type_) - - async def chat(self, messages: List[Dict[str, str]]) -> Any: - template = """{messages}""" - # ChatPromptTemplate - prompt = ChatPromptTemplate.from_template(template) - chain = prompt | self.client - - # Add Langfuse callback if available - config = {} - if self.langfuse_handler: - config["callbacks"] = [self.langfuse_handler] - - response = await chain.ainvoke({"messages": messages}, config=config) - # print(f"OpenAIClient response ======>:\n {response}") - return response - - async def response_structured( - self, - messages: List[Dict[str, str]], - response_model: type[BaseModel], - ) -> type[BaseModel]: - # Build a simple prompt pipeline that sends messages to the underlying LLM - question_text = "\n\n".join([str(m.get("content", "")) for m in messages]) - - # Prepare config with Langfuse callback if available - config = {} - if self.langfuse_handler: - config["callbacks"] = [self.langfuse_handler] - - # Primary: enforce schema with PydanticOutputParser if available - if PydanticOutputParser is not None: - try: - import logging - logger = logging.getLogger(__name__) - # 使用正确的属性路径：self.config.timeout（从LLMClient基类继承） - # logger.info(f"开始LLM结构化输出请求 (模型: {self.model_name}, 超时: {self.config.timeout}秒)") - - parser = PydanticOutputParser(pydantic_object=response_model) - format_instructions = parser.get_format_instructions() - prompt = ChatPromptTemplate.from_template("{question}\n{format_instructions}") - chain = prompt | self.client | parser - parsed = await chain.ainvoke({ - "question": question_text, - "format_instructions": format_instructions, - }) - - # logger.info(f"LLM结构化输出请求成功完成") - return parsed - except Exception as e: - import logging - logger = logging.getLogger(__name__) - logger.warning(f"PydanticOutputParser失败，尝试备用方法: {str(e)}") - # Fall through to alternative structured methods - pass - - # Fallback path: create plain prompt for other structured methods - template = """{question}""" - prompt = ChatPromptTemplate.from_template(template) - - # Try LangChain structured output if available on the underlying client - try: - with_so = getattr(self.client, "with_structured_output", None) - - if callable(with_so): - try: - structured_chain = prompt | with_so(response_model, strict=True) - parsed = await structured_chain.ainvoke({"question": question_text}, config=config) - # parsed may already be a pydantic model or a dict - try: - return response_model.model_validate(parsed) - except Exception: - try: - # If it's already a pydantic instance (LangChain returns model), return it - if hasattr(parsed, "model_dump"): - return parsed - return response_model.model_validate_json(json.dumps(parsed)) - except Exception: - # Fall through to manual parsing below - pass - except NotImplementedError: - # The underlying model doesn't support structured output, fall through - import logging - logger = logging.getLogger(__name__) - logger.warning( - f"Model {self.model_name} doesn't support with_structured_output, falling back to manual parsing") - pass - except Exception as e: - import logging - logger = logging.getLogger(__name__) - logger.warning(f"Structured output attempt failed: {e}, falling back to manual parsing") - - # Final fallback: manual parsing with plain LLM response - try: - import logging - logger = logging.getLogger(__name__) - logger.info(f"Using manual parsing fallback for model {self.model_name}") - - # Create a prompt that asks for JSON output - json_prompt = ChatPromptTemplate.from_template( - "{question}\n\n" - "Please respond with a valid JSON object that matches this schema:\n" - "{schema}\n\n" - "Response (JSON only):" - ) - - # Get the schema from the response model - schema = response_model.model_json_schema() - - chain = json_prompt | self.client - response = await chain.ainvoke({ - "question": question_text, - "schema": json.dumps(schema, indent=2) - }, config=config) - - # Extract JSON from response - response_text = str(response.content if hasattr(response, 'content') else response) - - # Try to find JSON in the response - import re - json_match = re.search(r'\{.*\}', response_text, re.DOTALL) - if json_match: - json_str = json_match.group(0) - try: - parsed_dict = json.loads(json_str) - return response_model.model_validate(parsed_dict) - except json.JSONDecodeError: - pass - - # If JSON parsing fails, try to create a minimal valid response - logger.warning(f"Failed to parse JSON from LLM response, creating minimal response") - - # Create a minimal response based on the schema - return self._create_minimal_response(response_model) - - except Exception as fallback_error: - import logging - logger = logging.getLogger(__name__) - logger.error(f"Manual parsing fallback also failed: {fallback_error}") - # Return minimal response as last resort - return self._create_minimal_response(response_model) - - def _create_minimal_response(self, response_model: type[BaseModel]) -> BaseModel: - """Create a minimal valid response based on the model schema.""" - try: - minimal_response = {} - - for field_name, field_info in response_model.model_fields.items(): - # Check if field has a default value - if hasattr(field_info, 'default') and field_info.default is not None: - minimal_response[field_name] = field_info.default - else: - # Create default based on field type - field_type = field_info.annotation - - # Handle nested BaseModel - if hasattr(field_type, '__bases__') and BaseModel in field_type.__bases__: - minimal_response[field_name] = self._create_minimal_response(field_type) - elif field_type == str: - minimal_response[field_name] = "信息不足，无法回答" - elif field_type == int: - minimal_response[field_name] = 0 - elif field_type == float: - minimal_response[field_name] = 0.0 - elif field_type == bool: - minimal_response[field_name] = False - elif field_type == list: - minimal_response[field_name] = [] - elif field_type == dict: - minimal_response[field_name] = {} - else: - minimal_response[field_name] = None - - return response_model.model_validate(minimal_response) - - except Exception as e: - import logging - logger = logging.getLogger(__name__) - logger.error(f"Failed to create minimal response: {e}") - # Last resort: try to create with just required fields - try: - return response_model() - except Exception: - # If even that fails, raise the original error - raise ValueError(f"Unable to create minimal response for {response_model.__name__}") from e diff --git a/api/app/core/memory/src/llm_tools/openai_embedder.py b/api/app/core/memory/src/llm_tools/openai_embedder.py deleted file mode 100644 index 427c38a0..00000000 --- a/api/app/core/memory/src/llm_tools/openai_embedder.py +++ /dev/null @@ -1,26 +0,0 @@ -from typing import List - -from app.core.memory.src.llm_tools.embedder_client import EmbedderClient -from app.core.models.base import RedBearModelConfig -# from app.models.models_model import ModelType -from app.core.models.embedding import RedBearEmbeddings - - -class OpenAIEmbedderClient(EmbedderClient): - def __init__(self, model_config: RedBearModelConfig): - super().__init__(model_config) - - async def response( - self, - messages: List[str], - ) -> List[List[float]]: - texts: List[str] = [str(m) for m in messages if m is not None] - - model = RedBearEmbeddings(RedBearModelConfig( - model_name=self.model_name, - provider=self.provider, - api_key=self.api_key, - base_url=self.base_url, - )) - embeddings = await model.aembed_documents(texts) - return embeddings diff --git a/api/app/core/memory/src/search.py b/api/app/core/memory/src/search.py index 685d038f..7deeb0f2 100644 --- a/api/app/core/memory/src/search.py +++ b/api/app/core/memory/src/search.py @@ -15,7 +15,7 @@ from app.repositories.neo4j.graph_search import ( search_graph_by_temporal, search_graph_by_keyword_temporal, search_graph_by_chunk_id ) -from app.core.memory.src.llm_tools.openai_embedder import OpenAIEmbedderClient +from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient from app.core.memory.models.config_models import TemporalSearchParams from app.core.memory.utils.config.config_utils import get_embedder_config, get_pipeline_config from app.core.memory.utils.data.time_utils import normalize_date_safe @@ -564,7 +564,7 @@ async def run_hybrid_search( # Validate query is not empty after cleaning if not query_text or not query_text.strip(): - logger.warning(f"Empty query after cleaning, returning empty results") + logger.warning("Empty query after cleaning, returning empty results") return { "keyword_search": {}, "embedding_search": {}, diff --git a/api/app/core/memory/storage_services/extraction_engine/data_preprocessing/data_preprocessor.py b/api/app/core/memory/storage_services/extraction_engine/data_preprocessing/data_preprocessor.py index 796a76af..f5e72517 100644 --- a/api/app/core/memory/storage_services/extraction_engine/data_preprocessing/data_preprocessor.py +++ b/api/app/core/memory/storage_services/extraction_engine/data_preprocessing/data_preprocessor.py @@ -168,7 +168,7 @@ class DataPreprocessor: except json.JSONDecodeError as line_error: # 如果是单行巨大JSON数组，可能需要特殊处理 if line_num == 1 and len(lines) == 1: - print(f"检测到单行大型JSON，尝试分块解析...") + print("检测到单行大型JSON，尝试分块解析...") # 对于超大单行JSON，尝试使用json.JSONDecoder进行流式解析 try: decoder = json.JSONDecoder() diff --git a/api/app/core/memory/storage_services/extraction_engine/data_preprocessing/data_pruning.py b/api/app/core/memory/storage_services/extraction_engine/data_preprocessing/data_pruning.py index 6544b2ce..d19e511b 100644 --- a/api/app/core/memory/storage_services/extraction_engine/data_preprocessing/data_pruning.py +++ b/api/app/core/memory/storage_services/extraction_engine/data_preprocessing/data_pruning.py @@ -81,7 +81,6 @@ class SemanticPruner: if re.search(p, text, flags=re.IGNORECASE): return True return False - def _importance_score(self, message: ConversationMessage) -> int: """为重要消息打分，用于在保留比例内优先保留更关键的内容。 diff --git a/api/app/core/memory/storage_services/extraction_engine/deduplication/deduped_and_disamb.py b/api/app/core/memory/storage_services/extraction_engine/deduplication/deduped_and_disamb.py index 8af9042f..64a28590 100644 --- a/api/app/core/memory/storage_services/extraction_engine/deduplication/deduped_and_disamb.py +++ b/api/app/core/memory/storage_services/extraction_engine/deduplication/deduped_and_disamb.py @@ -14,6 +14,51 @@ import difflib # 提供字符串相似度计算工具 import asyncio import importlib import re +# 模块级类型统一工具函数 +def _unify_entity_type(canonical: ExtractedEntityNode, losing: ExtractedEntityNode, suggested_type: str = None) -> None: + """统一实体类型：基于LLM建议或启发式规则选择最合适的类型。 + + Args: + canonical: 规范实体（保留的实体） + losing: 被合并的实体 + suggested_type: LLM建议的统一类型（可选） + """ + canonical_type = (getattr(canonical, "entity_type", "") or "").strip() + losing_type = (getattr(losing, "entity_type", "") or "").strip() + + if suggested_type and suggested_type.strip(): + # 优先使用LLM建议的类型 + canonical.entity_type = suggested_type.strip() + elif canonical_type.upper() == "UNKNOWN" and losing_type.upper() != "UNKNOWN": + # 如果canonical是UNKNOWN，使用losing的类型 + canonical.entity_type = losing_type + elif canonical_type.upper() != "UNKNOWN" and losing_type.upper() == "UNKNOWN": + # 如果losing是UNKNOWN，保持canonical的类型（无需操作） + pass + elif canonical_type and losing_type and canonical_type != losing_type: + # 两个类型都不是UNKNOWN且不同，选择更具体的类型 + # 启发式规则： + # 1. 更长的类型名通常更具体（如 HistoricalPeriod vs Organization） + # 2. 包含特定领域词汇的类型更具体（如 MilitaryCapability vs Concept） + + # 定义通用类型（优先级低） + generic_types = {"Concept", "Phenomenon", "Condition", "State", "Attribute", "Event"} + + canonical_is_generic = canonical_type in generic_types + losing_is_generic = losing_type in generic_types + + if canonical_is_generic and not losing_is_generic: + # canonical是通用类型，losing是具体类型，使用losing + canonical.entity_type = losing_type + elif not canonical_is_generic and losing_is_generic: + # losing是通用类型，canonical是具体类型，保持canonical（无需操作） + pass + elif len(losing_type) > len(canonical_type): + # 两者都是具体类型或都是通用类型，选择更长的（通常更具体） + canonical.entity_type = losing_type + # 否则保持canonical的类型 + + # 模块级属性融合工具函数（统一行为） def _merge_attribute(canonical: ExtractedEntityNode, ent: ExtractedEntityNode): # 强弱连接合并 @@ -30,18 +75,52 @@ def _merge_attribute(canonical: ExtractedEntityNode, ent: ExtractedEntityNode): else: canonical.connect_strength = next(iter(pair)) - # 别名合并（去重保序） + # 别名合并（去重保序，使用标准化工具） try: + canonical_name = (getattr(canonical, "name", "") or "").strip() + incoming_name = (getattr(ent, "name", "") or "").strip() + + # 收集所有需要合并的别名 + all_aliases = [] + + # 1. 添加canonical现有的别名 existing = getattr(canonical, "aliases", []) or [] + all_aliases.extend(existing) + + # 2. 添加incoming实体的名称（如果不同于canonical的名称） + if incoming_name and incoming_name != canonical_name: + all_aliases.append(incoming_name) + + # 3. 添加incoming实体的所有别名 incoming = getattr(ent, "aliases", []) or [] - seen = set() - merged_list: List[str] = [] - for x in existing + incoming: - xn = (x or "").strip() - if xn and xn not in seen: - seen.add(xn) - merged_list.append(x) - canonical.aliases = merged_list + all_aliases.extend(incoming) + + # 4. 标准化并去重（优先使用alias_utils工具函数） + try: + from app.core.memory.utils.alias_utils import normalize_aliases + canonical.aliases = normalize_aliases(canonical_name, all_aliases) + except Exception: + # 如果导入失败，使用增强的去重逻辑 + seen_normalized = set() + unique_aliases = [] + + for alias in all_aliases: + if not alias: + continue + + alias_stripped = str(alias).strip() + if not alias_stripped or alias_stripped == canonical_name: + continue + + # 标准化：转小写用于去重判断 + alias_normalized = alias_stripped.lower() + + if alias_normalized not in seen_normalized: + seen_normalized.add(alias_normalized) + unique_aliases.append(alias_stripped) + + # 排序并赋值 + canonical.aliases = sorted(unique_aliases) except Exception: pass @@ -132,25 +211,25 @@ def accurate_match( # 为避免跨业务组误并，明确以 group_id 为范围边界 if key not in canonical_map: canonical_map[key] = ent - id_redirect[getattr(ent, "id")] = getattr(ent, "id") + id_redirect[ent.id] = ent.id continue canonical = canonical_map[key] # 执行精确属性与强弱合并，并建立重定向 _merge_attribute(canonical, ent) - id_redirect[getattr(ent, "id")] = getattr(canonical, "id") + id_redirect[ent.id] = canonical.id # 记录精确匹配的合并项（使用规范化键，避免外层变量误用） try: - k = f"{getattr(canonical, 'group_id')}|{(getattr(canonical, 'name') or '').strip()}|{(getattr(canonical, 'entity_type') or '').strip()}" + k = f"{canonical.group_id}|{(canonical.name or '').strip()}|{(canonical.entity_type or '').strip()}" if k not in exact_merge_map: exact_merge_map[k] = { - "canonical_id": getattr(canonical, "id"), - "group_id": getattr(canonical, "group_id"), - "name": getattr(canonical, "name"), - "entity_type": getattr(canonical, "entity_type"), + "canonical_id": canonical.id, + "group_id": canonical.group_id, + "name": canonical.name, + "entity_type": canonical.entity_type, "merged_ids": set(), } - exact_merge_map[k]["merged_ids"].add(getattr(ent, "id")) + exact_merge_map[k]["merged_ids"].add(ent.id) except Exception: pass @@ -164,23 +243,33 @@ def fuzzy_match( config: DedupConfig | None = None, ) -> Tuple[List[ExtractedEntityNode], Dict[str, str], List[str]]: """ - 模糊匹配：在精确匹配之后，基于名称/类型相似度与上下文共现，进一步融合高相似实体。 + 模糊匹配：基于名称、别名、类型相似度进行实体去重合并。 + + 判断因素： + - 名称相似度（包含别名匹配）：70%权重 + - 类型相似度：30%权重 + 返回: (updated_entities, updated_redirect, fuzzy_merge_records) """ fuzzy_merge_records: List[str] = [] + # ========== 第一层：基础工具函数 ========== + def _normalize_text(s: str) -> str: + """文本标准化：转小写、去除特殊字符、规范化空格""" try: return re.sub(r"\s+", " ", re.sub(r"[^\w\u4e00-\u9fff]+", " ", (s or "").lower())).strip() except Exception: return str(s).lower().strip() def _tokenize(s: str) -> List[str]: + """分词：提取中文字符和英文数字单词""" norm = _normalize_text(s) tokens = re.findall(r"[\u4e00-\u9fff]+|[a-z0-9]+", norm) return tokens def _jaccard(a_tokens: List[str], b_tokens: List[str]) -> float: + """Jaccard相似度：计算两个token集合的交集/并集""" try: set_a, set_b = set(a_tokens), set(b_tokens) if not set_a and not set_b: @@ -192,10 +281,11 @@ def fuzzy_match( return 0.0 def _cosine(a: List[float], b: List[float]) -> float: + """余弦相似度：计算两个向量的夹角余弦值""" try: if not a or not b or len(a) != len(b): return 0.0 - dot = sum(x * y for x, y in zip(a, b)) + dot = sum(x * y for x, y in zip(a, b, strict=False)) na = sum(x * x for x in a) ** 0.5 nb = sum(y * y for y in b) ** 0.5 if na == 0 or nb == 0: @@ -204,44 +294,146 @@ def fuzzy_match( except Exception: return 0.0 - def _name_similarity(e1: ExtractedEntityNode, e2: ExtractedEntityNode): + # ========== 第二层：中层工具函数 ========== + + def _has_exact_alias_match(e1: ExtractedEntityNode, e2: ExtractedEntityNode) -> bool: + """检测两个实体之间是否存在完全别名匹配（case-insensitive） + + 检查以下情况： + - e1的主名称与e2的某个别名完全匹配 + - e2的主名称与e1的某个别名完全匹配 + - e1和e2的别名列表有交集 + + Args: + e1: 第一个实体 + e2: 第二个实体 + + Returns: + bool: 存在完全匹配返回True + """ + def _simple_normalize(s: str) -> str: + return (s or "").strip().lower() + + # 获取e1的所有名称（主名称 + 别名） + names1 = set() + name1 = _simple_normalize(getattr(e1, "name", "") or "") + if name1: + names1.add(name1) + + aliases1 = getattr(e1, "aliases", []) or [] + for alias in aliases1: + normalized = _simple_normalize(alias) + if normalized: + names1.add(normalized) + + # 获取e2的所有名称（主名称 + 别名） + names2 = set() + name2 = _simple_normalize(getattr(e2, "name", "") or "") + if name2: + names2.add(name2) + + aliases2 = getattr(e2, "aliases", []) or [] + for alias in aliases2: + normalized = _simple_normalize(alias) + if normalized: + names2.add(normalized) + + # 检查是否有交集 + if names1 & names2: + return True + + return False + + # ========== 第三层：高层综合函数 ========== + + def _name_similarity_with_aliases(e1: ExtractedEntityNode, e2: ExtractedEntityNode): + """名称相似度综合评分系统 + + 综合考虑主名称和别名，计算两个实体的相似度。 + + 算法： + 1. 计算主名称的向量相似度和Token Jaccard相似度 + 2. 计算所有别名的Token Jaccard相似度 + 3. 找出所有名称间的最佳匹配 + 4. 使用 _has_exact_alias_match 检测是否存在完全匹配 + + 评分权重： + - 有完全匹配：embedding(40%) + primary_jaccard(20%) + max_alias_sim(40%) + - 无完全匹配：embedding(60%) + primary_jaccard(20%) + max_alias_sim(20%) + + Args: + e1: 第一个实体 + e2: 第二个实体 + + Returns: + tuple: (综合相似度, 向量相似度, 主名称Jaccard, 别名Jaccard, + 最佳别名匹配度, 是否完全匹配) + """ + # 1. 主名称向量相似度 emb_sim = _cosine(getattr(e1, "name_embedding", []) or [], getattr(e2, "name_embedding", []) or []) + + # 2. 主名称token相似度 + + # 2. 主名称token相似度 tokens1 = set(_tokenize(getattr(e1, "name", "") or "")) tokens2 = set(_tokenize(getattr(e2, "name", "") or "")) + j_primary = _jaccard(list(tokens1), list(tokens2)) + + # 3. 获取所有别名 + j_primary = _jaccard(list(tokens1), list(tokens2)) + + # 3. 获取所有别名 aliases1 = getattr(e1, "aliases", []) or [] aliases2 = getattr(e2, "aliases", []) or [] + + # 4. 计算所有别名的token集合（用于整体Jaccard） + + # 4. 计算所有别名的token集合（用于整体Jaccard） alias_tokens1 = set(tokens1) alias_tokens2 = set(tokens2) for a in aliases1: alias_tokens1 |= set(_tokenize(a)) for a in aliases2: alias_tokens2 |= set(_tokenize(a)) - j_primary = _jaccard(list(tokens1), list(tokens2)) j_alias = _jaccard(list(alias_tokens1), list(alias_tokens2)) - s_name = 0.6 * emb_sim + 0.2 * j_primary + 0.2 * j_alias - return s_name, emb_sim, j_primary, j_alias - - def _desc_similarity(e1: ExtractedEntityNode, e2: ExtractedEntityNode): - """ - 计算实体描述的相似度（Jaccard + SequenceMatcher） - 返回: (相似度得分, Jaccard 相似度(词重合), SequenceMatcher 相似度（序列相似）) - """ - d1 = getattr(e1, "description", "") or "" - d2 = getattr(e2, "description", "") or "" - if not d1 and not d2: - return 0.0, 0.0, 0.0 - t1 = _tokenize(d1) - t2 = _tokenize(d2) - j = _jaccard(t1, t2) - try: - seq = difflib.SequenceMatcher(None, _normalize_text(d1), _normalize_text(d2)).ratio() - except Exception: - seq = 0.0 - # 平衡词重合与序列相似（更鲁棒） - s_desc = 0.5 * j + 0.5 * seq - return s_desc, j, seq - - def _canonicalize_type(t: str) -> str: # 扩展类型同义归一 + + # 5. 使用 _has_exact_alias_match 检测完全匹配 + has_exact_match = _has_exact_alias_match(e1, e2) + + # 6. 计算最佳别名匹配度（所有名称两两比较） + all_names1 = [getattr(e1, "name", "") or "", *aliases1] + all_names2 = [getattr(e2, "name", "") or "", *aliases2] + + max_alias_sim = 0.0 + + if has_exact_match: + max_alias_sim = 1.0 + else: + for n1 in all_names1: + if not n1: + continue + tokens_n1 = set(_tokenize(n1)) + + for n2 in all_names2: + if not n2: + continue + + tokens_n2 = set(_tokenize(n2)) + sim = _jaccard(list(tokens_n1), list(tokens_n2)) + max_alias_sim = max(max_alias_sim, sim) + + # 7. 综合评分 + if has_exact_match: + s_name = 0.4 * emb_sim + 0.2 * j_primary + 0.4 * max_alias_sim + else: + s_name = 0.6 * emb_sim + 0.2 * j_primary + 0.2 * max_alias_sim + + return s_name, emb_sim, j_primary, j_alias, max_alias_sim, has_exact_match + + # ========== 类型相似度工具函数 ========== + + def _canonicalize_type(t: str) -> str: + """类型标准化：将各种类型别名映射到规范类型""" t = (t or "").strip() if not t: return "" @@ -279,6 +471,7 @@ def fuzzy_match( return t_up def _type_similarity(t1: str, t2: str) -> float: + """类型相似度：计算两个类型的相似度（基于规范化和相似度表）""" import difflib c1 = _canonicalize_type(t1) c2 = _canonicalize_type(t2) @@ -313,87 +506,196 @@ def fuzzy_match( t2n = (t2 or "").strip().lower() seq_ratio = difflib.SequenceMatcher(None, t1n, t2n).ratio() return seq_ratio * 0.6 - # 阈值与权重设定（从配置读取；若无配置则使用 DedupConfig 的默认值） + # 阈值与权重设定 _defaults = DedupConfig() + + # 核心阈值 T_NAME_STRICT = (config.fuzzy_name_threshold_strict if config is not None else _defaults.fuzzy_name_threshold_strict) T_TYPE_STRICT = (config.fuzzy_type_threshold_strict if config is not None else _defaults.fuzzy_type_threshold_strict) T_OVERALL = (config.fuzzy_overall_threshold if config is not None else _defaults.fuzzy_overall_threshold) UNKNOWN_NAME_T = (config.fuzzy_unknown_type_name_threshold if config is not None else _defaults.fuzzy_unknown_type_name_threshold) UNKNOWN_TYPE_T = (config.fuzzy_unknown_type_type_threshold if config is not None else _defaults.fuzzy_unknown_type_type_threshold) - W_NAME = (config.name_weight if config is not None else _defaults.name_weight) - W_DESC = (config.desc_weight if config is not None else _defaults.desc_weight) - W_TYPE = (config.type_weight if config is not None else _defaults.type_weight) - CTX_BONUS = (config.context_bonus if config is not None else _defaults.context_bonus) # 上下文共现加分 - FALL_FLOOR = (config.llm_fallback_floor if config is not None else _defaults.llm_fallback_floor) - FALL_CEIL = (config.llm_fallback_ceiling if config is not None else _defaults.llm_fallback_ceiling) + + # 权重：名称70%，类型30% + W_NAME = 0.7 + W_TYPE = 0.3 + def _merge_entities_with_aliases(canonical: ExtractedEntityNode, losing: ExtractedEntityNode): + """ 模糊匹配中的实体合并。 + + 合并策略： + 1. 保留canonical的主名称不变 + 2. 将losing的主名称添加为alias（如果不同） + 3. 合并两个实体的所有aliases + 4. 自动去重（case-insensitive）并排序 + + Args: + canonical: 规范实体（保留） + losing: 被合并实体（删除） + + Note: + 使用alias_utils.normalize_aliases进行标准化去重 + """ + # 获取规范实体的名称 + canonical_name = (getattr(canonical, "name", "") or "").strip() + losing_name = (getattr(losing, "name", "") or "").strip() + + # 收集所有需要合并的别名 + all_aliases = [] + + # 1. 添加canonical现有的别名 + current_aliases = getattr(canonical, "aliases", []) or [] + all_aliases.extend(current_aliases) + + # 2. 添加losing实体的名称（如果不同于canonical的名称） + if losing_name and losing_name != canonical_name: + all_aliases.append(losing_name) + + # 3. 添加losing实体的所有别名 + losing_aliases = getattr(losing, "aliases", []) or [] + all_aliases.extend(losing_aliases) + + # 4. 标准化并去重（使用标准化后的字符串进行去重） + try: + from app.core.memory.utils.alias_utils import normalize_aliases + canonical.aliases = normalize_aliases(canonical_name, all_aliases) + except Exception: + # 如果导入失败，使用增强的去重逻辑 + # 使用标准化后的字符串作为key进行去重 + seen_normalized = set() + unique_aliases = [] + + for alias in all_aliases: + if not alias: + continue + + alias_stripped = str(alias).strip() + if not alias_stripped or alias_stripped == canonical_name: + continue + + # 标准化：转小写用于去重判断 + alias_normalized = alias_stripped.lower() + + if alias_normalized not in seen_normalized: + seen_normalized.add(alias_normalized) + unique_aliases.append(alias_stripped) + + # 排序并赋值 + canonical.aliases = sorted(unique_aliases) + + # ========== 主循环：遍历所有实体对进行模糊匹配 ========== i = 0 while i < len(deduped_entities): a = deduped_entities[i] j = i + 1 while j < len(deduped_entities): b = deduped_entities[j] + + # 跳过不同业务组的实体 if getattr(a, "group_id", None) != getattr(b, "group_id", None): j += 1 continue - # 上下文共现 - try: - sources_a = {e.source for e in statement_entity_edges if getattr(e, "target", None) == getattr(a, "id", None)} - sources_b = {e.source for e in statement_entity_edges if getattr(e, "target", None) == getattr(b, "id", None)} - co_ctx = bool(sources_a & sources_b) - except Exception: - co_ctx = False - s_name, emb_sim, j_primary, j_alias = _name_similarity(a, b) - s_desc, j_desc, seq_desc = _desc_similarity(a, b) + + # ========== 第一步：计算相似度分数 ========== + + # 1.1 名称+别名相似度（包含完全匹配检测） + s_name, emb_sim, j_primary, j_alias, max_alias_sim, has_exact_match = _name_similarity_with_aliases(a, b) + + # 1.2 类型相似度 s_type = _type_similarity(getattr(a, "entity_type", None), getattr(b, "entity_type", None)) + + # ========== 第二步：动态调整阈值 ========== + + # 2.1 检测是否存在UNKNOWN类型 unknown_present = ( str(getattr(a, "entity_type", "")).upper() == "UNKNOWN" or str(getattr(b, "entity_type", "")).upper() == "UNKNOWN" ) + + # 2.2 根据类型设置名称阈值 tn = UNKNOWN_NAME_T if unknown_present else T_NAME_STRICT - tn = min(tn, 0.88) if co_ctx else tn + + # 2.3 如果有完全别名匹配，降低名称相似度阈值 + if has_exact_match: + tn = min(tn, 0.75) + + # 2.4 设置类型阈值和综合阈值 type_threshold = UNKNOWN_TYPE_T if unknown_present else T_TYPE_STRICT tover = T_OVERALL - a_cs = (getattr(a, "connect_strength", "") or "").lower() - b_cs = (getattr(b, "connect_strength", "") or "").lower() - if a_cs in ("strong", "both") or b_cs in ("strong", "both"): - tover = 0.80 - # 综合评分：名称、描述、类型加权 + 上下文加分 - overall = W_NAME * s_name + W_DESC * s_desc + W_TYPE * s_type + (CTX_BONUS if co_ctx else 0.0) + + # ========== 第三步：计算综合评分 ========== + # 公式：overall = 名称权重(70%) × 名称相似度 + 类型权重(30%) × 类型相似度 + overall = W_NAME * s_name + W_TYPE * s_type + + # ========== 第四步：特殊规则判断（别名完全匹配快速通道）========== + + # 4.1 检查主名称是否相同 + name_a_normalized = (getattr(a, "name", "") or "").strip().lower() + name_b_normalized = (getattr(b, "name", "") or "").strip().lower() + same_name = (name_a_normalized == name_b_normalized) and name_a_normalized != "" + + # 4.2 别名匹配特殊规则（满足任一条件即可快速合并） + alias_match_merge = False + + # 规则1：别名完全匹配 + 类型相似度 ≥ 0.7 + if has_exact_match and s_type >= 0.7: + alias_match_merge = True + + # 规则2：名称相同 + 别名匹配 + 类型相似度 ≥ 0.5 + elif same_name and has_exact_match and s_type >= 0.5: + alias_match_merge = True + + # 规则3：名称相同 + 别名匹配 + 类型完全相同 + elif same_name and has_exact_match and s_type >= 1.0: + alias_match_merge = True - if s_name >= tn and s_type >= type_threshold and overall >= tover: + # ========== 第五步：最终合并判断 ========== + # 满足以下任一条件即执行合并： + # 条件A（快速通道）：alias_match_merge = True + # 条件B（标准通道）：s_name ≥ tn AND s_type ≥ type_threshold AND overall ≥ tover + if alias_match_merge or (s_name >= tn and s_type >= type_threshold and overall >= tover): + # ========== 第六步：执行实体合并 ========== + + # 6.1 合并别名 + _merge_entities_with_aliases(a, b) + + # 6.2 合并其他属性（描述、事实摘要、时间范围等） _merge_attribute(a, b) + + # 6.3 记录合并日志 try: + merge_reason = "[别名匹配]" if alias_match_merge else "[模糊]" + merge_reason = "[别名匹配]" if alias_match_merge else "[模糊]" fuzzy_merge_records.append( - f"[模糊] 规范实体 {a.id} ({a.group_id}|{a.name}|{a.entity_type}) <- 合并实体 {b.id} ({b.group_id}|{b.name}|{b.entity_type}) | s_name={s_name:.3f}, s_desc={s_desc:.3f}, s_type={s_type:.3f}, overall={overall:.3f}, ctx={co_ctx}" + f"{merge_reason} 规范实体 {a.id} ({a.group_id}|{a.name}|{a.entity_type}) <- 合并实体 {b.id} ({b.group_id}|{b.name}|{b.entity_type}) | " + f"s_name={s_name:.3f}, s_type={s_type:.3f}, overall={overall:.3f}, exact_alias={has_exact_match}" ) except Exception: pass - # 用于处理合并实体后，Statement节点下方无挂载边的情况 后续考虑将其代码逻辑统一由关系去重消歧管理 - # 建立 ID 重定向：将合并实体 b 的 ID 指向规范实体 a 的 ID + + # 6.4 建立 ID 重定向映射 try: canonical_id = id_redirect.get(getattr(a, "id", None), getattr(a, "id", None)) losing_id = getattr(b, "id", None) if losing_id and canonical_id: + # 将被合并实体的ID指向规范实体 id_redirect[losing_id] = canonical_id - # 扁平化可能的重定向链：凡是映射到 b.id 的，统一指向 a.id + + # 扁平化重定向链：确保所有指向losing_id的映射都指向canonical_id for k, v in list(id_redirect.items()): if v == losing_id: id_redirect[k] = canonical_id except Exception: pass + + # 6.5 从列表中移除被合并的实体 deduped_entities.pop(j) - continue + continue # 不增加j，继续检查当前位置的下一个实体 + + # ========== 未达到合并条件：检查下一对 ========== else: - try: - if s_name >= tn and s_type >= type_threshold and (FALL_FLOOR <= overall < tover) and (overall <= FALL_CEIL): - fuzzy_merge_records.append( - f"[边界] {a.id}<->{b.id} ({a.group_id}|{a.name}|{a.entity_type} ~ {b.group_id}|{b.name}|{b.entity_type}) | s_name={s_name:.3f}, s_desc={s_desc:.3f}, s_type={s_type:.3f}, overall={overall:.3f}, ctx={co_ctx}" - ) - except Exception: - pass - j += 1 + j += 1 # 移动到下一个实体 i += 1 return deduped_entities, id_redirect, fuzzy_merge_records @@ -428,24 +730,30 @@ async def LLM_decision( # 决策中包含去重和消歧的功能 pair_concurrency = (config.llm_pair_concurrency if config is not None else _defaults.llm_pair_concurrency) max_rounds = (config.llm_max_rounds if config is not None else _defaults.llm_max_rounds) - # 动态导入 llm 客户端（统一从 app.core.memory.utils.llm_utils 获取） + # 动态导入 llm 客户端（修正导入路径） try: - llm_utils_mod = importlib.import_module("app.core.memory.utils.llm_utils") - get_llm_client_fn = getattr(llm_utils_mod, "get_llm_client") - except Exception: - get_llm_client_fn = lambda: None + llm_utils_mod = importlib.import_module("app.core.memory.utils.llm.llm_utils") + get_llm_client_fn = llm_utils_mod.get_llm_client + except Exception as e: + llm_records.append(f"[LLM错误] 无法导入 llm_utils 模块: {e}") + return deduped_entities, id_redirect, llm_records try: llm_mod = importlib.import_module("app.core.memory.storage_services.extraction_engine.deduplication.entity_dedup_llm") - llm_fn = getattr(llm_mod, "llm_dedup_entities_iterative_blocks") - except Exception: - raise RuntimeError("LLM 模块加载失败：deduplication.entity_dedup_llm 缺少 llm_dedup_entities_iterative_blocks") + llm_fn = llm_mod.llm_dedup_entities_iterative_blocks + except Exception as e: + llm_records.append(f"[LLM错误] 无法导入 entity_dedup_llm 模块: {e}") + return deduped_entities, id_redirect, llm_records - # 获取 LLM 客户端，若环境未配置或抛错则回退为 None + # 获取 LLM 客户端 try: llm_client = get_llm_client_fn() - except Exception: - llm_client = None + if llm_client is None: + llm_records.append("[LLM错误] LLM 客户端初始化失败：返回 None") + return deduped_entities, id_redirect, llm_records + except Exception as e: + llm_records.append(f"[LLM错误] 获取 LLM 客户端失败: {e}") + return deduped_entities, id_redirect, llm_records llm_redirect, llm_records = await llm_fn( entity_nodes=deduped_entities, @@ -527,7 +835,13 @@ async def LLM_disamb_decision( from app.core.memory.utils.llm.llm_utils import get_llm_client from app.core.memory.storage_services.extraction_engine.deduplication.entity_dedup_llm import llm_disambiguate_pairs_iterative from app.core.memory.utils.config import definitions as config_defs + + # 获取 LLM 客户端并验证 llm_client = get_llm_client(config_defs.SELECTED_LLM_ID) + if llm_client is None: + disamb_records.append("[DISAMB错误] LLM 客户端初始化失败：返回 None") + return deduped_entities, id_redirect, blocked_pairs, disamb_records + merge_redirect, block_list, disamb_records = await llm_disambiguate_pairs_iterative( entity_nodes=deduped_entities, statement_entity_edges=statement_entity_edges, @@ -708,7 +1022,7 @@ def _write_dedup_fusion_report( aggregated_exact_lines: List[str] = [] try: for k, info in (exact_merge_map or {}).items(): - merged_ids = sorted(list(info.get("merged_ids", set()))) + merged_ids = sorted(info.get("merged_ids", set())) if merged_ids: aggregated_exact_lines.append( f"[精确] 键 {k} 规范实体 {info.get('canonical_id')} 名称 '{info.get('name')}' 类型 {info.get('entity_type')} <- 合并实体IDs {', '.join(merged_ids)}" diff --git a/api/app/core/memory/storage_services/extraction_engine/deduplication/entity_dedup_llm.py b/api/app/core/memory/storage_services/extraction_engine/deduplication/entity_dedup_llm.py index 01799941..2c784d42 100644 --- a/api/app/core/memory/storage_services/extraction_engine/deduplication/entity_dedup_llm.py +++ b/api/app/core/memory/storage_services/extraction_engine/deduplication/entity_dedup_llm.py @@ -5,6 +5,8 @@ import asyncio import difflib +import json +import logging from typing import List, Tuple, Dict import anyio @@ -12,6 +14,12 @@ from app.core.memory.llm_tools.openai_client import OpenAIClient from app.core.memory.models.graph_models import ExtractedEntityNode, StatementEntityEdge, EntityEntityEdge from app.core.memory.models.dedup_models import EntityDedupDecision, EntityDisambDecision from app.core.memory.utils.prompt.prompt_utils import render_entity_dedup_prompt +from app.core.memory.storage_services.extraction_engine.deduplication.deduped_and_disamb import ( + _merge_attribute, + _unify_entity_type +) + +logger = logging.getLogger(__name__) # --- 类型同义归并与相似度 --- @@ -55,13 +63,37 @@ def _simple_type_ok(t1: str | None, t2: str | None) -> bool: return c1 == c2 +def parse_llm_response_safe(response_text: str, response_model) -> EntityDedupDecision | EntityDisambDecision | None: + """安全解析LLM响应，带错误处理。 + + Args: + response_text: LLM返回的JSON文本 + response_model: 期望的响应模型类（EntityDedupDecision或EntityDisambDecision） + + Returns: + 解析后的决策对象，如果解析失败则返回None + """ + try: + data = json.loads(response_text) + + # 使用Pydantic模型验证和解析 + return response_model(**data) + + except json.JSONDecodeError as e: + logger.warning(f"LLM response JSON parsing failed: {e}") + return None + except Exception as e: + logger.warning(f"LLM response parsing failed: {e}") + return None + + def _name_embed_sim(a: List[float] | None, b: List[float] | None) -> float: # 计算实体名称嵌入向量的余弦相似度 a = a or [] b = b or [] if not a or not b or len(a) != len(b): return 0.0 try: - dot = sum(x * y for x, y in zip(a, b)) + dot = sum(x * y for x, y in zip(a, b, strict=False)) na = (sum(x * x for x in a)) ** 0.5 nb = (sum(y * y for y in b)) ** 0.5 if na > 0 and nb > 0: @@ -174,6 +206,7 @@ async def _judge_pair( entity_b=entity_b, context=ctx, json_schema=EntityDedupDecision.model_json_schema(), + disambiguation_mode=False, # 去重模式 ) messages = [ @@ -290,6 +323,33 @@ async def llm_dedup_entities( # 保留对偶判断作为子流程，是为了 # 规则2：类型必须兼容（调用_simple_type_ok判断） if not _simple_type_ok(getattr(a, "entity_type", None), getattr(b, "entity_type", None)): continue + + # 规则2.5：过滤掉应该在模糊匹配阶段就被合并的实体对 + # 如果名称相同且别名有交集，说明应该在模糊匹配阶段就被合并了 + # 这些实体对不应该进入LLM阶段，避免重复处理 + try: + name_a = (getattr(a, "name", "") or "").strip().lower() + name_b = (getattr(b, "name", "") or "").strip().lower() + same_name = (name_a == name_b) and name_a != "" + + if same_name: + # 检查别名是否有交集 + names_a = {name_a} + names_a |= {(alias or "").strip().lower() for alias in (getattr(a, "aliases", []) or [])} + names_a.discard("") + + names_b = {name_b} + names_b |= {(alias or "").strip().lower() for alias in (getattr(b, "aliases", []) or [])} + names_b.discard("") + + has_alias_overlap = bool(names_a & names_b) + + # 如果名称相同且别名有交集，跳过（应该在模糊匹配阶段处理） + if has_alias_overlap: + continue + except Exception: + pass # 如果检查失败，继续处理（保守策略） + # 规则3：名称相似度达标（文本/嵌入相似度取最大值） txt_sim = _name_text_sim(getattr(a, "name", ""), getattr(b, "name", "")) emb_sim = _name_embed_sim(getattr(a, "name_embedding", []), getattr(b, "name_embedding", [])) @@ -317,6 +377,7 @@ async def llm_dedup_entities( # 保留对偶判断作为子流程，是为了 try: result_list[idx] = await _judge_pair(llm_client, entity_nodes[i], entity_nodes[j], statement_entity_edges, entity_entity_edges) except Exception as e: + logger.error(f"Error judging pair ({i}, {j}): {e}", exc_info=True) result_list[idx] = e # Limit concurrency using semaphore @@ -349,7 +410,12 @@ async def llm_dedup_entities( # 保留对偶判断作为子流程，是为了 canon_idx = decision.canonical_idx if decision.canonical_idx in (0, 1) else _choose_canonical(a, b) canon = a if canon_idx == 0 else b other = b if canon_idx == 0 else a - id_redirect_updates[getattr(other, "id")] = getattr(canon, "id") + + # 应用LLM合并决策：合并属性和统一类型 + _merge_attribute(canon, other) + _unify_entity_type(canon, other, suggested_type=None) + + id_redirect_updates[other.id] = canon.id records.append( f"[LLM合并] 规范实体 {canon.id} 名称 '{getattr(canon, 'name', '')}' <- 合并实体 {other.id} 名称 '{getattr(other, 'name', '')}' | conf={decision.confidence:.3f}, th={th:.3f}, co_ctx={ctx.get('co_occurrence')}" ) @@ -508,8 +574,11 @@ async def llm_dedup_entities_iterative_blocks( # 迭代分块并发 LLM 去重 async def _run_block_wrapper(idx: int, block: List[ExtractedEntityNode]): try: results[idx] = await _run_one_block(idx, block) - except Exception as e: + except BaseException as e: + logger.error(f"Error in block {idx}: {e}", exc_info=True) results[idx] = e + if isinstance(e, (KeyboardInterrupt, SystemExit)): + raise for i in range(len(blocks)): tg.start_soon(_run_block_wrapper, i, blocks[i]) @@ -607,6 +676,7 @@ async def llm_disambiguate_pairs_iterative( try: judged[idx] = await _judge_pair_disamb(llm_client, entity_nodes[i], entity_nodes[j], statement_entity_edges, entity_entity_edges) except Exception as e: + logger.error(f"Error in disamb pair ({i}, {j}): {e}", exc_info=True) judged[idx] = e # Limit concurrency using semaphore @@ -634,6 +704,11 @@ async def llm_disambiguate_pairs_iterative( can_idx = 0 if decision.canonical_idx == 0 else 1 canonical = a if can_idx == 0 else b losing = b if can_idx == 0 else a + + # 应用LLM合并决策：合并属性和统一类型 + _merge_attribute(canonical, losing) + _unify_entity_type(canonical, losing, suggested_type=decision.suggested_type) + merge_redirect[getattr(losing, "id", "")] = getattr(canonical, "id", "") records.append( f"[DISAMB合并] {getattr(losing,'id','')} -> {getattr(canonical,'id','')} | conf={decision.confidence:.2f} | reason={decision.reason} | suggested_type={decision.suggested_type or ''}" @@ -663,6 +738,11 @@ async def llm_disambiguate_pairs_iterative( sb = _strength_rank(getattr(b, "connect_strength", None)) canonical = a if sa >= sb else b losing = b if sa >= sb else a + + # 应用LLM合并决策：合并属性和统一类型 + _merge_attribute(canonical, losing) + _unify_entity_type(canonical, losing, suggested_type=decision.suggested_type) + merge_redirect[getattr(losing, "id", "")] = getattr(canonical, "id", "") # 消歧合并审计 records.append( diff --git a/api/app/core/memory/storage_services/extraction_engine/extraction_orchestrator.py b/api/app/core/memory/storage_services/extraction_engine/extraction_orchestrator.py index 3cf74b41..024a812b 100644 --- a/api/app/core/memory/storage_services/extraction_engine/extraction_orchestrator.py +++ b/api/app/core/memory/storage_services/extraction_engine/extraction_orchestrator.py @@ -36,8 +36,8 @@ from app.core.memory.models.variate_config import ( ExtractionPipelineConfig, StatementExtractionConfig, ) -from app.core.memory.src.llm_tools.openai_client import LLMClient -from app.core.memory.src.llm_tools.openai_embedder import OpenAIEmbedderClient +from app.core.memory.llm_tools.openai_client import LLMClient +from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient from app.repositories.neo4j.neo4j_connector import Neo4jConnector # 导入各个提取模块 @@ -349,7 +349,7 @@ class ExtractionOrchestrator: if all_responses: try: self.triplet_extractor.save_triplets(all_responses) - logger.info(f"三元组数据已保存到文件") + logger.info("三元组数据已保存到文件") except Exception as e: logger.error(f"保存三元组到文件失败: {e}", exc_info=True) @@ -842,6 +842,7 @@ class ExtractionOrchestrator: description=getattr(entity, 'description', ''), # 添加必需的 description 字段 fact_summary=getattr(entity, 'fact_summary', ''), # 添加必需的 fact_summary 字段 connect_strength=entity_connect_strength if entity_connect_strength is not None else 'Strong', # 添加必需的 connect_strength 字段 + aliases=getattr(entity, 'aliases', []) or [], # 传递从三元组提取阶段获取的aliases name_embedding=getattr(entity, 'name_embedding', None), group_id=dialog_data.group_id, user_id=dialog_data.user_id, diff --git a/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/embedding_generation.py b/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/embedding_generation.py index 0dc48815..396c1e9e 100644 --- a/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/embedding_generation.py +++ b/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/embedding_generation.py @@ -7,7 +7,7 @@ import asyncio from typing import List, Dict, Any, Tuple from app.core.memory.models.message_models import DialogData -from app.core.memory.src.llm_tools.openai_embedder import OpenAIEmbedderClient +from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient from app.core.memory.utils.config.config_utils import get_embedder_config from app.core.models.base import RedBearModelConfig diff --git a/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/memory_summary.py b/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/memory_summary.py index 4c62bd4c..ffd4ed12 100644 --- a/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/memory_summary.py +++ b/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/memory_summary.py @@ -12,7 +12,7 @@ logger = get_memory_logger(__name__) from app.core.memory.models.graph_models import MemorySummaryNode from app.core.memory.models.base_response import RobustLLMResponse from app.core.models.base import RedBearModelConfig -from app.core.memory.src.llm_tools.openai_embedder import OpenAIEmbedderClient +from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient from app.core.memory.utils.config.config_utils import get_embedder_config from app.core.memory.utils.prompt.prompt_utils import render_memory_summary_prompt from uuid import uuid4 diff --git a/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/temporal_extraction.py b/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/temporal_extraction.py index 646ae914..9528e638 100644 --- a/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/temporal_extraction.py +++ b/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/temporal_extraction.py @@ -3,7 +3,7 @@ import asyncio from datetime import datetime from typing import Any, Optional from pydantic import BaseModel, Field -from app.core.memory.src.llm_tools.openai_client import OpenAIClient +from app.core.memory.llm_tools.openai_client import OpenAIClient from app.core.memory.models.message_models import DialogData, Statement, TemporalValidityRange from app.core.memory.utils.prompt.prompt_utils import render_temporal_extraction_prompt from app.core.memory.utils.data.ontology import LABEL_DEFINITIONS, TemporalInfo @@ -218,5 +218,5 @@ class TemporalExtractor: f.write(f" - Valid At: {statement.temporal_validity.valid_at}\n") f.write(f" - Invalid At: {statement.temporal_validity.invalid_at}\n") else: - f.write(f" - Temporal Validity: Not Extracted\n") + f.write(" - Temporal Validity: Not Extracted\n") f.write("\n") diff --git a/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/triplet_extraction.py b/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/triplet_extraction.py index c65d5b74..d3d059b0 100644 --- a/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/triplet_extraction.py +++ b/api/app/core/memory/storage_services/extraction_engine/knowledge_extraction/triplet_extraction.py @@ -3,7 +3,7 @@ import asyncio from typing import List, Dict from app.core.logging_config import get_memory_logger -from app.core.memory.src.llm_tools.openai_client import OpenAIClient +from app.core.memory.llm_tools.openai_client import OpenAIClient from app.core.memory.utils.prompt.prompt_utils import render_triplet_extraction_prompt from app.core.memory.utils.data.ontology import PREDICATE_DEFINITIONS, Predicate # 引入枚举 Predicate 白名单过滤 from app.core.memory.models.triplet_models import TripletExtractionResponse diff --git a/api/app/core/memory/storage_services/search/__init__.py b/api/app/core/memory/storage_services/search/__init__.py index 1109ed3e..04a7a4c2 100644 --- a/api/app/core/memory/storage_services/search/__init__.py +++ b/api/app/core/memory/storage_services/search/__init__.py @@ -58,7 +58,7 @@ async def run_hybrid_search( dict: 搜索结果字典，格式与旧API兼容 """ from app.repositories.neo4j.neo4j_connector import Neo4jConnector - from app.core.memory.src.llm_tools.openai_embedder import OpenAIEmbedderClient + from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient from app.core.memory.utils.config.config_utils import get_embedder_config from app.core.memory.utils.config import definitions as config_defs from app.core.models.base import RedBearModelConfig diff --git a/api/app/core/memory/storage_services/search/hybrid_chatbot.py b/api/app/core/memory/storage_services/search/hybrid_chatbot.py index 5b3e6827..40a65263 100644 --- a/api/app/core/memory/storage_services/search/hybrid_chatbot.py +++ b/api/app/core/memory/storage_services/search/hybrid_chatbot.py @@ -15,7 +15,7 @@ from typing import Any, Dict, Tuple, List from app.core.memory.storage_services.search import run_hybrid_search # 使用新的仓储层 from app.repositories.neo4j.neo4j_connector import Neo4jConnector -from app.core.memory.src.llm_tools.openai_client import OpenAIClient +from app.core.memory.llm_tools.openai_client import OpenAIClient from app.core.memory.models.config_models import LLMConfig from dotenv import load_dotenv diff --git a/api/app/core/memory/storage_services/search/hybrid_search.py b/api/app/core/memory/storage_services/search/hybrid_search.py index 8203aacf..1c834947 100644 --- a/api/app/core/memory/storage_services/search/hybrid_search.py +++ b/api/app/core/memory/storage_services/search/hybrid_search.py @@ -13,7 +13,7 @@ from app.repositories.neo4j.neo4j_connector import Neo4jConnector from app.core.memory.storage_services.search.search_strategy import SearchStrategy, SearchResult from app.core.memory.storage_services.search.keyword_search import KeywordSearchStrategy from app.core.memory.storage_services.search.semantic_search import SemanticSearchStrategy -from app.core.memory.src.llm_tools.openai_embedder import OpenAIEmbedderClient +from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient from app.core.memory.models.variate_config import ForgettingEngineConfig from app.core.memory.storage_services.forgetting_engine.forgetting_engine import ForgettingEngine diff --git a/api/app/core/memory/storage_services/search/semantic_search.py b/api/app/core/memory/storage_services/search/semantic_search.py index 38c58cc1..363ff1aa 100644 --- a/api/app/core/memory/storage_services/search/semantic_search.py +++ b/api/app/core/memory/storage_services/search/semantic_search.py @@ -10,7 +10,7 @@ from app.core.logging_config import get_memory_logger from app.repositories.neo4j.neo4j_connector import Neo4jConnector from app.core.memory.storage_services.search.search_strategy import SearchStrategy, SearchResult from app.repositories.neo4j.graph_search import search_graph_by_embedding -from app.core.memory.src.llm_tools.openai_embedder import OpenAIEmbedderClient +from app.core.memory.llm_tools.openai_embedder import OpenAIEmbedderClient from app.core.memory.utils.config.config_utils import get_embedder_config from app.core.memory.utils.config import definitions as config_defs from app.core.models.base import RedBearModelConfig diff --git a/api/app/core/memory/utils/alias_utils.py b/api/app/core/memory/utils/alias_utils.py new file mode 100644 index 00000000..df75752a --- /dev/null +++ b/api/app/core/memory/utils/alias_utils.py @@ -0,0 +1,314 @@ +""" +Utility functions for entity alias management. + +This module provides functions for validating, adding, merging, and normalizing +entity aliases in the knowledge graph system. +""" + +import logging +from typing import List, Any, Dict, Set + +logger = logging.getLogger(__name__) + + +def validate_aliases(v: Any) -> List[str]: + """Validate and clean aliases field. + + Filters out invalid values (None, empty strings, non-strings), removes duplicates, + and ensures the field is always a list. + + Args: + v: The aliases value to validate + + Returns: + A cleaned list of unique string aliases + """ + if v is None: + return [] + if not isinstance(v, list): + return [] + + # Filter and clean: keep only valid strings, strip whitespace, remove duplicates + seen = set() + result = [] + for a in v: + if a and isinstance(a, (str, int, float)): + cleaned = str(a).strip() + if cleaned and cleaned not in seen: + seen.add(cleaned) + result.append(cleaned) + return result + + +def add_alias(entity_name: str, current_aliases: List[str], new_alias: str) -> List[str]: + """Add a single alias to an entity's alias list. + + Automatically handles deduplication and normalization. Ignores empty strings + and aliases that match the entity's primary name. + + Args: + entity_name: The primary name of the entity + current_aliases: Current list of aliases + new_alias: The alias to add + + Returns: + Updated list of aliases + """ + if not new_alias or new_alias == entity_name: + return current_aliases + + normalized = new_alias.strip() + if normalized and normalized not in current_aliases: + return [*current_aliases, normalized] + + return current_aliases + + +def merge_aliases(entity_name: str, aliases1: List[str], aliases2: List[str]) -> List[str]: + """Merge two alias lists. + + Automatically handles deduplication by adding each alias from the second list + to the first list. + + Args: + entity_name: The primary name of the entity + aliases1: First list of aliases + aliases2: Second list of aliases to merge + + Returns: + Merged list of aliases without duplicates + """ + result = list(aliases1) + for alias in aliases2: + result = add_alias(entity_name, result, alias) + return result + + +def normalize_aliases(entity_name: str, aliases: List[str]) -> List[str]: + """Normalize an alias list. + + Performs the following operations: + - Removes duplicates (case-insensitive comparison) + - Sorts alphabetically + - Removes any aliases that match the primary name + - Strips whitespace from all entries + - Preserves the original case of the first occurrence + + Args: + entity_name: The primary name of the entity + aliases: List of aliases to normalize + + Returns: + Normalized and sorted list of aliases + """ + # 使用字典来去重，key是小写形式，value是原始形式 + seen_normalized = {} + entity_name_lower = entity_name.strip().lower() + + for alias in aliases: + if not alias: + continue + + alias_stripped = str(alias).strip() + if not alias_stripped: + continue + + alias_lower = alias_stripped.lower() + + # 跳过与主名称相同的别名（不区分大小写） + if alias_lower == entity_name_lower: + continue + + # 如果这个别名（小写形式）还没见过，保存它 + if alias_lower not in seen_normalized: + seen_normalized[alias_lower] = alias_stripped + + # 返回排序后的唯一别名列表 + return sorted(seen_normalized.values()) + + + +# 错误处理相关常量 +MAX_ALIASES = 50 # 别名列表的最大数量限制 + + +def merge_aliases_with_limit( + entity_name: str, + aliases1: List[str], + aliases2: List[str], + max_aliases: int = MAX_ALIASES +) -> List[str]: + """合并别名列表并限制数量。 + + 当合并后的别名数量超过限制时，保留最相关的别名（基于长度，通常更短的别名更常用）。 + + Args: + entity_name: 实体的主名称 + aliases1: 第一个别名列表 + aliases2: 第二个别名列表 + max_aliases: 最大别名数量限制（默认50） + + Returns: + 合并后的别名列表，不超过max_aliases个 + """ + # 合并所有别名 + all_aliases = list(set(aliases1 + aliases2)) + + # 移除与主名称相同的别名 + all_aliases = [a for a in all_aliases if a != entity_name] + + # 如果超过限制，保留最短的别名（通常更常用） + if len(all_aliases) > max_aliases: + logger.warning( + f"Aliases exceed limit ({len(all_aliases)} > {max_aliases}) for entity '{entity_name}', " + f"truncating to {max_aliases} shortest aliases" + ) + # 按长度排序，然后按字母顺序排序（确保稳定排序），保留最短的 + all_aliases = sorted(all_aliases, key=lambda x: (len(x), x))[:max_aliases] + + # 最后按字母顺序排序返回 + return sorted(all_aliases) + + +def detect_alias_cycles(entities: List[Any]) -> Dict[str, Set[str]]: + """检测实体别名中的循环引用。 + + 构建别名图并检测循环：如果实体A的别名指向实体B，实体B的别名又指向实体A。 + + Args: + entities: 实体列表，每个实体应有id、name和aliases属性 + + Returns: + Dict[str, Set[str]]: 循环组的映射，key为组ID，value为该组中的实体ID集合 + """ + # 构建名称到实体ID的映射（只映射主名称，不包括别名） + name_to_entity: Dict[str, str] = {} + entity_by_id: Dict[str, Any] = {} + + for entity in entities: + entity_id = getattr(entity, 'id', None) + entity_name = getattr(entity, 'name', None) + + if not entity_id or not entity_name: + continue + + entity_by_id[entity_id] = entity + name_to_entity[entity_name.lower().strip()] = entity_id + + # 构建实体间的连接图：如果实体A的别名匹配实体B的名称，则A指向B + connections: Dict[str, Set[str]] = {} + for entity in entities: + entity_id = getattr(entity, 'id', None) + entity_aliases = getattr(entity, 'aliases', []) or [] + + if not entity_id: + continue + + connections[entity_id] = set() + + # 检查别名是否匹配其他实体的名称 + for alias in entity_aliases: + if not alias: + continue + + normalized_alias = alias.lower().strip() + if normalized_alias in name_to_entity: + target_id = name_to_entity[normalized_alias] + if target_id != entity_id: + connections[entity_id].add(target_id) + + # 使用DFS检测循环 + visited: Set[str] = set() + rec_stack: Set[str] = set() + cycles: Dict[str, Set[str]] = {} + cycle_id = 0 + + def dfs(node: str, current_path: List[str]) -> None: + """深度优先搜索检测循环""" + nonlocal cycle_id + + visited.add(node) + rec_stack.add(node) + current_path.append(node) + + for neighbor in connections.get(node, set()): + if neighbor not in visited: + dfs(neighbor, current_path) + elif neighbor in rec_stack: + # 发现循环 + cycle_start_idx = current_path.index(neighbor) + cycle_nodes = {*current_path[cycle_start_idx:], neighbor} + + # 记录循环 + cycle_key = f"cycle_{cycle_id}" + cycles[cycle_key] = cycle_nodes + cycle_id += 1 + + logger.warning( + f"Detected alias cycle: {' -> '.join(current_path[cycle_start_idx:])} -> {neighbor}" + ) + + current_path.pop() + rec_stack.remove(node) + + # 对所有节点执行DFS + for entity_id in connections: + if entity_id not in visited: + dfs(entity_id, []) + + return cycles + + +def resolve_alias_cycles(entities: List[Any], cycles: Dict[str, Set[str]]) -> List[str]: + """解决别名循环引用。 + + 对于检测到的循环，选择最强连接的实体作为规范实体， + 将循环中的其他实体合并到规范实体。 + + Args: + entities: 实体列表 + cycles: 循环组的映射（由detect_alias_cycles返回） + + Returns: + List[str]: 需要合并的实体ID列表（losing entity IDs） + """ + entity_by_id: Dict[str, Any] = { + getattr(e, 'id', None): e for e in entities if getattr(e, 'id', None) + } + + merge_suggestions: List[str] = [] + + for cycle_key, cycle_entity_ids in cycles.items(): + if len(cycle_entity_ids) < 2: + continue + + # 选择规范实体：优先选择连接强度最高的 + def _strength_rank(entity_id: str) -> int: + entity = entity_by_id.get(entity_id) + if not entity: + return 0 + strength = (getattr(entity, 'connect_strength', '') or '').lower() + return {'strong': 3, 'both': 2, 'weak': 1}.get(strength, 0) + + # 按连接强度排序 + sorted_entities = sorted( + cycle_entity_ids, + key=lambda eid: ( + _strength_rank(eid), + len(getattr(entity_by_id.get(eid), 'description', '') or ''), + len(getattr(entity_by_id.get(eid), 'fact_summary', '') or '') + ), + reverse=True + ) + + canonical_id = sorted_entities[0] + losing_ids = sorted_entities[1:] + + logger.info( + f"Resolving cycle {cycle_key}: canonical={canonical_id}, " + f"merging={losing_ids}" + ) + + merge_suggestions.extend(losing_ids) + + return merge_suggestions diff --git a/api/app/core/memory/utils/config/config_utils.py b/api/app/core/memory/utils/config/config_utils.py index 0f1934f0..6acd73d3 100644 --- a/api/app/core/memory/utils/config/config_utils.py +++ b/api/app/core/memory/utils/config/config_utils.py @@ -46,7 +46,7 @@ def get_model_config(model_id: str, db: Session | None = None) -> dict: with open("logs/model_config.log", "a", encoding="utf-8") as f: f.write(f"模型ID: {model_id}\n") f.write(f"模型配置信息:\n{model_config}\n") - f.write(f"=============================\n\n") + f.write("=============================\n\n") return model_config def get_embedder_config(embedding_id: str, db: Session | None = None) -> dict: @@ -75,7 +75,7 @@ def get_embedder_config(embedding_id: str, db: Session | None = None) -> dict: with open("logs/embedder_config.log", "a", encoding="utf-8") as f: f.write(f"嵌入模型ID: {embedding_id}\n") f.write(f"嵌入模型配置信息:\n{model_config}\n") - f.write(f"=============================\n\n") + f.write("=============================\n\n") return model_config def get_neo4j_config() -> dict: diff --git a/api/app/core/memory/utils/config/definitions.py b/api/app/core/memory/utils/config/definitions.py index 316245c2..03d6b28a 100644 --- a/api/app/core/memory/utils/config/definitions.py +++ b/api/app/core/memory/utils/config/definitions.py @@ -273,7 +273,7 @@ def reload_configuration_from_database(config_id: int | str, force_reload: bool # 重新暴露常量 _expose_runtime_constants(updated_cfg) - logger.info(f"[definitions] 配置重新加载成功，已暴露常量") + logger.info("[definitions] 配置重新加载成功，已暴露常量") logger.debug(f"[definitions] 配置详情: LLM_ID={updated_cfg.get('selections', {}).get('llm_id')}, " f"EMBEDDING_ID={updated_cfg.get('selections', {}).get('embedding_id')}") diff --git a/api/app/core/memory/utils/config/litellm_config.py b/api/app/core/memory/utils/config/litellm_config.py index f5a9667f..dbf991a8 100644 --- a/api/app/core/memory/utils/config/litellm_config.py +++ b/api/app/core/memory/utils/config/litellm_config.py @@ -331,7 +331,7 @@ class LiteLLMConfig: 'modules': {} } - for mod in self.module_stats.keys(): + for mod in self.module_stats: result['modules'][mod] = { 'current_qps': self.module_stats[mod]['current_qps'], 'max_qps': self.module_stats[mod]['max_qps'], @@ -394,7 +394,7 @@ class LiteLLMConfig: print(f"📊 {stats['message']}") return - print(f"\n📊 USAGE SUMMARY") + print("\n📊 USAGE SUMMARY") print(f"{'='*50}") print(f"⏱️ Duration: {stats['session_duration_minutes']:.1f} min") print(f"📈 Requests: {stats['total_requests']}") @@ -404,7 +404,7 @@ class LiteLLMConfig: # Module statistics if stats.get('module_stats'): - print(f"\n📦 MODULES:") + print("\n📦 MODULES:") for module, mod_stats in stats['module_stats'].items(): print(f" {module}: {mod_stats['requests']} req, Max QPS: {mod_stats['max_qps']}, Current: {mod_stats['current_qps']}") @@ -479,7 +479,7 @@ def print_instant_qps(module: str = None): """Print instant QPS information""" qps_data = get_instant_qps(module) - print(f"\n⚡ INSTANT QPS MONITOR") + print("\n⚡ INSTANT QPS MONITOR") print(f"{'='*60}") if module: @@ -490,14 +490,14 @@ def print_instant_qps(module: str = None): else: # Global stats global_data = qps_data.get('global', {}) - print(f"🌍 GLOBAL:") + print("🌍 GLOBAL:") print(f" Current QPS: {global_data.get('current_qps', 0)}") print(f" Max QPS: {global_data.get('max_qps', 0)}") # Module stats modules = qps_data.get('modules', {}) if modules: - print(f"\n📦 MODULES:") + print("\n📦 MODULES:") for mod, data in modules.items(): print(f" {mod}:") print(f" Current: {data['current_qps']} QPS") diff --git a/api/app/core/memory/utils/llm/llm_utils.py b/api/app/core/memory/utils/llm/llm_utils.py index dc80d0a5..5f8618c2 100644 --- a/api/app/core/memory/utils/llm/llm_utils.py +++ b/api/app/core/memory/utils/llm/llm_utils.py @@ -1,7 +1,7 @@ import os from pydantic import BaseModel -from app.core.memory.src.llm_tools.openai_client import OpenAIClient +from app.core.memory.llm_tools.openai_client import OpenAIClient from app.core.memory.utils.config.config_utils import get_model_config from app.core.memory.utils.config import definitions as config_defs from app.core.models.base import RedBearModelConfig diff --git a/api/app/core/memory/utils/prompt/prompts/entity_dedup.jinja2 b/api/app/core/memory/utils/prompt/prompts/entity_dedup.jinja2 index b83e7b92..be53c9d4 100644 --- a/api/app/core/memory/utils/prompt/prompts/entity_dedup.jinja2 +++ b/api/app/core/memory/utils/prompt/prompts/entity_dedup.jinja2 @@ -35,26 +35,78 @@ ===判定指引=== {% if disambiguation_mode %} -- 这是“同名但类型不同”的消歧场景。请判断两者是否指向同一真实世界实体。 +- 这是"同名但类型不同"的消歧场景。请判断两者是否指向同一真实世界实体。 - 综合名称文本/向量相似度、别名、描述、摘要与上下文关系（同源与关系陈述）进行判断。 +- **别名处理（高优先级）**: + * 如果两个实体的别名列表中有交集，这是强烈的同一性信号 + * 如果一个实体的名称出现在另一个实体的别名中，应视为高置信度匹配 + * 如果一个实体的别名与另一个实体的名称完全匹配，应视为高置信度匹配 + * 别名匹配的权重应高于单纯的名称文本相似度 - 若无法充分确定，应保守处理：不合并，并建议阻断该对在其他模糊/启发式合并中出现（block_pair=true）。 -- 若需要合并（should_merge=true），请选择“规范实体”(canonical_idx)并在可能的情况下给出建议统一类型（suggested_type），建议类型需与上下文一致。 +- 若需要合并（should_merge=true），请选择"规范实体"(canonical_idx)并**必须**给出建议统一类型（suggested_type）。 +- **类型统一原则（重要）**： + * 优先选择更具体、更准确的类型（如 HistoricalPeriod 优于 Organization，MilitaryCapability 优于 Concept） + * 如果两个类型都很具体但不同，选择与实体核心语义最匹配的类型 + * 通用类型（Concept、Phenomenon、Condition、State、Attribute、Event）优先级低于领域特定类型 + * 建议类型必须与上下文和实体描述一致 - 规范实体优先级：连接强度（strong/both）更高者；其余相同则保留描述/摘要更丰富者；再相同时保留实体A（canonical_idx=0）。 +- **注意**：别名（aliases）已在三元组提取阶段获取，合并时会自动整合，无需在此阶段提取。 {% else %} - 若实体类型相同或任一为UNKNOWN/空，可放行作为候选；若类型明显冲突（如人 vs 物品），除非别名与描述高度一致，否则判定不同实体。 +- **别名匹配优先（最高优先级）**: + * 如果实体A的名称与实体B的某个别名完全匹配，应视为高置信度匹配 + * 如果实体B的名称与实体A的某个别名完全匹配，应视为高置信度匹配 + * 如果实体A的任一别名与实体B的任一别名完全匹配，应视为高置信度匹配 + * 别名完全匹配时，即使名称文本相似度较低，也应考虑合并 + * 别名匹配的置信度应高于单纯的名称相似度匹配 - 综合名称文本/向量相似度、别名、描述、摘要以及上下文关系判断是否为同一实体。 - 当上下文同源或存在明确的关系陈述支持同一性（例如同一对象反复被提及或别名对应），可以适度降低判定阈值。 - 保守决策：当无法充分确定，不要合并（same_entity=false）。 -- 若需要合并，选择“保留的规范实体”(canonical_idx)为更合适的一个： +- 若需要合并，选择"保留的规范实体"(canonical_idx)为更合适的一个： - 优先保留连接强度更强(strong/both)者；其余相同则保留描述/摘要更丰富者；再相同时保留实体A（canonical_idx=0）。 +- **注意**：别名（aliases）已在三元组提取阶段获取，合并时会自动整合，无需在此阶段提取。 {% endif %} **Output format** +{% if disambiguation_mode %} +返回JSON格式，必须包含以下字段： +{ + "should_merge": boolean, + "canonical_idx": 0 or 1, + "confidence": float (0.0-1.0), + "block_pair": boolean, + "suggested_type": "string or null", + "reason": "string" +} + +**字段说明**: +- should_merge: 是否应该合并这两个实体（true/false） +- canonical_idx: 规范实体的索引，0表示实体A，1表示实体B +- confidence: 决策的置信度，范围0.0-1.0 +- block_pair: 是否阻断该对在其他模糊/启发式合并中出现（true/false） +- suggested_type: 建议的统一类型（字符串或null） +- reason: 决策理由的简短说明 +{% else %} +返回JSON格式，必须包含以下字段： +{ + "same_entity": boolean, + "canonical_idx": 0 or 1, + "confidence": float (0.0-1.0), + "reason": "string" +} + +**字段说明**: +- same_entity: 两个实体是否指向同一真实世界实体（true/false） +- canonical_idx: 规范实体的索引，0表示实体A，1表示实体B +- confidence: 决策的置信度，范围0.0-1.0 +- reason: 决策理由的简短说明 +{% endif %} + **CRITICAL JSON FORMATTING REQUIREMENTS:** 1. Use only standard ASCII double quotes (") for JSON structure - never use Chinese quotation marks ("") or other Unicode quotes -2. If the extracted statement text contains quotation marks, escape them properly using backslashes (\") -3. Ensure all JSON strings are properly closed and comma-separated -4. Do not include line breaks within JSON string values +2. Ensure all JSON strings are properly closed and comma-separated +3. Do not include line breaks within JSON string values +4. Test your JSON output mentally to ensure it can be parsed correctly The output language should always be the same as the input language. -{{ json_schema }} \ No newline at end of file +{{ json_schema }} diff --git a/api/app/core/memory/utils/prompt/prompts/extract_triplet.jinja2 b/api/app/core/memory/utils/prompt/prompts/extract_triplet.jinja2 index 0bfc5eb7..337b5d4f 100644 --- a/api/app/core/memory/utils/prompt/prompts/extract_triplet.jinja2 +++ b/api/app/core/memory/utils/prompt/prompts/extract_triplet.jinja2 @@ -12,7 +12,18 @@ Extract entities and knowledge triplets from the given statement. ===Guidelines=== **Entity Extraction:** -- Extract entities with their types and context-independent descriptions +- Extract entities with their types, context-independent descriptions, and aliases +- **Aliases Extraction (Important):** + * **CRITICAL: Extract aliases ONLY in the SAME LANGUAGE as the input text** + * **DO NOT translate or add aliases in different languages** + * Include common alternative names in the same language (e.g., "北京" → aliases: ["北平", "京城"]) + * Include abbreviations and full names in the same language (e.g., "联合国" → aliases: ["联合国组织"]) + * Include nicknames and common variations in the same language (e.g., "纽约" → aliases: ["纽约市", "大苹果"]) + * If no aliases exist in the same language, use empty array: [] + * **Examples:** + - Chinese input "北京" → aliases: ["北平", "京城"] (NOT ["Beijing", "Peking"]) + - English input "Beijing" → aliases: ["Peking"] (NOT ["北京", "北平"]) + - Chinese input "苹果公司" → aliases: ["苹果"] (NOT ["Apple Inc.", "Apple"]) - Exclude lengthy quotes, calendar dates, temporal ranges, and temporal expressions - For numeric values: extract as separate entities (instance_of: 'Numeric', name: units, numeric_value: value) Example: £30 → name: 'GBP', numeric_value: 30, instance_of: 'Numeric' @@ -72,19 +83,22 @@ Output: "entity_idx": 0, "name": "I", "type": "Person", - "description": "The user" + "description": "The user", + "aliases": [] }, { "entity_idx": 1, "name": "Paris", "type": "Location", - "description": "Capital city of France" + "description": "Capital city of France", + "aliases": [] }, { "entity_idx": 2, "name": "Louvre", "type": "Location", - "description": "World-famous museum located in Paris" + "description": "World-famous museum located in Paris", + "aliases": ["Louvre Museum"] } ] } @@ -115,19 +129,22 @@ Output: "entity_idx": 0, "name": "John Smith", "type": "Person", - "description": "Individual person name" + "description": "Individual person name", + "aliases": [] }, { "entity_idx": 1, "name": "Google", "type": "Organization", - "description": "American technology company" + "description": "American technology company", + "aliases": ["Google LLC", "Alphabet Inc."] }, { "entity_idx": 2, "name": "AI product development", "type": "WorkRole", - "description": "Artificial intelligence product development work" + "description": "Artificial intelligence product development work", + "aliases": [] } ] } @@ -158,19 +175,22 @@ Output: "entity_idx": 0, "name": "我", "type": "Person", - "description": "用户本人" + "description": "用户本人", + "aliases": [] }, { "entity_idx": 1, "name": "巴黎", "type": "Location", - "description": "法国首都城市" + "description": "法国首都城市", + "aliases": [] }, { "entity_idx": 2, "name": "卢浮宫", "type": "Location", - "description": "位于巴黎的世界著名博物馆" + "description": "位于巴黎的世界著名博物馆", + "aliases": [] } ] } @@ -201,24 +221,27 @@ Output: "entity_idx": 0, "name": "张明", "type": "Person", - "description": "个人姓名" + "description": "个人姓名", + "aliases": [] }, { "entity_idx": 1, "name": "腾讯", "type": "Organization", - "description": "中国科技公司" + "description": "中国科技公司", + "aliases": ["腾讯控股", "腾讯公司"] }, { "entity_idx": 2, "name": "AI产品开发", "type": "WorkRole", - "description": "人工智能产品研发工作" + "description": "人工智能产品研发工作", + "aliases": [] } ] } -**Example 5 (Entity Only):** "Tripod" or "三脚架" +**Example 5 (Entity Only - English):** "Tripod" Output: { "triplets": [], @@ -227,7 +250,23 @@ Output: "entity_idx": 0, "name": "Tripod", "type": "Equipment", - "description": "Photography equipment accessory" + "description": "Photography equipment accessory", + "aliases": ["Camera Tripod"] + } + ] +} + +**Example 6 (Entity Only - Chinese):** "三脚架" +Output: +{ + "triplets": [], + "entities": [ + { + "entity_idx": 0, + "name": "三脚架", + "type": "Equipment", + "description": "摄影器材配件", + "aliases": ["相机三脚架"] } ] } diff --git a/api/app/core/memory/utils/self_reflexion_utils/self_reflexion.py b/api/app/core/memory/utils/self_reflexion_utils/self_reflexion.py index 5687223d..2c3943e2 100644 --- a/api/app/core/memory/utils/self_reflexion_utils/self_reflexion.py +++ b/api/app/core/memory/utils/self_reflexion_utils/self_reflexion.py @@ -191,6 +191,9 @@ async def update_memory(solved_data: List[Any], host_id: uuid.UUID) -> str: logging.info(f"成功删除 {success_count} 条检索数据") except Exception as e: logging.error(f"删除数据库中的检索数据失败: {e}") + finally: + db.close() + async def _append_json(label: str, data: Any) -> None: diff --git a/api/app/core/models/base.py b/api/app/core/models/base.py index e33fd102..cc8b7b7e 100644 --- a/api/app/core/models/base.py +++ b/api/app/core/models/base.py @@ -1,5 +1,8 @@ from __future__ import annotations -import asyncio, httpx, time, os +import asyncio +import httpx +import time +import os from abc import ABC, abstractmethod from typing import Any, Dict, List, Optional, TypeVar, Callable from langchain_community.document_compressors import JinaRerank diff --git a/api/app/core/rag/app/naive.py b/api/app/core/rag/app/naive.py index 95aad2d2..5430e38f 100644 --- a/api/app/core/rag/app/naive.py +++ b/api/app/core/rag/app/naive.py @@ -15,13 +15,15 @@ import copy from app.core.rag.llm.cv_model import AzureGptV4, QWenCV from app.core.rag.common.file_utils import get_project_base_directory from app.core.rag.utils.file_utils import extract_embed_file, extract_links_from_pdf, extract_links_from_docx, extract_html +from app.core.rag.utils.libre_office import convert_to_pdf, async_convert_to_pdf from app.core.rag.deepdoc.parser import DocxParser, ExcelParser, HtmlParser, JsonParser, MarkdownElementExtractor, MarkdownParser, PdfParser, TxtParser from app.core.rag.deepdoc.parser.figure_parser import VisionFigureParser,vision_figure_parser_docx_wrapper,vision_figure_parser_pdf_wrapper from app.core.rag.deepdoc.parser.pdf_parser import PlainParser, VisionParser from app.core.rag.deepdoc.parser.mineru_parser import MinerUParser +from app.core.rag.app.textin_parser import TextLnParser from app.core.rag.nlp import concat_img, find_codec, naive_merge, naive_merge_with_images, naive_merge_docx, tokenize, rag_tokenizer, tokenize_chunks, tokenize_chunks_with_images, tokenize_table -def by_deepdoc(filename, binary=None, from_page=0, to_page=100000, lang="Chinese", callback=None, vision_model=None, pdf_cls = None ,**kwargs): +def by_deepdoc(filename, binary=None, from_page=0, to_page=100000, lang="Chinese", callback=None, vision_model=None, pdf_cls = None, **kwargs): callback = callback binary = binary pdf_parser = pdf_cls() if pdf_cls else Pdf() @@ -39,7 +41,7 @@ def by_deepdoc(filename, binary=None, from_page=0, to_page=100000, lang="Chinese return sections, tables, pdf_parser -def by_mineru(filename, binary=None, from_page=0, to_page=100000, lang="Chinese", callback=None, vision_model=None, pdf_cls = None ,**kwargs): +def by_mineru(filename, binary=None, from_page=0, to_page=100000, lang="Chinese", callback=None, vision_model=None, pdf_cls = None, **kwargs): mineru_executable = os.environ.get("MINERU_EXECUTABLE", "mineru") mineru_api = os.environ.get("MINERU_APISERVER", "http://host.docker.internal:9987") pdf_parser = MinerUParser(mineru_path=mineru_executable, mineru_api=mineru_api) @@ -59,23 +61,19 @@ def by_mineru(filename, binary=None, from_page=0, to_page=100000, lang="Chinese" return sections, tables, pdf_parser -def by_textln(filename, binary=None, from_page=0, to_page=100000, lang="Chinese", callback=None, vision_model=None, pdf_cls = None ,**kwargs): - textln_app_id = os.environ.get("TEXTLN_APP_ID", "") - textln_secret_code = os.environ.get("TEXTLN_SECRET_CODE", "") +def by_textln(filename, binary=None, from_page=0, to_page=100000, lang="Chinese", callback=None, vision_model=None, pdf_cls = None, **kwargs): textln_api = os.environ.get("TEXTLN_APISERVER", "https://api.textin.com/ai/service/v1/pdf_to_markdown") - pdf_parser = MinerUParser(mineru_path=textln_app_id, mineru_api=textln_api) - - if not pdf_parser.check_installation(): - callback(-1, "MinerU not found.") - return None, None, pdf_parser + app_id = os.environ.get("TEXTLN_APP_ID", "fa3f24380683ad53e6c620c0f0878a09") + secret_code = os.environ.get("TEXTLN_SECRET_CODE", "6130caac9aabc6eb26433758d7898f4a") + pdf_parser = TextLnParser(textln_api=textln_api, app_id=app_id, secret_code=secret_code) sections, tables = pdf_parser.parse_pdf( filepath=filename, binary=binary, callback=callback, - output_dir=os.environ.get("MINERU_OUTPUT_DIR", ""), - backend=os.environ.get("MINERU_BACKEND", "pipeline"), - delete_output=bool(int(os.environ.get("MINERU_DELETE_OUTPUT", 1))), + vision_model=vision_model, + lang=lang, + **kwargs ) return sections, tables, pdf_parser @@ -605,7 +603,7 @@ def chunk(filename, binary=None, from_page=0, to_page=100000, parser = PARSERS.get(name, by_plaintext) callback(0.1, "Start to parse.") - sections, tables, pdf_parser = parser( + sections, tables, pdf_parser= parser( filename=filename, binary=binary, from_page=from_page, @@ -626,24 +624,30 @@ def chunk(filename, binary=None, from_page=0, to_page=100000, res = tokenize_table(tables, doc, is_english) callback(0.8, "Finish parsing.") - elif re.search(r"\.pptx?$", filename, re.IGNORECASE): - if not binary: - with open(filename, "rb") as f: - binary = f.read() - from app.core.rag.app.presentation import Ppt - ppt_parser = Ppt() - for pn, (txt, img) in enumerate(ppt_parser( - filename if not binary else binary, from_page, to_page, callback)): - d = copy.deepcopy(doc) - pn += from_page - d["image"] = img - d["doc_type_kwd"] = "image" - d["page_num_int"] = [pn + 1] - d["top_int"] = [0] - d["position_int"] = [(pn + 1, 0, img.size[0], 0, img.size[1])] - tokenize(d, txt, is_english) - res.append(d) - return res + elif re.search(r"\.(pptx|ppt?)$", filename, re.IGNORECASE): + # 方法1.Aspose.Slides是商业级库，其核心功能（如幻灯片创建、动画处理、格式转换等）需通过付费许可证使用。尽管它为符合条件的开源项目提供免费许可证（需申请），但商业闭源项目必须购买授权 + # if not binary: + # with open(filename, "rb") as f: + # binary = f.read() + # from app.core.rag.app.presentation import Ppt + # ppt_parser = Ppt() + # for pn, (txt, img) in enumerate(ppt_parser( + # filename if not binary else binary, from_page, to_page, callback)): + # d = copy.deepcopy(doc) + # pn += from_page + # d["image"] = img + # d["doc_type_kwd"] = "image" + # d["page_num_int"] = [pn + 1] + # d["top_int"] = [0] + # d["position_int"] = [(pn + 1, 0, img.size[0], 0, img.size[1])] + # tokenize(d, txt, is_english) + # res.append(d) + # return res + # 方法2.提交任务-文件转换为pdf + future = async_convert_to_pdf(filename) + dest_pdf_path = future.result() + # 解析pdf + return chunk(dest_pdf_path, binary=None, lang=lang, callback=callback, vision_model=vision_model, **kwargs) elif re.search(r"\.(da|wave|wav|mp3|aac|flac|ogg|aiff|au|midi|wma|realaudio|vqf|oggvorbis|ape?)$", filename, re.IGNORECASE): if not binary: @@ -818,14 +822,14 @@ if __name__ == "__main__": # file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/1.txt" # file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/2.md" # file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/3.md" # 带图url - file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/义务教育教科书·中国历史七年级上册 (2)_Compressed.md" + # file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/义务教育教科书·中国历史七年级上册 (2)_Compressed.md" # file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/4.doc" # file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/5.json" # file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/6.html" # file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/7.xlsx" # file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/8.pdf" # file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/9.pptx" - # file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/10.png" + file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/10.png" # file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/11.mp4" # file_path = "/Users/sbtjfdn/Downloads/记忆科学/files/12.mp3" res = chunk(filename=file_path, @@ -834,7 +838,8 @@ if __name__ == "__main__": callback=progress_callback, vision_model=vision_model, parser_config={ - "layout_recognize": "DeepDOC", + # "layout_recognize": "DeepDOC", + "layout_recognize": "TextLn", "chunk_token_num": 128, "delimiter": "\n", "analyze_hyperlink": True, diff --git a/api/app/core/rag/app/presentation.py b/api/app/core/rag/app/presentation.py index d7b23d66..d62e0096 100644 --- a/api/app/core/rag/app/presentation.py +++ b/api/app/core/rag/app/presentation.py @@ -5,7 +5,8 @@ from PIL import Image from app.core.rag.nlp import tokenize, is_english from app.core.rag.nlp import rag_tokenizer -from app.core.rag.deepdoc.parser import PdfParser, PptParser, PlainParser +from app.core.rag.deepdoc.parser import PdfParser, PlainParser +from app.core.rag.deepdoc.parser.ppt_parser import RAGPptParser as PptParser from PyPDF2 import PdfReader as pdf2_read from app.core.rag.app.naive import by_plaintext, PARSERS diff --git a/api/app/core/rag/app/textin_parser.py b/api/app/core/rag/app/textin_parser.py new file mode 100644 index 00000000..5d2028c4 --- /dev/null +++ b/api/app/core/rag/app/textin_parser.py @@ -0,0 +1,217 @@ +import json +import os +import re +import sys +import threading +from io import BytesIO +from os import PathLike +from typing import Any, Callable, Optional +import numpy as np +import pdfplumber +from functools import reduce +import requests +import logging +from PIL import Image + +from app.core.rag.nlp import concat_img +from app.core.rag.deepdoc.parser.figure_parser import VisionFigureParser + +LOCK_KEY_pdfplumber = "global_shared_lock_pdfplumber" +if LOCK_KEY_pdfplumber not in sys.modules: + sys.modules[LOCK_KEY_pdfplumber] = threading.Lock() + + +class TextLnParser: + def __init__(self, textln_api: str, app_id: str, secret_code: str): + self.textln_api = textln_api + self.app_id = app_id + self.secret_code = secret_code + + def recognize(self, file_content: bytes, options: dict) -> str: + params = {} + for key, value in options.items(): + params[key] = str(value) + + headers = { + "x-ti-app-id": self.app_id, + "x-ti-secret-code": self.secret_code, + "Content-Type": "application/octet-stream" + } + + response = requests.post( + url=self.textln_api, + params=params, + headers=headers, + data=file_content + ) + + response.raise_for_status() + return response.text + + def __images__(self, fnm, zoomin: int = 1, page_from=0, page_to=600, callback=None): + self.page_from = page_from + self.page_to = page_to + try: + with pdfplumber.open(fnm) if isinstance(fnm, (str, PathLike)) else pdfplumber.open(BytesIO(fnm)) as pdf: + self.pdf = pdf + self.page_images = [p.to_image(resolution=72 * zoomin, antialias=True).original for _, p in enumerate(self.pdf.pages[page_from:page_to])] + except Exception as e: + self.page_images = None + logging.exception(e) + + + def parse_pdf( + self, + filepath: str | PathLike[str], + binary: BytesIO | bytes, + callback: Optional[Callable] = None, + vision_model=None, + lang: Optional[str] = None, + **kwargs + ): + try: + callback(0.15, "USE [Textln] to recognize the file") + self.__images__(filepath, zoomin=1) + base_name, ext = os.path.splitext(filepath) + if not os.path.exists(f"{base_name}_result.md"): + with open(filepath, "rb") as f: + file_content = f.read() + options = dict( + dpi=144, + get_image="objects", + markdown_details=1, + page_count=1000, # 当上传的是pdf时，表示要进行解析的pdf页数。总页数不得超过1000页，默认为1000页 + parse_mode="auto", + table_flavor="md" + ) + response = self.recognize(file_content, options) + # 保存完整的JSON响应到result.json文件 + with open(f"{base_name}_result.json", "w", encoding="utf-8") as f: + f.write(response) + # 解析JSON响应以提取markdown内容 + json_response = json.loads(response) + if "result" in json_response and "markdown" in json_response["result"]: + markdown_content = json_response["result"]["markdown"] + with open(f"{base_name}_result.md", "w", encoding="utf-8") as f: + f.write(markdown_content) + else: + callback(prog=-1, msg=json_response["message"]) + return None, None, None + callback(0.75, f"[Textln] respond md: {base_name}_result.md") + + from app.core.rag.app.naive import Markdown + parser_config = kwargs.get( + "parser_config", { + "layout_recognize": "TextLn", "chunk_token_num": 512, "delimiter": "\n!?。；！？", + "analyze_hyperlink": True}) + markdown_parser = Markdown(int(parser_config.get("chunk_token_num", 128))) + sections, tables = markdown_parser(f"{base_name}_result.md", binary, separate_tables=False, + delimiter=parser_config.get("delimiter", "\n!?;。；！？")) + return sections, tables + # # Process images for each section + # section_images = [] + # if vision_model: + # for idx, (section_text, _) in enumerate(sections): + # images = markdown_parser.get_pictures(section_text) if section_text else None + # + # if images: + # # If multiple images found, combine them using concat_img + # combined_image = reduce(concat_img, images) if len(images) > 1 else images[0] + # section_images.append(combined_image) + # markdown_vision_parser = VisionFigureParser(vision_model=vision_model, figures_data=[ + # ((combined_image, ["markdown image"]), [(0, 0, 0, 0, 0)])], **kwargs) + # boosted_figures = markdown_vision_parser(callback=callback) + # sections[idx] = (section_text + "\n\n" + "\n\n".join([fig[0][1][0] for fig in boosted_figures]), + # sections[idx][1]) + # else: + # section_images.append(None) + # + # else: + # logging.warning("No visual model detected. Skipping figure parsing enhancement.") + # return sections, tables, section_images + except Exception as e: + logging.warning(f"Error: {e}") + callback(prog=-1, msg=str(e)) + return None, None + + @staticmethod + def extract_positions(txt: str): + poss = [] + for tag in re.findall(r"@@[0-9-]+\t[0-9.\t]+##", txt): + pn, left, right, top, bottom = tag.strip("#").strip("@").split("\t") + left, right, top, bottom = float(left), float(right), float(top), float(bottom) + poss.append(([int(p) - 1 for p in pn.split("-")], left, right, top, bottom)) + return poss + + def crop(self, text, ZM=1, need_position=False): + imgs = [] + poss = self.extract_positions(text) + if not poss: + if need_position: + return None, None + return + + max_width = max(np.max([right - left for (_, left, right, _, _) in poss]), 6) + GAP = 6 + pos = poss[0] + poss.insert(0, ([pos[0][0]], pos[1], pos[2], max(0, pos[3] - 120), max(pos[3] - GAP, 0))) + pos = poss[-1] + poss.append(([pos[0][-1]], pos[1], pos[2], min(self.page_images[pos[0][-1]].size[1], pos[4] + GAP), min(self.page_images[pos[0][-1]].size[1], pos[4] + 120))) + + positions = [] + for ii, (pns, left, right, top, bottom) in enumerate(poss): + right = left + max_width + + if bottom <= top: + bottom = top + 2 + + for pn in pns[1:]: + bottom += self.page_images[pn - 1].size[1] + + img0 = self.page_images[pns[0]] + x0, y0, x1, y1 = int(left), int(top), int(right), int(min(bottom, img0.size[1])) + crop0 = img0.crop((x0, y0, x1, y1)) + imgs.append(crop0) + if 0 < ii < len(poss) - 1: + positions.append((pns[0] + self.page_from, x0, x1, y0, y1)) + + bottom -= img0.size[1] + for pn in pns[1:]: + page = self.page_images[pn] + x0, y0, x1, y1 = int(left), 0, int(right), int(min(bottom, page.size[1])) + cimgp = page.crop((x0, y0, x1, y1)) + imgs.append(cimgp) + if 0 < ii < len(poss) - 1: + positions.append((pn + self.page_from, x0, x1, y0, y1)) + bottom -= page.size[1] + + if not imgs: + if need_position: + return None, None + return + + height = 0 + for img in imgs: + height += img.size[1] + GAP + height = int(height) + width = int(np.max([i.size[0] for i in imgs])) + pic = Image.new("RGB", (width, height), (245, 245, 245)) + height = 0 + for ii, img in enumerate(imgs): + if ii == 0 or ii + 1 == len(imgs): + img = img.convert("RGBA") + overlay = Image.new("RGBA", img.size, (0, 0, 0, 0)) + overlay.putalpha(128) + img = Image.alpha_composite(img, overlay).convert("RGB") + pic.paste(img, (0, int(height))) + height += img.size[1] + GAP + + if need_position: + return pic, positions + return pic + + @staticmethod + def remove_tag(txt): + return re.sub(r"@@[\t0-9.-]+?##", "", txt) + + diff --git a/api/app/core/rag/deepdoc/parser/__init__.py b/api/app/core/rag/deepdoc/parser/__init__.py index 4cc4bada..8f99e519 100644 --- a/api/app/core/rag/deepdoc/parser/__init__.py +++ b/api/app/core/rag/deepdoc/parser/__init__.py @@ -6,7 +6,7 @@ from .markdown_parser import MarkdownElementExtractor from .markdown_parser import RAGMarkdownParser as MarkdownParser from .pdf_parser import PlainParser from .pdf_parser import RAGPdfParser as PdfParser -from .ppt_parser import RAGPptParser as PptParser +# from .ppt_parser import RAGPptParser as PptParser from .txt_parser import RAGTxtParser as TxtParser __all__ = [ @@ -14,7 +14,7 @@ __all__ = [ "PlainParser", "DocxParser", "ExcelParser", - "PptParser", + # "PptParser", "HtmlParser", "JsonParser", "MarkdownParser", diff --git a/api/app/core/rag/prompts/generator.py b/api/app/core/rag/prompts/generator.py index 67891c1a..fe928d8d 100644 --- a/api/app/core/rag/prompts/generator.py +++ b/api/app/core/rag/prompts/generator.py @@ -134,7 +134,7 @@ def question_proposal(chat_mdl, content, topn=3): rendered_prompt = template.render(content=content, topn=topn) msg = [{"role": "system", "content": rendered_prompt}, {"role": "user", "content": "Output: "}] - _, msg = message_fit_in(msg, chat_mdl.max_length) + _, msg = message_fit_in(msg, getattr(chat_mdl, 'max_length', 8096)) kwd = chat_mdl.chat(rendered_prompt, msg[1:], {"temperature": 0.2}) if isinstance(kwd, tuple): kwd = kwd[0] diff --git a/api/app/core/rag/utils/libre_office.py b/api/app/core/rag/utils/libre_office.py new file mode 100644 index 00000000..a07df5c9 --- /dev/null +++ b/api/app/core/rag/utils/libre_office.py @@ -0,0 +1,62 @@ +import subprocess +import os +from concurrent.futures import ThreadPoolExecutor +from fastapi import HTTPException, status + +# 根据CPU核心数自动设置（保守策略：核心数 * 2） +MAX_WORKERS = os.cpu_count() * 2 if os.cpu_count() else 4 +executor = ThreadPoolExecutor(max_workers=MAX_WORKERS) + +# 将DOCX/PPT/PPTX文件转换为PDF +def convert_to_pdf(src_path): + try: + print("开始使用LibreOffice将DOC/DOCX/PPT/PPTX转换为PDF...") + output_dir = os.path.dirname(src_path) + + # 使用linux上LibreOffice的完整路径调用soffice进行转换 + libreoffice_path = "/usr/bin/soffice" + if not os.path.exists(libreoffice_path): + # 使用macOS上LibreOffice的完整路径调用soffice进行转换 + libreoffice_path = "/Applications/LibreOffice.app/Contents/MacOS/soffice" + if not os.path.exists(libreoffice_path): + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail="LibreOffice未安装或路径不正确，请确认安装。" + ) + + # 使用subprocess.run的超时设置防止卡死 + subprocess.run([ + libreoffice_path, + '--headless', + '--convert-to', 'pdf', + '--outdir', output_dir, + src_path + ], check=True, timeout=120) # 设置超时时间 + + # 检查PDF是否生成成功 + dest_path = os.path.splitext(src_path)[0] + '.pdf' + if not os.path.exists(dest_path): + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"PDF文件未生成在 {dest_path}" + ) + + print(f"PDF已保存至 {dest_path}") + return dest_path + except subprocess.CalledProcessError as e: + print(f"转换过程中出错: {e}") + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"转换过程中出错: {e}" + ) + except FileNotFoundError as e: + print(f"文件错误: {e}") + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"文件错误: {e}" + ) + +def async_convert_to_pdf(src_path): + # 提交任务到线程池 + future = executor.submit(convert_to_pdf, src_path) + return future # 返回一个future对象，调用者可以使用它来获取结果或处理异常 \ No newline at end of file diff --git a/api/app/core/rag_utils/chunk_tags.py b/api/app/core/rag_utils/chunk_tags.py index 5d633be9..719f97e6 100644 --- a/api/app/core/rag_utils/chunk_tags.py +++ b/api/app/core/rag_utils/chunk_tags.py @@ -179,13 +179,13 @@ if __name__ == "__main__": print("开始提取chunk标签...") tags = asyncio.run(extract_chunk_tags(test_chunks)) - print(f"\n提取的标签：") + print("\n提取的标签：") for tag, freq in tags: print(f"- {tag} (频率: {freq})") print("\n" + "="*50) print("开始提取人物形象...") personas = asyncio.run(extract_chunk_persona(test_chunks)) - print(f"\n提取的人物形象：") + print("\n提取的人物形象：") for persona in personas: print(f"- {persona}") diff --git a/api/app/db.py b/api/app/db.py index 895e81c2..2513dc78 100644 --- a/api/app/db.py +++ b/api/app/db.py @@ -1,12 +1,24 @@ import os +from contextlib import contextmanager +from typing import Generator from sqlalchemy import create_engine -from sqlalchemy.orm import sessionmaker +from sqlalchemy.orm import Session, sessionmaker from sqlalchemy.ext.declarative import declarative_base from app.core.config import settings SQLALCHEMY_DATABASE_URL = f"postgresql://{settings.DB_USER}:{settings.DB_PASSWORD}@{settings.DB_HOST}:{settings.DB_PORT}/{settings.DB_NAME}" -engine = create_engine(SQLALCHEMY_DATABASE_URL) +engine = create_engine( + SQLALCHEMY_DATABASE_URL, + pool_size=settings.DB_POOL_SIZE, + max_overflow=settings.DB_MAX_OVERFLOW, + pool_pre_ping=settings.DB_POOL_PRE_PING, + pool_recycle=settings.DB_POOL_RECYCLE, + pool_timeout=settings.DB_POOL_TIMEOUT, + connect_args={ + "options": "-c timezone=Asia/Shanghai -c statement_timeout=60000" + }, +) SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) Base = declarative_base() @@ -17,4 +29,46 @@ def get_db(): try: yield db finally: + try: + if db.in_transaction(): + db.rollback() + finally: + db.close() + +@contextmanager +def get_db_context() -> Generator[Session, None, None]: + """ + 线程安全、池友好的 Session 上下文。 + 不会自动 commit/rollback，调用方自己决定事务边界。 + 用法： + with get_db_context() as db: + db.add(obj) + db.commit() # 或 db.rollback() + """ + db: Session = SessionLocal() + try: + yield db + finally: + # 如果还有未提交的事务，直接 rollback 防止 idle in transaction + if db.in_transaction(): + db.rollback() db.close() + +@contextmanager +def get_db_read() -> Generator[Session, None, None]: + """只读场景专用，出上下文自动 rollback，绝不留下 idle in transaction""" + with get_db_context() as db: + yield db + db.rollback() # 只读任务无需 commit + +def get_pool_status(): + """获取连接池状态（用于监控）""" + pool = engine.pool + return { + "pool_size": pool.size(), + "checked_in": pool.checkedin(), + "checked_out": pool.checkedout(), + "overflow": pool.overflow(), + "total": pool.size() + pool.overflow(), + "usage_percent": round(pool.checkedout() / (pool.size() + pool.overflow()) * 100, 2) if (pool.size() + pool.overflow()) > 0 else 0 + } \ No newline at end of file diff --git a/api/app/dependencies.py b/api/app/dependencies.py index c2c4d99a..9e0cd88c 100644 --- a/api/app/dependencies.py +++ b/api/app/dependencies.py @@ -1,9 +1,10 @@ +import uuid +from functools import wraps + from fastapi import Depends, HTTPException, status from fastapi.security import OAuth2PasswordBearer from sqlalchemy.orm import Session from jose import jwt, JWTError -import uuid -from functools import wraps from app.db import get_db, SessionLocal from app.schemas import token_schema @@ -25,9 +26,10 @@ security_logger = get_security_logger() oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") + async def get_current_user( - token: str = Depends(oauth2_scheme), - db: Session = Depends(get_db) + token: str = Depends(oauth2_scheme), + db: Session = Depends(get_db) ) -> User: """ 获取当前认证用户 @@ -37,81 +39,82 @@ async def get_current_user( detail="Could not validate credentials", headers={"WWW-Authenticate": "Bearer"}, ) - + try: auth_logger.debug("开始解析JWT token") payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM]) user_id: str = payload.get("sub") - + if user_id is None: auth_logger.warning("JWT token中缺少用户ID") raise credentials_exception - + token_data = token_schema.TokenData(userId=user_id) auth_logger.debug(f"JWT解析成功，用户ID: {user_id}") - + except JWTError as e: auth_logger.warning(f"JWT解析失败: {str(e)}") raise credentials_exception - + # 检查单点登录黑名单和用户token失效 try: auth_logger.debug("检查单点登录黑名单") token_id = get_token_id(token) session_service = SessionService() - + if await session_service.is_token_blacklisted(token_id): auth_logger.warning(f"Token已被列入黑名单: {token_id}") raise credentials_exception - + # 检查用户是否重置了密码（所有旧token失效） invalidation_time_str = await session_service.get_user_token_invalidation_time(user_id) if invalidation_time_str: from datetime import datetime, timezone invalidation_time = datetime.fromisoformat(invalidation_time_str) - token_issued_at = datetime.fromtimestamp(payload.get("iat", 0), tz=timezone.utc) if payload.get("iat") else None - + token_issued_at = datetime.fromtimestamp(payload.get("iat", 0), tz=timezone.utc) if payload.get( + "iat") else None + if token_issued_at and token_issued_at < invalidation_time: auth_logger.warning(f"Token在密码重置前签发，已失效: user_id={user_id}") raise credentials_exception - + auth_logger.debug("单点登录检查通过") - + except HTTPException: raise except Exception as e: auth_logger.error(f"检查token有效性时发生错误: {str(e)}") raise credentials_exception - + try: auth_logger.debug(f"查询用户信息: {token_data.userId}") user = user_repository.get_user_by_id(db, user_id=token_data.userId) - + if user is None: auth_logger.warning(f"用户不存在: {token_data.userId}") raise credentials_exception if not user.is_active: auth_logger.warning(f"用户已被停用: {user.username} (ID: {user.id})") raise credentials_exception - + auth_logger.info(f"用户认证成功: {user.username} (ID: {user.id})") return user - + except Exception as e: auth_logger.error(f"查询用户信息时发生错误: {str(e)}") raise credentials_exception async def get_current_tenant( - current_user: User = Depends(get_current_user), - db: Session = Depends(get_db) + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db) ) -> Tenants: """ 获取当前用户的租户 由于每个用户只属于一个租户，直接返回用户的租户 """ auth_logger.debug(f"获取用户 {current_user.username} 的租户信息") - + try: # 直接从用户模型获取租户 if current_user.tenant: @@ -123,7 +126,7 @@ async def get_current_tenant( status_code=status.HTTP_404_NOT_FOUND, detail="用户没有关联的租户" ) - + except HTTPException: raise except Exception as e: @@ -135,15 +138,15 @@ async def get_current_tenant( async def get_user_tenants( - current_user: User = Depends(get_current_user), - db: Session = Depends(get_db) + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db) ) -> list[Tenants]: """ 获取当前用户所属的所有租户 由于每个用户只属于一个租户，返回包含该租户的列表 """ auth_logger.debug(f"获取用户 {current_user.username} 的所有租户") - + try: if current_user.tenant: tenants = [current_user.tenant] @@ -152,7 +155,7 @@ async def get_user_tenants( else: auth_logger.info(f"用户 {current_user.username} 没有关联的租户") return [] - + except Exception as e: auth_logger.error(f"获取用户租户列表时发生错误: {str(e)}") raise HTTPException( @@ -162,20 +165,20 @@ async def get_user_tenants( async def get_current_superuser( - current_user: User = Depends(get_current_user) + current_user: User = Depends(get_current_user) ) -> User: """ 检查当前用户是否为超级管理员 """ auth_logger.debug(f"检查用户 {current_user.username} 是否为超级管理员") - + if not current_user.is_superuser: auth_logger.warning(f"用户 {current_user.username} 尝试访问超管功能但不是超级管理员") raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail="只有超级管理员才能执行此操作" ) - + auth_logger.info(f"超级管理员 {current_user.username} 访问超管功能") return current_user @@ -246,13 +249,13 @@ async def get_current_superuser( def _check_workspace_access_sync(db: Session, user: User, workspace_id: uuid.UUID) -> Workspace: """同步校验版本，供装饰器在同步端点中调用 - 使用权限服务""" auth_logger.debug(f"同步校验工作空间访问权限: workspace_id={workspace_id}, user={user.id}") - + # 1) 工作空间存在性 workspace = workspace_repository.get_workspace_by_id(db=db, workspace_id=workspace_id) if not workspace: auth_logger.warning(f"工作空间不存在: {workspace_id}") raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Workspace not found") - + # 2) 超级用户跳过成员检查，直接验证租户 if user.is_superuser: if user.tenant_id == workspace.tenant_id: @@ -261,26 +264,26 @@ def _check_workspace_access_sync(db: Session, user: User, workspace_id: uuid.UUI else: auth_logger.warning(f"超级用户尝试访问其他租户工作空间: workspace_id={workspace_id}, user={user.id}") raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden") - + # 3) 普通用户使用权限服务检查访问权限 from app.core.permissions import permission_service, Subject, Resource, Action from app.core.permissions.policies import WorkspaceMemberPolicy, SameTenantSuperuserPolicy - + # Check if user is a member member = workspace_repository.get_member_in_workspace( db=db, user_id=user.id, workspace_id=workspace_id ) workspace_memberships = {workspace_id} if member else set() - + subject = Subject.from_user(user, workspace_memberships=workspace_memberships) resource = Resource.from_workspace(workspace) - + # Add workspace member policy temp_service = permission_service if member: temp_service.add_policy(WorkspaceMemberPolicy(allowed_actions={Action.READ, Action.UPDATE, Action.MANAGE})) temp_service.add_policy(SameTenantSuperuserPolicy()) - + try: permission_service.require_permission( subject, @@ -317,7 +320,8 @@ def workspace_access_guard(get_workspace_id_from_body: bool = False): if get_workspace_id_from_body: payload = kwargs.get("payload") if not payload or not hasattr(payload, "workspace_id"): - raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="workspace_id missing in body") + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, + detail="workspace_id missing in body") workspace_id = payload.workspace_id else: workspace_id = kwargs.get("workspace_id") @@ -326,6 +330,7 @@ def workspace_access_guard(get_workspace_id_from_body: bool = False): _check_workspace_access_sync(db, user, workspace_id) return await func(*args, **kwargs) + return _async_wrapper else: @wraps(func) @@ -336,7 +341,8 @@ def workspace_access_guard(get_workspace_id_from_body: bool = False): if get_workspace_id_from_body: payload = kwargs.get("payload") if not payload or not hasattr(payload, "workspace_id"): - raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="workspace_id missing in body") + raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, + detail="workspace_id missing in body") workspace_id = payload.workspace_id else: workspace_id = kwargs.get("workspace_id") @@ -345,6 +351,7 @@ def workspace_access_guard(get_workspace_id_from_body: bool = False): _check_workspace_access_sync(db, user, workspace_id) return func(*args, **kwargs) + return _sync_wrapper return _decorator @@ -384,6 +391,7 @@ def cur_workspace_access_guard(): raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="workspace_id is required") _check_workspace_access_sync(db, user, workspace_id) return await func(*args, **kwargs) + return _async_wrapper else: @wraps(func) @@ -395,20 +403,23 @@ def cur_workspace_access_guard(): raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="workspace_id is required") _check_workspace_access_sync(db, user, workspace_id) return func(*args, **kwargs) + return _sync_wrapper return _decorator + class ShareTokenData: """分享 token 数据""" + def __init__(self, user_id: str, share_token: str): self.user_id = user_id self.share_token = share_token async def get_share_user_id( - token: str = Depends(oauth2_scheme), - db: Session = Depends(get_db) + token: str = Depends(oauth2_scheme), + db: Session = Depends(get_db) ) -> ShareTokenData: """ 从分享访问 token 中获取用户 ID 和 share_token @@ -422,38 +433,40 @@ async def get_share_user_id( from app.services.auth_service import decode_access_token from app.services.release_share_service import ReleaseShareService from app.core.exceptions import BusinessException - + credentials_exception = HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Could not validate credentials", headers={"WWW-Authenticate": "Bearer"}, ) - + try: auth_logger.debug("开始解析分享访问 token") - + # 解码 token 获取 user_id 和 share_token payload = decode_access_token(token) user_id = payload["user_id"] share_token = payload["share_token"] - + auth_logger.debug(f"Token 解析成功，用户ID: {user_id}, share_token: {share_token}") - + # 验证 share_token 是否有效 service = ReleaseShareService(db) share_info = service.get_shared_release_info(share_token=share_token) - + if not share_info: auth_logger.warning(f"分享 token 无效: {share_token}") raise credentials_exception - + auth_logger.info(f"分享访问验证成功: user_id={user_id}, share_token={share_token}") return ShareTokenData(user_id=user_id, share_token=share_token) - + except BusinessException as e: auth_logger.warning(f"分享访问验证失败: {str(e)}") raise credentials_exception except Exception as e: auth_logger.error(f"验证分享访问 token 时发生错误: {str(e)}") raise credentials_exception - + + + diff --git a/api/app/main.py b/api/app/main.py index e3a571d7..20a2b0d9 100644 --- a/api/app/main.py +++ b/api/app/main.py @@ -1,4 +1,5 @@ import os +import subprocess from dotenv import load_dotenv from fastapi import FastAPI, HTTPException, Request from fastapi.middleware.cors import CORSMiddleware @@ -32,7 +33,6 @@ from app.controllers import ( from fastapi import FastAPI, APIRouter - app = FastAPI(title="Data Config API", version="1.0.0") router = APIRouter(prefix="/memory", tags=["Memory"]) @@ -46,16 +46,16 @@ from app.controllers.service import service_router LoggingConfig.setup_logging() logger = get_logger(__name__) + @asynccontextmanager async def lifespan(app: FastAPI): """使用 FastAPI lifespan 替代 on_event 处理启动/关闭事件""" # 应用启动事件 - + # 检查是否需要自动升级数据库 if settings.DB_AUTO_UPGRADE: logger.info("开始自动升级数据库...") try: - import subprocess result = subprocess.run( ["alembic", "upgrade", "head"], capture_output=True, @@ -71,11 +71,12 @@ async def lifespan(app: FastAPI): raise else: logger.info("自动数据库升级已禁用 (DB_AUTO_UPGRADE=false)") - + logger.info("应用程序启动完成") yield # 应用关闭事件 - logger.info("应用程序正在关闭") + logger.info("应用程序正在关闭") + app = FastAPI( title="redbera-mem", @@ -120,10 +121,8 @@ app.include_router(manager_router, prefix="/api") # 服务端 API (API Key 认证) app.include_router(service_router, prefix="/v1") - logger.info("所有路由已注册完成") - # Import additional exception types for specific handling from app.core.exceptions import ( ValidationException, @@ -131,7 +130,8 @@ from app.core.exceptions import ( PermissionDeniedException, AuthenticationException, AuthorizationException, - FileUploadException + FileUploadException, + RateLimitException ) from app.core.sensitive_filter import SensitiveDataFilter import traceback @@ -143,7 +143,7 @@ async def validation_exception_handler(request: Request, exc: ValidationExceptio """处理验证异常""" # 过滤敏感信息 filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context) - + logger.warning( f"Validation error: {filtered_message}", extra={ @@ -169,7 +169,7 @@ async def not_found_exception_handler(request: Request, exc: ResourceNotFoundExc """处理资源不存在异常""" # 过滤敏感信息 filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context) - + logger.info( f"Resource not found: {filtered_message}", extra={ @@ -194,7 +194,7 @@ async def permission_denied_handler(request: Request, exc: PermissionDeniedExcep """处理权限拒绝异常""" # 过滤敏感信息 filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context) - + logger.warning( f"Permission denied: {filtered_message}", extra={ @@ -220,7 +220,7 @@ async def authentication_exception_handler(request: Request, exc: Authentication """处理认证异常""" # 过滤敏感信息 filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context) - + logger.warning( f"Authentication error: {filtered_message}", extra={ @@ -245,7 +245,7 @@ async def authorization_exception_handler(request: Request, exc: AuthorizationEx """处理授权异常""" # 过滤敏感信息 filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context) - + logger.warning( f"Authorization error: {filtered_message}", extra={ @@ -270,7 +270,7 @@ async def file_upload_exception_handler(request: Request, exc: FileUploadExcepti """处理文件上传异常""" # 过滤敏感信息 filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context) - + logger.error( f"File upload error: {filtered_message}", extra={ @@ -290,13 +290,48 @@ async def file_upload_exception_handler(request: Request, exc: FileUploadExcepti ) +# 处理限流异常 +@app.exception_handler(RateLimitException) +async def rate_limit_exception_handler(request: Request, exc: RateLimitException): + """处理限流异常""" + # 过滤敏感信息 + filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context) + + logger.warning( + f"Rate limit exceeded: {filtered_message}", + extra={ + "path": request.url.path, + "method": request.method, + "context": filtered_context, + "error_code": exc.code.value if isinstance(exc.code, BizCode) else exc.code, + "cause": str(exc.cause) if exc.cause else None + } + ) + + biz_code = exc.code if isinstance(exc.code, BizCode) else BizCode.RATE_LIMITED + status_code = HTTP_MAPPING.get(biz_code, 429) + + # 创建响应对象并添加限流头信息 + response = JSONResponse( + status_code=status_code, + content=fail(code=biz_code.value, msg=filtered_message, error=filtered_message) + ) + + # 添加限流相关的响应头 + rate_headers = exc.context.get("rate_limit_headers", {}) if exc.context else {} + for header_name, header_value in rate_headers.items(): + response.headers[header_name] = str(header_value) + + return response + + # 业务异常统一处理（使用业务错误码） @app.exception_handler(BusinessException) async def business_exception_handler(request: Request, exc: BusinessException): """处理通用业务异常""" # 过滤敏感信息 filtered_message, filtered_context = SensitiveDataFilter.filter_message(exc.message, exc.context) - + logger.error( f"Business error: {filtered_message}", extra={ @@ -332,7 +367,7 @@ async def http_exception_handler(request: Request, exc: HTTPException): """处理HTTP异常""" # 过滤敏感信息 filtered_detail = SensitiveDataFilter.filter_string(str(exc.detail)) - + logger.warning( f"HTTP exception: {filtered_detail}", extra={ @@ -362,7 +397,7 @@ async def unhandled_exception_handler(request: Request, exc: Exception): }, exc_info=True ) - + # 生产环境隐藏详细错误信息 environment = os.getenv("ENVIRONMENT", "development") if environment == "production": @@ -370,7 +405,7 @@ async def unhandled_exception_handler(request: Request, exc: Exception): else: # 开发环境也要过滤敏感信息 message = SensitiveDataFilter.filter_string(str(exc)) - + return JSONResponse( status_code=500, content=fail(code=BizCode.INTERNAL_ERROR.value, msg=message, error=message) @@ -379,4 +414,5 @@ async def unhandled_exception_handler(request: Request, exc: Exception): if __name__ == "__main__": import uvicorn - uvicorn.run(app, host="0.0.0.0", port=8000) \ No newline at end of file + + uvicorn.run(app, host="0.0.0.0", port=8000) diff --git a/api/app/models/__init__.py b/api/app/models/__init__.py index 238e4d47..493e894b 100644 --- a/api/app/models/__init__.py +++ b/api/app/models/__init__.py @@ -15,7 +15,7 @@ from .end_user_model import EndUser from .appshare_model import AppShare from .release_share_model import ReleaseShare from .conversation_model import Conversation, Message -from .api_key_model import ApiKey, ApiKeyLog, ApiKeyType +from .api_key_model import ApiKey, ApiKeyLog, ApiKeyType, ResourceType from .data_config_model import DataConfig from .multi_agent_model import MultiAgentConfig, AgentInvocation @@ -46,6 +46,7 @@ __all__ = [ "ApiKey", "ApiKeyLog", "ApiKeyType", + "ResourceType", "DataConfig", "MultiAgentConfig", "AgentInvocation" diff --git a/api/app/models/api_key_model.py b/api/app/models/api_key_model.py index 70f17b1d..b123a034 100644 --- a/api/app/models/api_key_model.py +++ b/api/app/models/api_key_model.py @@ -1,20 +1,29 @@ """API Key 数据模型""" import datetime import uuid -from enum import StrEnum -from sqlalchemy import Column, String, Boolean, DateTime, Integer, ForeignKey, Text + +from sqlalchemy import Column, String, Boolean, DateTime, Integer, ForeignKey, Text, Enum from sqlalchemy.dialects.postgresql import UUID, JSONB from sqlalchemy.orm import relationship +from enum import StrEnum from app.db import Base class ApiKeyType(StrEnum): """API Key 类型""" - APP = "app" # 应用 API Key - RAG = "rag" # RAG API Key - MEMORY = "memory" # Memory API Key - GENERAL = "general" # 通用 API Key + APP = "app" # 应用 API Key + RAG = "rag" # RAG API Key + MEMORY = "memory" # Memory API Key + + +class ResourceType(StrEnum): + """资源类型枚举""" + AGENT = "Agent" # 智能体 + CLUSTER = "Cluster" # 集群 + WORKFLOW = "Workflow" # 工作流 + KNOWLEDGE = "Knowledge" # 知识库 + MEMORY_ENGINE = "Memory_Engine" # 记忆引擎 class ApiKey(Base): @@ -22,40 +31,43 @@ class ApiKey(Base): __tablename__ = "api_keys" id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, index=True) - + # 基本信息 name = Column(String(255), nullable=False, comment="API Key 名称") description = Column(Text, comment="描述") key_prefix = Column(String(20), nullable=False, comment="Key 前缀") key_hash = Column(String(255), nullable=False, unique=True, index=True, comment="Key 哈希值") - + # 类型和权限 type = Column(String(50), nullable=False, index=True, comment="API Key 类型") scopes = Column(JSONB, nullable=False, default=list, comment="权限范围列表") - + # 关联资源 - workspace_id = Column(UUID(as_uuid=True), ForeignKey("workspaces.id", ondelete="CASCADE"), nullable=False, index=True, comment="所属工作空间") + workspace_id = Column(UUID(as_uuid=True), ForeignKey("workspaces.id", ondelete="CASCADE"), nullable=False, + index=True, comment="所属工作空间") resource_id = Column(UUID(as_uuid=True), index=True, comment="关联资源ID") resource_type = Column(String(50), comment="资源类型") - + # 限制和配额 - rate_limit = Column(Integer, default=100, comment="速率限制（请求/分钟）") + rate_limit = Column(Integer, default=10, comment="QPS限制（请求/秒）") + daily_request_limit = Column(Integer, default=10000, comment="日请求限制") + + # 配额和使用统计 quota_limit = Column(Integer, comment="配额限制（总请求数）") quota_used = Column(Integer, default=0, comment="已使用配额") - - # 有效期 - expires_at = Column(DateTime, comment="过期时间") - - # 状态 - is_active = Column(Boolean, default=True, nullable=False, comment="是否激活") - last_used_at = Column(DateTime, comment="最后使用时间") usage_count = Column(Integer, default=0, comment="使用次数") - + last_used_at = Column(DateTime, comment="最后使用时间") + + # 状态管理 + is_active = Column(Boolean, default=True, nullable=False, comment="是否激活") + expires_at = Column(DateTime, comment="过期时间") + # 审计 created_by = Column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=False, comment="创建者") created_at = Column(DateTime, nullable=False, default=datetime.datetime.now, comment="创建时间") - updated_at = Column(DateTime, nullable=False, default=datetime.datetime.now, onupdate=datetime.datetime.now, comment="更新时间") - + updated_at = Column(DateTime, nullable=False, default=datetime.datetime.now, onupdate=datetime.datetime.now, + comment="更新时间") + # 关系 workspace = relationship("Workspace", back_populates="api_keys") creator = relationship("User", foreign_keys=[created_by]) @@ -67,24 +79,25 @@ class ApiKeyLog(Base): __tablename__ = "api_key_logs" id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, index=True) - - api_key_id = Column(UUID(as_uuid=True), ForeignKey("api_keys.id", ondelete="CASCADE"), nullable=False, index=True, comment="API Key ID") - + + api_key_id = Column(UUID(as_uuid=True), ForeignKey("api_keys.id", ondelete="CASCADE"), nullable=False, index=True, + comment="API Key ID") + # 请求信息 - endpoint = Column(String(255), nullable=False, comment="请求端点") + endpoint = Column(String(255), nullable=False, comment="请求端点", index=True) method = Column(String(10), nullable=False, comment="HTTP 方法") ip_address = Column(String(50), comment="IP 地址") user_agent = Column(Text, comment="User Agent") - + # 响应信息 - status_code = Column(Integer, comment="响应状态码") + status_code = Column(Integer, comment="响应状态码", index=True) response_time = Column(Integer, comment="响应时间（毫秒）") - + # Token 使用 tokens_used = Column(Integer, comment="使用的 Token 数") - + # 时间 created_at = Column(DateTime, nullable=False, default=datetime.datetime.now, index=True, comment="创建时间") - + # 关系 api_key = relationship("ApiKey", back_populates="logs") diff --git a/api/app/models/knowledge_model.py b/api/app/models/knowledge_model.py index bdb97678..0587da53 100644 --- a/api/app/models/knowledge_model.py +++ b/api/app/models/knowledge_model.py @@ -34,6 +34,7 @@ class ParserType(enum.StrEnum): class PermissionType(enum.StrEnum): Private = "Private" Share = "Share" + Memory = "Memory" class Knowledge(Base): __tablename__ = "knowledges" @@ -46,7 +47,7 @@ class Knowledge(Base): description = Column(String, comment="KB description") avatar = Column(String, comment="avatar url") type = Column(String, default="General", comment="Type:General|Web|Third-party|Folder") - permission_id = Column(String, default="Private", comment="permission ID:Private|Share") + permission_id = Column(String, default="Private", comment="permission ID:Private|Share|Memory") embedding_id = Column(UUID(as_uuid=True), ForeignKey('model_configs.id', ondelete="SET NULL"), nullable=True, comment="default embedding model ID") reranker_id = Column(UUID(as_uuid=True), ForeignKey('model_configs.id', ondelete="SET NULL"), nullable=True, comment="default reranker model ID") llm_id = Column(UUID(as_uuid=True), ForeignKey('model_configs.id', ondelete="SET NULL"), nullable=True, comment="default llm model ID") diff --git a/api/app/models/models_model.py b/api/app/models/models_model.py index e5215018..3b0c1221 100644 --- a/api/app/models/models_model.py +++ b/api/app/models/models_model.py @@ -37,6 +37,7 @@ class ModelConfig(Base): __tablename__ = "model_configs" id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, index=True) + tenant_id = Column(UUID(as_uuid=True), ForeignKey("tenants.id"), nullable=False, index=True, comment="租户ID") name = Column(String, nullable=False, comment="模型显示名称") type = Column(String, nullable=False, index=True, comment="模型类型") description = Column(String, comment="模型描述") diff --git a/api/app/repositories/api_key_repository.py b/api/app/repositories/api_key_repository.py index ceeb99cd..27ffdff0 100644 --- a/api/app/repositories/api_key_repository.py +++ b/api/app/repositories/api_key_repository.py @@ -1,9 +1,10 @@ """API Key Repository""" -from sqlalchemy.orm import Session -from sqlalchemy import select, func, and_ -from typing import Optional, List, Tuple import uuid import datetime +from typing import Optional, List, Tuple + +from sqlalchemy.orm import Session +from sqlalchemy import select, func, and_ from app.models.api_key_model import ApiKey, ApiKeyLog from app.schemas import api_key_schema @@ -11,7 +12,7 @@ from app.schemas import api_key_schema class ApiKeyRepository: """API Key 数据访问层""" - + @staticmethod def create(db: Session, api_key_data: dict) -> ApiKey: """创建 API Key""" @@ -19,27 +20,27 @@ class ApiKeyRepository: db.add(api_key) db.flush() return api_key - + @staticmethod def get_by_id(db: Session, api_key_id: uuid.UUID) -> Optional[ApiKey]: """根据 ID 获取 API Key""" return db.get(ApiKey, api_key_id) - + @staticmethod def get_by_hash(db: Session, key_hash: str) -> Optional[ApiKey]: """根据哈希值获取 API Key""" stmt = select(ApiKey).where(ApiKey.key_hash == key_hash) return db.scalars(stmt).first() - + @staticmethod def list_by_workspace( - db: Session, - workspace_id: uuid.UUID, - query: api_key_schema.ApiKeyQuery + db: Session, + workspace_id: uuid.UUID, + query: api_key_schema.ApiKeyQuery ) -> Tuple[List[ApiKey], int]: """列出工作空间的 API Keys""" stmt = select(ApiKey).where(ApiKey.workspace_id == workspace_id) - + # 过滤条件 if query.type: stmt = stmt.where(ApiKey.type == query.type) @@ -47,40 +48,39 @@ class ApiKeyRepository: stmt = stmt.where(ApiKey.is_active == query.is_active) if query.resource_id: stmt = stmt.where(ApiKey.resource_id == query.resource_id) - + # 总数 count_stmt = select(func.count()).select_from(stmt.subquery()) total = db.execute(count_stmt).scalar() - + # 分页 stmt = stmt.order_by(ApiKey.created_at.desc()) stmt = stmt.offset((query.page - 1) * query.pagesize).limit(query.pagesize) - + items = db.scalars(stmt).all() return list(items), total - + @staticmethod - def update(db: Session, api_key_id: uuid.UUID, update_data: dict) -> ApiKey: + def update(db: Session, api_key_id: uuid.UUID, update_data: dict) -> ApiKey | None: """更新 API Key""" api_key = db.get(ApiKey, api_key_id) if api_key: for key, value in update_data.items(): if value is not None: setattr(api_key, key, value) - api_key.updated_at = datetime.datetime.now() db.flush() return api_key - + @staticmethod def delete(db: Session, api_key_id: uuid.UUID) -> bool: - """删除 API Key""" + """逻辑删除 API Key""" api_key = db.get(ApiKey, api_key_id) if api_key: - db.delete(api_key) + api_key.is_active = False db.flush() return True return False - + @staticmethod def update_usage(db: Session, api_key_id: uuid.UUID) -> bool: """更新使用统计""" @@ -92,14 +92,14 @@ class ApiKeyRepository: db.flush() return True return False - + @staticmethod def get_stats(db: Session, api_key_id: uuid.UUID) -> dict: """获取使用统计""" api_key = db.get(ApiKey, api_key_id) if not api_key: return {} - + # 今日请求数 today_start = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0) today_count_stmt = select(func.count()).select_from(ApiKeyLog).where( @@ -109,13 +109,13 @@ class ApiKeyRepository: ) ) requests_today = db.execute(today_count_stmt).scalar() or 0 - + # 平均响应时间 avg_time_stmt = select(func.avg(ApiKeyLog.response_time)).where( ApiKeyLog.api_key_id == api_key_id ) avg_response_time = db.execute(avg_time_stmt).scalar() - + return { "total_requests": api_key.usage_count, "requests_today": requests_today, @@ -128,7 +128,7 @@ class ApiKeyRepository: class ApiKeyLogRepository: """API Key 日志数据访问层""" - + @staticmethod def create(db: Session, log_data: dict) -> ApiKeyLog: """创建日志""" @@ -136,3 +136,54 @@ class ApiKeyLogRepository: db.add(log) db.flush() return log + + @staticmethod + def list_by_api_key( + db: Session, + api_key_id: uuid.UUID, + filters: dict, + page: int, + pagesize: int + ) -> Tuple[List[ApiKeyLog], int]: + """ + 根据 API Key ID 查询日志列表 + + Args: + db: 数据库会话 + api_key_id: API Key ID + filters: 过滤条件字典，支持： + - start_date: 开始日期 + - end_date: 结束日期 + - status_code: HTTP 状态码 + - endpoint: 端点路径 + page: 页码 + pagesize: 每页数量 + + Returns: + Tuple[List[ApiKeyLog], int]: (日志列表, 总数) + """ + stmt = select(ApiKeyLog).where(ApiKeyLog.api_key_id == api_key_id) + + # 应用过滤条件 + if filters.get('start_date'): + stmt = stmt.where(ApiKeyLog.created_at >= filters['start_date']) + + if filters.get('end_date'): + stmt = stmt.where(ApiKeyLog.created_at <= filters['end_date']) + + if filters.get('status_code'): + stmt = stmt.where(ApiKeyLog.status_code == filters['status_code']) + + if filters.get('endpoint'): + stmt = stmt.where(ApiKeyLog.endpoint.ilike(f"%{filters['endpoint']}%")) + + # 计算总数 + count_stmt = select(func.count()).select_from(stmt.subquery()) + total = db.execute(count_stmt).scalar() + + # 分页和排序 + stmt = stmt.order_by(ApiKeyLog.created_at.desc()) + stmt = stmt.offset((page - 1) * pagesize).limit(pagesize) + + items = db.scalars(stmt).all() + return list(items), total diff --git a/api/app/repositories/base_repository.py b/api/app/repositories/base_repository.py index a62404ec..005d6336 100644 --- a/api/app/repositories/base_repository.py +++ b/api/app/repositories/base_repository.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """基础仓储接口模块 本模块定义了通用的仓储接口，适用于所有数据库类型（PostgreSQL、Neo4j等）。 @@ -14,7 +13,7 @@ from typing import Generic, TypeVar, List, Optional, Dict, Any T = TypeVar('T') -class BaseRepository(ABC, Generic[T]): +class BaseRepository[T](ABC): """基础仓储接口 - 适用于所有数据库类型 这是一个抽象基类，定义了所有仓储必须实现的基本CRUD操作。 diff --git a/api/app/repositories/data_config_repository.py b/api/app/repositories/data_config_repository.py index d1d1af90..ed1a482a 100644 --- a/api/app/repositories/data_config_repository.py +++ b/api/app/repositories/data_config_repository.py @@ -1,16 +1,19 @@ # -*- coding: utf-8 -*- """数据配置Repository模块 -本模块提供data_config表的数据访问层，包括SQL查询构建和Neo4j Cypher查询。 -从 app.core.memory.src.data_config_api.sql_queries 迁移而来。 +本模块提供data_config表的数据访问层，使用SQLAlchemy ORM进行数据库操作。 +包括CRUD操作和Neo4j Cypher查询常量。 Classes: - DataConfigRepository: 数据配置仓储类，提供CRUD操作和查询构建 + DataConfigRepository: 数据配置仓储类，提供CRUD操作 """ -from typing import Dict, Tuple, List +from typing import Dict, List, Optional, Tuple from sqlalchemy.orm import Session +from sqlalchemy import desc +import uuid +from app.models.data_config_model import DataConfig from app.schemas.memory_storage_schema import ( ConfigParamsCreate, ConfigParamsDelete, @@ -24,15 +27,12 @@ from app.core.logging_config import get_db_logger # 获取数据库专用日志器 db_logger = get_db_logger() -# 表名常量 -TABLE_NAME = "data_config" - class DataConfigRepository: """数据配置Repository 提供data_config表的数据访问方法，包括： - - SQL查询构建（PostgreSQL） + - SQLAlchemy ORM 数据库操作 - Neo4j Cypher查询常量 """ @@ -136,273 +136,369 @@ class DataConfigRepository: } AS targetNode """ - # ==================== SQL 查询构建方法 ==================== + # ==================== SQLAlchemy ORM 数据库操作方法 ==================== @staticmethod - def build_insert(params: ConfigParamsCreate) -> Tuple[str, Dict]: - """构建插入语句（PostgreSQL 命名参数） + def create(db: Session, params: ConfigParamsCreate) -> DataConfig: + """创建数据配置 Args: + db: 数据库会话 params: 配置参数创建模型 Returns: - Tuple[str, Dict]: (SQL查询字符串, 参数字典) + DataConfig: 创建的配置对象 """ - db_logger.debug(f"构建插入语句: config_name={params.config_name}, workspace_id={params.workspace_id}") + db_logger.debug(f"创建数据配置: config_name={params.config_name}, workspace_id={params.workspace_id}") - columns = [ - "config_name", - "config_desc", - "workspace_id", - "llm_id", - "embedding_id", - "rerank_id", - "created_at", - ] - placeholders = [ - "%(config_name)s", - "%(config_desc)s", - "%(workspace_id)s::uuid", - "%(llm_id)s", - "%(embedding_id)s", - "%(rerank_id)s", - "timezone('Asia/Shanghai', now())", - ] - query = f"INSERT INTO {TABLE_NAME} (" + ",".join(columns) + ") VALUES (" + ",".join(placeholders) + ")" - # 将 UUID 转换为字符串 - workspace_id_str = str(params.workspace_id) if params.workspace_id else None - params_dict = { - "config_name": params.config_name, - "config_desc": params.config_desc, - "workspace_id": workspace_id_str, - "llm_id": params.llm_id, - "embedding_id": params.embedding_id, - "rerank_id": params.rerank_id, - } - return query, params_dict + try: + db_config = DataConfig( + config_name=params.config_name, + config_desc=params.config_desc, + workspace_id=params.workspace_id, + llm_id=params.llm_id, + embedding_id=params.embedding_id, + rerank_id=params.rerank_id, + ) + db.add(db_config) + db.flush() # 获取自增ID但不提交事务 + + db_logger.info(f"数据配置已添加到会话: {db_config.config_name} (ID: {db_config.config_id})") + return db_config + + except Exception as e: + db.rollback() + db_logger.error(f"创建数据配置失败: {params.config_name} - {str(e)}") + raise @staticmethod - def build_update(update: ConfigUpdate) -> Tuple[str, Dict]: - """构建基础配置更新语句（PostgreSQL 命名参数） + def update(db: Session, update: ConfigUpdate) -> Optional[DataConfig]: + """更新基础配置 Args: + db: 数据库会话 update: 配置更新模型 Returns: - Tuple[str, Dict]: (SQL查询字符串, 参数字典) + Optional[DataConfig]: 更新后的配置对象，不存在则返回None Raises: ValueError: 没有字段需要更新时抛出 """ - db_logger.debug(f"构建更新语句: config_id={update.config_id}") + db_logger.debug(f"更新数据配置: config_id={update.config_id}") - key_where = "config_id = %(config_id)s" - set_fields: List[str] = [] - params: Dict = { - "config_id": update.config_id, - } - - mapping = { - "config_name": "config_name", - "config_desc": "config_desc", - } - - for api_field, db_col in mapping.items(): - value = getattr(update, api_field) - if value is not None: - set_fields.append(f"{db_col} = %({api_field})s") - params[api_field] = value - - set_fields.append("updated_at = timezone('Asia/Shanghai', now())") - if not set_fields: - raise ValueError("No fields to update") - query = f"UPDATE {TABLE_NAME} SET " + ", ".join(set_fields) + f" WHERE {key_where}" - return query, params + try: + db_config = db.query(DataConfig).filter(DataConfig.config_id == update.config_id).first() + if not db_config: + db_logger.warning(f"数据配置不存在: config_id={update.config_id}") + return None + + # 更新字段 + has_update = False + if update.config_name is not None: + db_config.config_name = update.config_name + has_update = True + if update.config_desc is not None: + db_config.config_desc = update.config_desc + has_update = True + + if not has_update: + raise ValueError("No fields to update") + + db.commit() + db.refresh(db_config) + + db_logger.info(f"数据配置更新成功: {db_config.config_name} (ID: {update.config_id})") + return db_config + + except Exception as e: + db.rollback() + db_logger.error(f"更新数据配置失败: config_id={update.config_id} - {str(e)}") + raise @staticmethod - def build_update_extracted(update: ConfigUpdateExtracted) -> Tuple[str, Dict]: - """构建记忆萃取引擎配置更新语句（PostgreSQL 命名参数） + def update_extracted(db: Session, update: ConfigUpdateExtracted) -> Optional[DataConfig]: + """更新记忆萃取引擎配置 Args: + db: 数据库会话 update: 萃取配置更新模型 Returns: - Tuple[str, Dict]: (SQL查询字符串, 参数字典) + Optional[DataConfig]: 更新后的配置对象，不存在则返回None Raises: ValueError: 没有字段需要更新时抛出 """ - db_logger.debug(f"构建萃取配置更新语句: config_id={update.config_id}") + db_logger.debug(f"更新萃取配置: config_id={update.config_id}") - key_where = "config_id = %(config_id)s" - set_fields: List[str] = [] - params: Dict = { - "config_id": update.config_id, - } - - mapping = { - # 模型选择 - "llm_id": "llm", - "embedding_id": "embedding", - "rerank_id": "rerank", - # 记忆萃取引擎 - "enable_llm_dedup_blockwise": "enable_llm_dedup_blockwise", - "enable_llm_disambiguation": "enable_llm_disambiguation", - "deep_retrieval": "deep_retrieval", - "t_type_strict": "t_type_strict", - "t_name_strict": "t_name_strict", - "t_overall": "t_overall", - "state": "state", - "chunker_strategy": "chunker_strategy", - # 句子提取 - "statement_granularity": "statement_granularity", - "include_dialogue_context": "include_dialogue_context", - "max_context": "max_context", - # 剪枝配置 - "pruning_enabled": "pruning_enabled", - "pruning_scene": "pruning_scene", - "pruning_threshold": "pruning_threshold", - # 自我反思配置 - "enable_self_reflexion": "enable_self_reflexion", - "iteration_period": "iteration_period", - "reflexion_range": "reflexion_range", - "baseline": "baseline", - } - - for api_field, db_col in mapping.items(): - value = getattr(update, api_field) - if value is not None: - set_fields.append(f"{db_col} = %({api_field})s") - params[api_field] = value - - set_fields.append("updated_at = timezone('Asia/Shanghai', now())") - if not set_fields: - raise ValueError("No fields to update") - query = f"UPDATE {TABLE_NAME} SET " + ", ".join(set_fields) + f" WHERE {key_where}" - return query, params + try: + db_config = db.query(DataConfig).filter(DataConfig.config_id == update.config_id).first() + if not db_config: + db_logger.warning(f"数据配置不存在: config_id={update.config_id}") + return None + + # 更新字段映射 + field_mapping = { + # 模型选择 + "llm_id": "llm", + "embedding_id": "embedding_id", + "rerank_id": "rerank_id", + # 记忆萃取引擎 + "enable_llm_dedup_blockwise": "enable_llm_dedup_blockwise", + "enable_llm_disambiguation": "enable_llm_disambiguation", + "deep_retrieval": "deep_retrieval", + "t_type_strict": "t_type_strict", + "t_name_strict": "t_name_strict", + "t_overall": "t_overall", + "state": "state", + "chunker_strategy": "chunker_strategy", + # 句子提取 + "statement_granularity": "statement_granularity", + "include_dialogue_context": "include_dialogue_context", + "max_context": "max_context", + # 剪枝配置 + "pruning_enabled": "pruning_enabled", + "pruning_scene": "pruning_scene", + "pruning_threshold": "pruning_threshold", + # 自我反思配置 + "enable_self_reflexion": "enable_self_reflexion", + "iteration_period": "iteration_period", + "reflexion_range": "reflexion_range", + "baseline": "baseline", + } + + has_update = False + for api_field, db_field in field_mapping.items(): + value = getattr(update, api_field, None) + if value is not None: + setattr(db_config, db_field, value) + has_update = True + + if not has_update: + raise ValueError("No fields to update") + + db.commit() + db.refresh(db_config) + + db_logger.info(f"萃取配置更新成功: config_id={update.config_id}") + return db_config + + except Exception as e: + db.rollback() + db_logger.error(f"更新萃取配置失败: config_id={update.config_id} - {str(e)}") + raise @staticmethod - def build_update_forget(update: ConfigUpdateForget) -> Tuple[str, Dict]: - """构建遗忘引擎配置更新语句（PostgreSQL 命名参数） + def update_forget(db: Session, update: ConfigUpdateForget) -> Optional[DataConfig]: + """更新遗忘引擎配置 Args: + db: 数据库会话 update: 遗忘配置更新模型 Returns: - Tuple[str, Dict]: (SQL查询字符串, 参数字典) + Optional[DataConfig]: 更新后的配置对象，不存在则返回None Raises: ValueError: 没有字段需要更新时抛出 """ - db_logger.debug(f"构建遗忘配置更新语句: config_id={update.config_id}") + db_logger.debug(f"更新遗忘配置: config_id={update.config_id}") - key_where = "config_id = %(config_id)s" - set_fields: List[str] = [] - params: Dict = { - "config_id": update.config_id, - } - - mapping = { - # 遗忘引擎 - "lambda_time": "lambda_time", - "lambda_mem": "lambda_mem", - # 由于 PostgreSQL 中 OFFSET 是保留字，需使用双引号包裹列名 - "offset": '"offset"', - } - - for api_field, db_col in mapping.items(): - value = getattr(update, api_field) - if value is not None: - set_fields.append(f"{db_col} = %({api_field})s") - params[api_field] = value - - set_fields.append("updated_at = timezone('Asia/Shanghai', now())") - if not set_fields: - raise ValueError("No fields to update") - query = f"UPDATE {TABLE_NAME} SET " + ", ".join(set_fields) + f" WHERE {key_where}" - return query, params + try: + db_config = db.query(DataConfig).filter(DataConfig.config_id == update.config_id).first() + if not db_config: + db_logger.warning(f"数据配置不存在: config_id={update.config_id}") + return None + + # 更新字段 + has_update = False + if update.lambda_time is not None: + db_config.lambda_time = update.lambda_time + has_update = True + if update.lambda_mem is not None: + db_config.lambda_mem = update.lambda_mem + has_update = True + if update.offset is not None: + db_config.offset = update.offset + has_update = True + + if not has_update: + raise ValueError("No fields to update") + + db.commit() + db.refresh(db_config) + + db_logger.info(f"遗忘配置更新成功: config_id={update.config_id}") + return db_config + + except Exception as e: + db.rollback() + db_logger.error(f"更新遗忘配置失败: config_id={update.config_id} - {str(e)}") + raise @staticmethod - def build_select_extracted(key: ConfigKey) -> Tuple[str, Dict]: - """构建萃取配置查询语句，通过主键查询某条配置（PostgreSQL 命名参数） + def get_extracted_config(db: Session, config_id: int) -> Optional[Dict]: + """获取萃取配置，通过主键查询某条配置 Args: - key: 配置键模型 + db: 数据库会话 + config_id: 配置ID Returns: - Tuple[str, Dict]: (SQL查询字符串, 参数字典) + Optional[Dict]: 萃取配置字典，不存在则返回None """ - db_logger.debug(f"构建萃取配置查询语句: config_id={key.config_id}") - # f"SELECT statement_granularity, include_dialogue_context, max_context, " + db_logger.debug(f"查询萃取配置: config_id={config_id}") + + try: + db_config = db.query(DataConfig).filter(DataConfig.config_id == config_id).first() + if not db_config: + db_logger.debug(f"萃取配置不存在: config_id={config_id}") + return None + + result = { + "llm_id": db_config.llm_id, + "embedding_id": db_config.embedding_id, + "rerank_id": db_config.rerank_id, + "enable_llm_dedup_blockwise": db_config.enable_llm_dedup_blockwise, + "enable_llm_disambiguation": db_config.enable_llm_disambiguation, + "deep_retrieval": db_config.deep_retrieval, + "t_type_strict": db_config.t_type_strict, + "t_name_strict": db_config.t_name_strict, + "t_overall": db_config.t_overall, + "chunker_strategy": db_config.chunker_strategy, + "statement_granularity": db_config.statement_granularity, + "include_dialogue_context": db_config.include_dialogue_context, + "max_context": db_config.max_context, + "pruning_enabled": db_config.pruning_enabled, + "pruning_scene": db_config.pruning_scene, + "pruning_threshold": db_config.pruning_threshold, + "enable_self_reflexion": db_config.enable_self_reflexion, + "iteration_period": db_config.iteration_period, + "reflexion_range": db_config.reflexion_range, + "baseline": db_config.baseline, + } + + db_logger.debug(f"萃取配置查询成功: config_id={config_id}") + return result + + except Exception as e: + db_logger.error(f"查询萃取配置失败: config_id={config_id} - {str(e)}") + raise + + @staticmethod + def get_forget_config(db: Session, config_id: int) -> Optional[Dict]: + """获取遗忘配置，通过主键查询某条配置 + + Args: + db: 数据库会话 + config_id: 配置ID + + Returns: + Optional[Dict]: 遗忘配置字典，不存在则返回None + """ + db_logger.debug(f"查询遗忘配置: config_id={config_id}") + + try: + db_config = db.query(DataConfig).filter(DataConfig.config_id == config_id).first() + if not db_config: + db_logger.debug(f"遗忘配置不存在: config_id={config_id}") + return None + + result = { + "lambda_time": db_config.lambda_time, + "lambda_mem": db_config.lambda_mem, + "offset": db_config.offset, + } + + db_logger.debug(f"遗忘配置查询成功: config_id={config_id}") + return result + + except Exception as e: + db_logger.error(f"查询遗忘配置失败: config_id={config_id} - {str(e)}") + raise + + @staticmethod + def get_by_id(db: Session, config_id: int) -> Optional[DataConfig]: + """根据ID获取数据配置 + + Args: + db: 数据库会话 + config_id: 配置ID + + Returns: + Optional[DataConfig]: 配置对象，不存在则返回None + """ + db_logger.debug(f"根据ID查询数据配置: config_id={config_id}") + + try: + config = db.query(DataConfig).filter(DataConfig.config_id == config_id).first() + + if config: + db_logger.debug(f"数据配置查询成功: {config.config_name} (ID: {config_id})") + else: + db_logger.debug(f"数据配置不存在: config_id={config_id}") + return config + except Exception as e: + db_logger.error(f"根据ID查询数据配置失败: config_id={config_id} - {str(e)}") + raise + + @staticmethod + def get_all(db: Session, workspace_id: Optional[uuid.UUID] = None) -> List[DataConfig]: + """获取所有配置参数 + + Args: + db: 数据库会话 + workspace_id: 工作空间ID，用于过滤查询结果 + + Returns: + List[DataConfig]: 配置列表 + """ + db_logger.debug(f"查询所有配置: workspace_id={workspace_id}") + + try: + query = db.query(DataConfig) + + if workspace_id: + query = query.filter(DataConfig.workspace_id == workspace_id) + + configs = query.order_by(desc(DataConfig.updated_at)).all() + + db_logger.debug(f"配置列表查询成功: 数量={len(configs)}") + return configs + + except Exception as e: + db_logger.error(f"查询所有配置失败: workspace_id={workspace_id} - {str(e)}") + raise + + @staticmethod + def delete(db: Session, config_id: int) -> bool: + """删除数据配置 + + Args: + db: 数据库会话 + config_id: 配置ID + + Returns: + bool: 删除成功返回True，配置不存在返回False + """ + db_logger.debug(f"删除数据配置: config_id={config_id}") + + try: + db_config = db.query(DataConfig).filter(DataConfig.config_id == config_id).first() + if not db_config: + db_logger.warning(f"数据配置不存在: config_id={config_id}") + return False + + db.delete(db_config) + db.commit() + + db_logger.info(f"数据配置删除成功: config_id={config_id}") + return True + + except Exception as e: + db.rollback() + db_logger.error(f"删除数据配置失败: config_id={config_id} - {str(e)}") + raise - query = ( - f"SELECT llm_id, embedding_id, rerank_id, " - f"enable_llm_dedup_blockwise, enable_llm_disambiguation, deep_retrieval, " - f"t_type_strict, t_name_strict, t_overall, chunker_strategy, " - f"statement_granularity, include_dialogue_context, max_context, " - f"pruning_enabled, pruning_scene, pruning_threshold, " - f"enable_self_reflexion, iteration_period, reflexion_range, baseline " - f"FROM {TABLE_NAME} WHERE config_id = %(config_id)s" - ) - params = {"config_id": key.config_id} - return query, params - - @staticmethod - def build_select_forget(key: ConfigKey) -> Tuple[str, Dict]: - """构建遗忘配置查询语句，通过主键查询某条配置（PostgreSQL 命名参数） - - Args: - key: 配置键模型 - - Returns: - Tuple[str, Dict]: (SQL查询字符串, 参数字典) - """ - db_logger.debug(f"构建遗忘配置查询语句: config_id={key.config_id}") - - query = ( - f"SELECT lambda_time, lambda_mem, \"offset\" " # 用双引号包裹保留字别名 - f"FROM {TABLE_NAME} WHERE config_id = %(config_id)s" - ) - params = {"config_id": key.config_id} - return query, params - - @staticmethod - def build_select_all(workspace_id = None) -> Tuple[str, Dict]: - """构建查询所有配置参数的语句（PostgreSQL 命名参数） - - Args: - workspace_id: 工作空间ID（UUID或字符串），用于过滤查询结果 - - Returns: - Tuple[str, Dict]: (SQL查询字符串, 参数字典) - """ - db_logger.debug(f"构建查询所有配置语句: workspace_id={workspace_id}") - - if workspace_id: - # 将 UUID 转换为字符串以便在 SQL 中使用 - workspace_id_str = str(workspace_id) if workspace_id else None - query = f"SELECT * FROM {TABLE_NAME} WHERE workspace_id = %(workspace_id)s::uuid ORDER BY updated_at DESC NULLS LAST" - params = {"workspace_id": workspace_id_str} - else: - query = f"SELECT * FROM {TABLE_NAME} ORDER BY updated_at DESC NULLS LAST" - params = {} - return query, params - - @staticmethod - def build_delete(key: ConfigParamsDelete) -> Tuple[str, Dict]: - """构建删除语句，通过配置ID删除（PostgreSQL 命名参数） - - Args: - key: 配置删除模型 - - Returns: - Tuple[str, Dict]: (SQL查询字符串, 参数字典) - """ - db_logger.debug(f"构建删除语句: config_id={key.config_id}") - - query = ( - f"DELETE FROM {TABLE_NAME} WHERE config_id = %(config_id)s" - ) - params = {"config_id": key.config_id} - return query, params diff --git a/api/app/repositories/end_user_repository.py b/api/app/repositories/end_user_repository.py index 9005fda0..07e45a48 100644 --- a/api/app/repositories/end_user_repository.py +++ b/api/app/repositories/end_user_repository.py @@ -102,4 +102,40 @@ def get_end_user_by_id(db: Session, end_user_id: uuid.UUID) -> Optional[EndUser] """根据 end_user_id 查询对应宿主""" repo = EndUserRepository(db) end_user = repo.get_end_user_by_id(end_user_id) - return end_user \ No newline at end of file + return end_user + +def update_end_user_other_name( + db: Session, + end_user_id: uuid.UUID, + other_name: str +) -> int: + """ + 通过 end_user_id 更新 end_user 表中的 other_name 字段 + + Args: + db: 数据库会话 + end_user_id: 宿主ID + other_name: 要更新的用户名 + + Returns: + int: 更新的记录数 + """ + try: + # 执行更新 + updated_count = ( + db.query(EndUser) + .filter(EndUser.id == end_user_id) + .update( + {EndUser.other_name: other_name}, + synchronize_session=False + ) + ) + + db.commit() + db_logger.info(f"成功更新宿主 {end_user_id} 的 other_name 为: {other_name}") + return updated_count + + except Exception as e: + db.rollback() + db_logger.error(f"更新宿主 {end_user_id} 的 other_name 时出错: {str(e)}") + raise \ No newline at end of file diff --git a/api/app/repositories/model_repository.py b/api/app/repositories/model_repository.py index 20c1af40..f22b66ae 100644 --- a/api/app/repositories/model_repository.py +++ b/api/app/repositories/model_repository.py @@ -18,14 +18,25 @@ class ModelConfigRepository: """模型配置Repository""" @staticmethod - def get_by_id(db: Session, model_id: uuid.UUID) -> Optional[ModelConfig]: + def get_by_id(db: Session, model_id: uuid.UUID, tenant_id: uuid.UUID | None = None) -> Optional[ModelConfig]: """根据ID获取模型配置""" - db_logger.debug(f"根据ID查询模型配置: model_id={model_id}") + db_logger.debug(f"根据ID查询模型配置: model_id={model_id}, tenant_id={tenant_id}") try: - model = db.query(ModelConfig).options( + query = db.query(ModelConfig).options( joinedload(ModelConfig.api_keys) - ).filter(ModelConfig.id == model_id).first() + ).filter(ModelConfig.id == model_id) + + # 添加租户过滤 + if tenant_id: + query = query.filter( + or_( + ModelConfig.tenant_id == tenant_id, + ModelConfig.is_public == True + ) + ) + + model = query.first() if model: db_logger.debug(f"模型配置查询成功: {model.name} (ID: {model_id})") @@ -37,12 +48,23 @@ class ModelConfigRepository: raise @staticmethod - def get_by_name(db: Session, name: str) -> Optional[ModelConfig]: + def get_by_name(db: Session, name: str, tenant_id: uuid.UUID | None = None) -> Optional[ModelConfig]: """根据名称获取模型配置""" - db_logger.debug(f"根据名称查询模型配置: name={name}") + db_logger.debug(f"根据名称查询模型配置: name={name}, tenant_id={tenant_id}") try: - model = db.query(ModelConfig).filter(ModelConfig.name == name).first() + query = db.query(ModelConfig).filter(ModelConfig.name == name) + + # 添加租户过滤 + if tenant_id: + query = query.filter( + or_( + ModelConfig.tenant_id == tenant_id, + ModelConfig.is_public == True + ) + ) + + model = query.first() if model: db_logger.debug(f"模型配置查询成功: {model.name}") return model @@ -51,24 +73,30 @@ class ModelConfigRepository: raise @staticmethod - def search_by_name(db: Session, name: str, limit: int = 10) -> List[ModelConfig]: + def search_by_name(db: Session, name: str, tenant_id: uuid.UUID | None = None, limit: int = 10) -> List[ModelConfig]: """按名称模糊匹配获取模型配置列表 Args: name: 模型名称关键词（模糊匹配） + tenant_id: 租户ID limit: 返回数量上限 Returns: 模型配置列表 """ - db_logger.debug(f"按名称模糊查询模型配置: name~{name}, limit={limit}") + db_logger.debug(f"按名称模糊查询模型配置: name~{name}, tenant_id={tenant_id}, limit={limit}") try: - models = ( - db.query(ModelConfig) - .filter(ModelConfig.name.ilike(f"%{name}%")) - .order_by(ModelConfig.name) - .limit(limit) - .all() - ) + query = db.query(ModelConfig).filter(ModelConfig.name.ilike(f"%{name}%")) + + # 添加租户过滤 + if tenant_id: + query = query.filter( + or_( + ModelConfig.tenant_id == tenant_id, + ModelConfig.is_public == True + ) + ) + + models = query.order_by(ModelConfig.name).limit(limit).all() db_logger.debug(f"模糊查询成功: 返回数量={len(models)}") return models except Exception as e: @@ -76,14 +104,23 @@ class ModelConfigRepository: raise @staticmethod - def get_list(db: Session, query: ModelConfigQuery) -> Tuple[List[ModelConfig], int]: + def get_list(db: Session, query: ModelConfigQuery, tenant_id: uuid.UUID | None = None) -> Tuple[List[ModelConfig], int]: """获取模型配置列表""" - db_logger.debug(f"查询模型配置列表: {query.dict()}") + db_logger.debug(f"查询模型配置列表: {query.dict()}, tenant_id={tenant_id}") try: # 构建查询条件 filters = [] + # 添加租户过滤（查询本租户的模型或公开模型） + if tenant_id: + filters.append( + or_( + ModelConfig.tenant_id == tenant_id, + ModelConfig.is_public == True + ) + ) + # 支持多个 type 值（使用 IN 查询） if query.type: filters.append(ModelConfig.type.in_(query.type)) @@ -132,15 +169,24 @@ class ModelConfigRepository: raise @staticmethod - def get_by_type(db: Session, model_type: ModelType, is_active: bool = True) -> List[ModelConfig]: + def get_by_type(db: Session, model_type: ModelType, tenant_id: uuid.UUID | None = None, is_active: bool = True) -> List[ModelConfig]: """根据类型获取模型配置""" - db_logger.debug(f"根据类型查询模型配置: type={model_type}, is_active={is_active}") + db_logger.debug(f"根据类型查询模型配置: type={model_type}, tenant_id={tenant_id}, is_active={is_active}") try: query = db.query(ModelConfig).options( joinedload(ModelConfig.api_keys) ).filter(ModelConfig.type == model_type) + # 添加租户过滤 + if tenant_id: + query = query.filter( + or_( + ModelConfig.tenant_id == tenant_id, + ModelConfig.is_public == True + ) + ) + if is_active: query = query.filter(ModelConfig.is_active == True) @@ -170,14 +216,20 @@ class ModelConfigRepository: raise @staticmethod - def update(db: Session, model_id: uuid.UUID, model_data: ModelConfigUpdate) -> Optional[ModelConfig]: + def update(db: Session, model_id: uuid.UUID, model_data: ModelConfigUpdate, tenant_id: uuid.UUID | None = None) -> Optional[ModelConfig]: """更新模型配置""" - db_logger.debug(f"更新模型配置: model_id={model_id}") + db_logger.debug(f"更新模型配置: model_id={model_id}, tenant_id={tenant_id}") try: - db_model = db.query(ModelConfig).filter(ModelConfig.id == model_id).first() + query = db.query(ModelConfig).filter(ModelConfig.id == model_id) + + # 添加租户过滤（只能更新本租户的模型） + if tenant_id: + query = query.filter(ModelConfig.tenant_id == tenant_id) + + db_model = query.first() if not db_model: - db_logger.warning(f"模型配置不存在: model_id={model_id}") + db_logger.warning(f"模型配置不存在或无权限: model_id={model_id}") return None # 更新字段 @@ -197,20 +249,27 @@ class ModelConfigRepository: raise @staticmethod - def delete(db: Session, model_id: uuid.UUID) -> bool: + def delete(db: Session, model_id: uuid.UUID, tenant_id: uuid.UUID | None = None) -> bool: """删除模型配置""" - db_logger.debug(f"删除模型配置: model_id={model_id}") + db_logger.debug(f"删除模型配置: model_id={model_id}, tenant_id={tenant_id}") try: - db_model = db.query(ModelConfig).filter(ModelConfig.id == model_id).first() + query = db.query(ModelConfig).filter(ModelConfig.id == model_id) + + # 添加租户过滤（只能删除本租户的模型） + if tenant_id: + query = query.filter(ModelConfig.tenant_id == tenant_id) + + db_model = query.first() if not db_model: - db_logger.warning(f"模型配置不存在: model_id={model_id}") + db_logger.warning(f"模型配置不存在或无权限: model_id={model_id}") return False - db.delete(db_model) + # 逻辑删除模型配置 + db_model.is_active = False db.commit() - db_logger.info(f"模型配置删除成功: model_id={model_id}") + db_logger.info(f"模型配置删除成功（逻辑删除）: model_id={model_id}") return True except Exception as e: @@ -350,10 +409,11 @@ class ModelApiKeyRepository: db_logger.warning(f"API Key不存在: api_key_id={api_key_id}") return False - db.delete(db_api_key) + # 逻辑删除 API Key + db_api_key.is_active = False db.commit() - db_logger.info(f"API Key删除成功: api_key_id={api_key_id}") + db_logger.info(f"API Key删除成功（逻辑删除）: api_key_id={api_key_id}") return True except Exception as e: diff --git a/api/app/repositories/neo4j/add_edges.py b/api/app/repositories/neo4j/add_edges.py index 1d4c050b..3b45867e 100644 --- a/api/app/repositories/neo4j/add_edges.py +++ b/api/app/repositories/neo4j/add_edges.py @@ -27,7 +27,7 @@ async def add_chunk_statement_edges(chunks: List[Chunk], connector: Neo4jConnect edges: List[dict] = [] for chunk in chunks: for stmt in getattr(chunk, "statements", []) or []: - stable_edge_id = hashlib.sha1(f"{chunk.id}|{stmt.id}".encode("utf-8")).hexdigest() + stable_edge_id = hashlib.sha1(f"{chunk.id}|{stmt.id}".encode()).hexdigest() edge = { "id": stable_edge_id, "source": chunk.id, diff --git a/api/app/repositories/neo4j/base_neo4j_repository.py b/api/app/repositories/neo4j/base_neo4j_repository.py index 51a90078..959a1e68 100644 --- a/api/app/repositories/neo4j/base_neo4j_repository.py +++ b/api/app/repositories/neo4j/base_neo4j_repository.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """Neo4j仓储基类模块 本模块提供Neo4j仓储的基类实现，封装了通用的Neo4j节点操作。 @@ -57,9 +56,17 @@ class BaseNeo4jRepository(BaseRepository[T]): CREATE (n:{self.node_label} $props) RETURN n """ + # 使用model_dump()获取所有字段，包括aliases + props = entity.model_dump() + + # 确保aliases字段存在且为列表（针对ExtractedEntity节点） + if hasattr(entity, 'aliases'): + if props.get('aliases') is None: + props['aliases'] = [] + result = await self.connector.execute_query( query, - props=entity.model_dump() + props=props ) return entity @@ -97,10 +104,18 @@ class BaseNeo4jRepository(BaseRepository[T]): SET n += $props RETURN n """ + # 使用model_dump()获取所有字段，包括aliases + props = entity.model_dump() + + # 确保aliases字段存在且为列表（针对ExtractedEntity节点） + if hasattr(entity, 'aliases'): + if props.get('aliases') is None: + props['aliases'] = [] + await self.connector.execute_query( query, id=entity.id, - props=entity.model_dump() + props=props ) return entity @@ -142,7 +157,7 @@ class BaseNeo4jRepository(BaseRepository[T]): ... ) """ # 构建查询条件 - where_clauses = [f"n.{key} = ${key}" for key in filters.keys()] + where_clauses = [f"n.{key} = ${key}" for key in filters] where_str = " AND ".join(where_clauses) if where_clauses else "1=1" query = f""" diff --git a/api/app/repositories/neo4j/cypher_queries.py b/api/app/repositories/neo4j/cypher_queries.py index 1f9943f8..7330a00f 100644 --- a/api/app/repositories/neo4j/cypher_queries.py +++ b/api/app/repositories/neo4j/cypher_queries.py @@ -85,7 +85,11 @@ SET e.name = CASE WHEN entity.name IS NOT NULL AND entity.name <> '' THEN entity e.statement_id = CASE WHEN entity.statement_id IS NOT NULL AND entity.statement_id <> '' THEN entity.statement_id ELSE e.statement_id END, e.aliases = CASE WHEN entity.aliases IS NOT NULL AND size(entity.aliases) > 0 - THEN CASE WHEN e.aliases IS NULL THEN entity.aliases ELSE e.aliases + entity.aliases END + THEN CASE + WHEN e.aliases IS NULL THEN entity.aliases + ELSE reduce(acc = [], alias IN (e.aliases + entity.aliases) | + CASE WHEN alias IN acc THEN acc ELSE acc + alias END) + END ELSE e.aliases END, e.name_embedding = CASE WHEN entity.name_embedding IS NOT NULL AND size(entity.name_embedding) > 0 THEN entity.name_embedding @@ -682,3 +686,63 @@ SET r.group_id = e.group_id, r.expired_at = e.expired_at RETURN elementId(r) AS uuid """ + + +# Entity Merge Query +MERGE_ENTITIES = """ +MATCH (canonical:ExtractedEntity {id: $canonical_id}) +MATCH (losing:ExtractedEntity {id: $losing_id}) + +// 更新canonical实体的aliases +SET canonical.aliases = $merged_aliases + +// 转移所有从losing出发的关系到canonical +WITH canonical, losing +OPTIONAL MATCH (losing)-[r]->(target) +WHERE NOT (canonical)-[:RELATES_TO]->(target) +FOREACH (rel IN CASE WHEN r IS NOT NULL THEN [r] ELSE [] END | + CREATE (canonical)-[:RELATES_TO { + id: rel.id, + relation_type: rel.relation_type, + relation_value: rel.relation_value, + statement: rel.statement, + source_statement_id: rel.source_statement_id, + valid_at: rel.valid_at, + invalid_at: rel.invalid_at, + group_id: rel.group_id, + user_id: rel.user_id, + apply_id: rel.apply_id, + run_id: rel.run_id, + created_at: rel.created_at, + expired_at: rel.expired_at + }]->(target) +) + +// 转移所有指向losing的关系到canonical +WITH canonical, losing +OPTIONAL MATCH (source)-[r]->(losing) +WHERE NOT (source)-[:RELATES_TO]->(canonical) +FOREACH (rel IN CASE WHEN r IS NOT NULL THEN [r] ELSE [] END | + CREATE (source)-[:RELATES_TO { + id: rel.id, + relation_type: rel.relation_type, + relation_value: rel.relation_value, + statement: rel.statement, + source_statement_id: rel.source_statement_id, + valid_at: rel.valid_at, + invalid_at: rel.invalid_at, + group_id: rel.group_id, + user_id: rel.user_id, + apply_id: rel.apply_id, + run_id: rel.run_id, + created_at: rel.created_at, + expired_at: rel.expired_at + }]->(canonical) +) + +// 删除losing实体及其所有关系 +WITH losing +DETACH DELETE losing + +RETURN count(losing) as deleted +""" diff --git a/api/app/repositories/neo4j/entity_repository.py b/api/app/repositories/neo4j/entity_repository.py index ef2e5170..87088ade 100644 --- a/api/app/repositories/neo4j/entity_repository.py +++ b/api/app/repositories/neo4j/entity_repository.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """实体仓储模块 本模块提供实体节点的数据访问功能。 @@ -7,7 +6,7 @@ Classes: EntityRepository: 实体仓储，管理ExtractedEntityNode的CRUD操作 """ -from typing import List, Optional, Dict +from typing import List, Dict from datetime import datetime from app.repositories.neo4j.base_neo4j_repository import BaseNeo4jRepository @@ -49,9 +48,13 @@ class EntityRepository(BaseNeo4jRepository[ExtractedEntityNode]): # 处理datetime字段 if isinstance(n.get('created_at'), str): n['created_at'] = datetime.fromisoformat(n['created_at']) - if n.get('expired_at') and isinstance(n['expired_at'], str): + if n.get('expired_at') and isinstance(n.get('expired_at'), str): n['expired_at'] = datetime.fromisoformat(n['expired_at']) + # 确保aliases字段存在且为列表 + if 'aliases' not in n or n['aliases'] is None: + n['aliases'] = [] + return ExtractedEntityNode(**n) async def find_by_type(self, entity_type: str, limit: int = 100) -> List[ExtractedEntityNode]: @@ -66,274 +69,4 @@ class EntityRepository(BaseNeo4jRepository[ExtractedEntityNode]): """ return await self.find({"entity_type": entity_type}, limit=limit) - async def find_by_group_id(self, group_id: str, limit: int = 100) -> List[ExtractedEntityNode]: - """根据group_id查询实体 - - Args: - group_id: 组ID - limit: 返回结果的最大数量 - - Returns: - List[ExtractedEntityNode]: 实体列表 - """ - return await self.find({"group_id": group_id}, limit=limit) - - async def find_by_name( - self, - name: str, - group_id: Optional[str] = None, - limit: int = 100 - ) -> List[ExtractedEntityNode]: - """根据名称查询实体 - - 支持模糊匹配（CONTAINS）。 - - Args: - name: 实体名称 - group_id: 可选的组ID过滤 - limit: 返回结果的最大数量 - - Returns: - List[ExtractedEntityNode]: 实体列表 - """ - where_clause = "n.name CONTAINS $name" - if group_id: - where_clause += " AND n.group_id = $group_id" - - query = f""" - MATCH (n:{self.node_label}) - WHERE {where_clause} - RETURN n - LIMIT $limit - """ - - params = {"name": name, "limit": limit} - if group_id: - params["group_id"] = group_id - - results = await self.connector.execute_query(query, **params) - return [self._map_to_entity(r) for r in results] - - async def find_related_entities( - self, - entity_id: str, - relation_type: Optional[str] = None, - limit: int = 100 - ) -> List[ExtractedEntityNode]: - """查询相关实体 - - 查询与指定实体有关系的其他实体。 - - Args: - entity_id: 实体ID - relation_type: 可选的关系类型过滤 - limit: 返回结果的最大数量 - - Returns: - List[ExtractedEntityNode]: 相关实体列表 - """ - if relation_type: - query = """ - MATCH (e1:ExtractedEntity {id: $entity_id})-[r:RELATES_TO {relation_type: $relation_type}]->(e2:ExtractedEntity) - RETURN e2 as n - LIMIT $limit - """ - results = await self.connector.execute_query( - query, - entity_id=entity_id, - relation_type=relation_type, - limit=limit - ) - else: - query = """ - MATCH (e1:ExtractedEntity {id: $entity_id})-[r:RELATES_TO]->(e2:ExtractedEntity) - RETURN e2 as n - LIMIT $limit - """ - results = await self.connector.execute_query( - query, - entity_id=entity_id, - limit=limit - ) - - return [self._map_to_entity(r) for r in results] - - async def search_by_embedding( - self, - embedding: List[float], - group_id: Optional[str] = None, - limit: int = 10, - min_score: float = 0.7 - ) -> List[Dict]: - """基于向量相似度搜索实体 - - 使用余弦相似度计算查询向量与实体名称向量的相似度。 - - Args: - embedding: 查询向量 - group_id: 可选的组ID过滤 - limit: 返回结果的最大数量 - min_score: 最小相似度分数阈值 - - Returns: - List[Dict]: 包含实体和相似度分数的字典列表 - 每个字典包含: entity (ExtractedEntityNode), score (float) - """ - where_clause = "n.name_embedding IS NOT NULL" - if group_id: - where_clause += " AND n.group_id = $group_id" - - query = f""" - MATCH (n:{self.node_label}) - WHERE {where_clause} - WITH n, gds.similarity.cosine(n.name_embedding, $embedding) AS score - WHERE score > $min_score - RETURN n, score - ORDER BY score DESC - LIMIT $limit - """ - - params = { - "embedding": embedding, - "min_score": min_score, - "limit": limit - } - if group_id: - params["group_id"] = group_id - - results = await self.connector.execute_query(query, **params) - - return [ - { - "entity": self._map_to_entity(r), - "score": r.get("score", 0.0) - } - for r in results - ] - - async def find_by_statement_id(self, statement_id: str) -> List[ExtractedEntityNode]: - """根据陈述句ID查询实体 - - 查询从指定陈述句中提取的所有实体。 - - Args: - statement_id: 陈述句ID - - Returns: - List[ExtractedEntityNode]: 实体列表 - """ - return await self.find({"statement_id": statement_id}) - - async def find_strong_entities( - self, - group_id: str, - limit: int = 100 - ) -> List[ExtractedEntityNode]: - """查询强连接的实体 - - Args: - group_id: 组ID - limit: 返回结果的最大数量 - - Returns: - List[ExtractedEntityNode]: 强连接的实体列表 - """ - return await self.find( - {"group_id": group_id, "connect_strength": "Strong"}, - limit=limit - ) - - async def get_entity_count_by_type(self, group_id: str) -> Dict[str, int]: - """统计各类型实体的数量 - - Args: - group_id: 组ID - - Returns: - Dict[str, int]: 实体类型到数量的映射 - """ - query = """ - MATCH (n:ExtractedEntity {group_id: $group_id}) - RETURN n.entity_type as entity_type, count(n) as count - ORDER BY count DESC - """ - results = await self.connector.execute_query(query, group_id=group_id) - return {r["entity_type"]: r["count"] for r in results} - - async def find_by_config_id( - self, - config_id: str, - limit: int = 100 - ) -> List[ExtractedEntityNode]: - """根据config_id查询实体 - - Args: - config_id: 配置ID - limit: 返回结果的最大数量 - - Returns: - List[ExtractedEntityNode]: 实体列表 - """ - return await self.find({"config_id": config_id}, limit=limit) - - async def search_by_embedding_with_config( - self, - embedding: List[float], - config_id: Optional[str] = None, - group_id: Optional[str] = None, - limit: int = 10, - min_score: float = 0.7 - ) -> List[Dict]: - """基于向量相似度搜索实体,可选择按config_id过滤 - - 使用余弦相似度计算查询向量与实体名称向量的相似度。 - 支持按config_id过滤结果,确保只返回使用特定配置处理的实体。 - - Args: - embedding: 查询向量 - config_id: 可选的配置ID过滤 - group_id: 可选的组ID过滤 - limit: 返回结果的最大数量 - min_score: 最小相似度分数阈值 - - Returns: - List[Dict]: 包含实体和相似度分数的字典列表 - 每个字典包含: entity (ExtractedEntityNode), score (float) - """ - # 构建查询条件 - where_clauses = ["n.name_embedding IS NOT NULL"] - params = { - "embedding": embedding, - "min_score": min_score, - "limit": limit - } - - if config_id: - where_clauses.append("n.config_id = $config_id") - params["config_id"] = config_id - - if group_id: - where_clauses.append("n.group_id = $group_id") - params["group_id"] = group_id - - where_str = " AND ".join(where_clauses) - - query = f""" - MATCH (n:{self.node_label}) - WHERE {where_str} - WITH n, gds.similarity.cosine(n.name_embedding, $embedding) AS score - WHERE score > $min_score - RETURN n, score - ORDER BY score DESC - LIMIT $limit - """ - - results = await self.connector.execute_query(query, **params) - - return [ - { - "entity": self._map_to_entity(r), - "score": r.get("score", 0.0) - } - for r in results - ] + diff --git a/api/app/repositories/neo4j/statement_repository.py b/api/app/repositories/neo4j/statement_repository.py index 816bf06e..ec2d6660 100644 --- a/api/app/repositories/neo4j/statement_repository.py +++ b/api/app/repositories/neo4j/statement_repository.py @@ -7,7 +7,7 @@ Classes: StatementRepository: 陈述句仓储，管理StatementNode的CRUD操作 """ -from typing import List, Optional, Dict +from typing import List, Dict from datetime import datetime from app.repositories.neo4j.base_neo4j_repository import BaseNeo4jRepository @@ -76,244 +76,3 @@ class StatementRepository(BaseNeo4jRepository[StatementNode]): List[StatementNode]: 陈述句列表 """ return await self.find({"chunk_id": chunk_id}) - - async def find_by_group_id(self, group_id: str, limit: int = 100) -> List[StatementNode]: - """根据group_id查询陈述句 - - Args: - group_id: 组ID - limit: 返回结果的最大数量 - - Returns: - List[StatementNode]: 陈述句列表 - """ - return await self.find({"group_id": group_id}, limit=limit) - - async def search_by_embedding( - self, - embedding: List[float], - group_id: Optional[str] = None, - limit: int = 10, - min_score: float = 0.7 - ) -> List[Dict]: - """基于向量相似度搜索陈述句 - - 使用余弦相似度计算查询向量与陈述句向量的相似度。 - - Args: - embedding: 查询向量 - group_id: 可选的组ID过滤 - limit: 返回结果的最大数量 - min_score: 最小相似度分数阈值 - - Returns: - List[Dict]: 包含陈述句和相似度分数的字典列表 - 每个字典包含: statement (StatementNode), score (float) - """ - # 构建查询条件 - where_clause = "n.statement_embedding IS NOT NULL" - if group_id: - where_clause += " AND n.group_id = $group_id" - - query = f""" - MATCH (n:{self.node_label}) - WHERE {where_clause} - WITH n, gds.similarity.cosine(n.statement_embedding, $embedding) AS score - WHERE score > $min_score - RETURN n, score - ORDER BY score DESC - LIMIT $limit - """ - - params = { - "embedding": embedding, - "min_score": min_score, - "limit": limit - } - if group_id: - params["group_id"] = group_id - - results = await self.connector.execute_query(query, **params) - - return [ - { - "statement": self._map_to_entity(r), - "score": r.get("score", 0.0) - } - for r in results - ] - - async def search_by_keyword( - self, - keyword: str, - group_id: Optional[str] = None, - limit: int = 50 - ) -> List[StatementNode]: - """基于关键词搜索陈述句 - - Args: - keyword: 搜索关键词 - group_id: 可选的组ID过滤 - limit: 返回结果的最大数量 - - Returns: - List[StatementNode]: 陈述句列表 - """ - where_clause = "n.statement CONTAINS $keyword" - if group_id: - where_clause += " AND n.group_id = $group_id" - - query = f""" - MATCH (n:{self.node_label}) - WHERE {where_clause} - RETURN n - LIMIT $limit - """ - - params = {"keyword": keyword, "limit": limit} - if group_id: - params["group_id"] = group_id - - results = await self.connector.execute_query(query, **params) - return [self._map_to_entity(r) for r in results] - - async def find_by_temporal_range( - self, - group_id: str, - start_date: Optional[datetime] = None, - end_date: Optional[datetime] = None, - limit: int = 100 - ) -> List[StatementNode]: - """根据时间范围查询陈述句 - - 查询在指定时间范围内有效的陈述句。 - - Args: - group_id: 组ID - start_date: 开始日期（可选） - end_date: 结束日期（可选） - limit: 返回结果的最大数量 - - Returns: - List[StatementNode]: 陈述句列表 - """ - where_clauses = ["n.group_id = $group_id"] - params = {"group_id": group_id, "limit": limit} - - if start_date: - where_clauses.append("n.valid_at >= $start_date") - params["start_date"] = start_date.isoformat() - - if end_date: - where_clauses.append("(n.invalid_at IS NULL OR n.invalid_at <= $end_date)") - params["end_date"] = end_date.isoformat() - - where_str = " AND ".join(where_clauses) - - query = f""" - MATCH (n:{self.node_label}) - WHERE {where_str} - RETURN n - ORDER BY n.created_at DESC - LIMIT $limit - """ - - results = await self.connector.execute_query(query, **params) - return [self._map_to_entity(r) for r in results] - - async def find_strong_statements( - self, - group_id: str, - limit: int = 100 - ) -> List[StatementNode]: - """查询强连接的陈述句 - - Args: - group_id: 组ID - limit: 返回结果的最大数量 - - Returns: - List[StatementNode]: 强连接的陈述句列表 - """ - return await self.find( - {"group_id": group_id, "connect_strength": "Strong"}, - limit=limit - ) - - async def find_by_config_id( - self, - config_id: str, - limit: int = 100 - ) -> List[StatementNode]: - """根据config_id查询陈述句 - - Args: - config_id: 配置ID - limit: 返回结果的最大数量 - - Returns: - List[StatementNode]: 陈述句列表 - """ - return await self.find({"config_id": config_id}, limit=limit) - - async def search_by_embedding_with_config( - self, - embedding: List[float], - config_id: Optional[str] = None, - group_id: Optional[str] = None, - limit: int = 10, - min_score: float = 0.7 - ) -> List[Dict]: - """基于向量相似度搜索陈述句,可选择按config_id过滤 - - 使用余弦相似度计算查询向量与陈述句向量的相似度。 - 支持按config_id过滤结果,确保只返回使用特定配置处理的陈述句。 - - Args: - embedding: 查询向量 - config_id: 可选的配置ID过滤 - group_id: 可选的组ID过滤 - limit: 返回结果的最大数量 - min_score: 最小相似度分数阈值 - - Returns: - List[Dict]: 包含陈述句和相似度分数的字典列表 - 每个字典包含: statement (StatementNode), score (float) - """ - # 构建查询条件 - where_clauses = ["n.statement_embedding IS NOT NULL"] - params = { - "embedding": embedding, - "min_score": min_score, - "limit": limit - } - - if config_id: - where_clauses.append("n.config_id = $config_id") - params["config_id"] = config_id - - if group_id: - where_clauses.append("n.group_id = $group_id") - params["group_id"] = group_id - - where_str = " AND ".join(where_clauses) - - query = f""" - MATCH (n:{self.node_label}) - WHERE {where_str} - WITH n, gds.similarity.cosine(n.statement_embedding, $embedding) AS score - WHERE score > $min_score - RETURN n, score - ORDER BY score DESC - LIMIT $limit - """ - - results = await self.connector.execute_query(query, **params) - - return [ - { - "statement": self._map_to_entity(r), - "score": r.get("score", 0.0) - } - for r in results - ] diff --git a/api/app/repositories/tenant_repository.py b/api/app/repositories/tenant_repository.py index 97e422bd..2934dda3 100644 --- a/api/app/repositories/tenant_repository.py +++ b/api/app/repositories/tenant_repository.py @@ -91,12 +91,13 @@ class TenantRepository: return db_tenant def delete_tenant(self, tenant_id: uuid.UUID) -> bool: - """删除租户""" + """逻辑删除租户""" db_tenant = self.get_tenant_by_id(tenant_id) if not db_tenant: return False - self.db.delete(db_tenant) + # 逻辑删除租户 + db_tenant.is_active = False return True def get_tenant_users(self, tenant_id: uuid.UUID, is_active: Optional[bool] = None) -> List[User]: diff --git a/api/app/repositories/user_repository.py b/api/app/repositories/user_repository.py index ffdd6ec1..a43c5869 100644 --- a/api/app/repositories/user_repository.py +++ b/api/app/repositories/user_repository.py @@ -144,9 +144,10 @@ class UserRepository: db_logger.debug(f"用户不存在: user_id={user_id}") return False - self.db.delete(user) + # 逻辑删除用户 + user.is_active = False self.db.flush() - db_logger.info(f"用户删除成功: {user.username}") + db_logger.info(f"用户删除成功（逻辑删除）: {user.username}") return True except Exception as e: db_logger.error(f"删除用户失败: user_id={user_id} - {str(e)}") diff --git a/api/app/schemas/api_key_schema.py b/api/app/schemas/api_key_schema.py index 36c0d457..8c0a1031 100644 --- a/api/app/schemas/api_key_schema.py +++ b/api/app/schemas/api_key_schema.py @@ -1,10 +1,11 @@ """API Key Schema""" -from pydantic import BaseModel, Field, ConfigDict -from typing import Optional, List import datetime import uuid +from pydantic import BaseModel, Field, ConfigDict +from pydantic.v1 import validator +from typing import Optional, List -from app.models.api_key_model import ApiKeyType +from app.models.api_key_model import ApiKeyType, ResourceType class ApiKeyCreate(BaseModel): @@ -14,27 +15,55 @@ class ApiKeyCreate(BaseModel): type: ApiKeyType = Field(..., description="API Key 类型") scopes: List[str] = Field(default_factory=list, description="权限范围列表") resource_id: Optional[uuid.UUID] = Field(None, description="关联资源ID") - resource_type: Optional[str] = Field(None, description="资源类型") - rate_limit: Optional[int] = Field(100, description="速率限制（请求/分钟）", ge=1) + resource_type: Optional[ResourceType] = Field(None, description="资源类型") + rate_limit: Optional[int] = Field(10, ge=1, le=1000, description="QPS限制（请求/秒）") + daily_request_limit: Optional[int] = Field(10000, description="日请求限制", ge=1) quota_limit: Optional[int] = Field(None, description="配额限制（总请求数）", ge=1) expires_at: Optional[datetime.datetime] = Field(None, description="过期时间") + @validator('scopes') + def validate_scopes(cls, v): + """验证权限范围格式""" + valid_scopes = [ + "app:all", + "rag:search", "rag:upload", "rag:delete", + "memory:read", "memory:write", "memory:delete", "memory:search" + ] + for scope in v: + if scope not in valid_scopes: + raise ValueError(f"无效范围: {scope}") + return v + class ApiKeyUpdate(BaseModel): - """更新 API Key""" + """更新 API Key配置""" name: Optional[str] = Field(None, description="API Key 名称", max_length=255) description: Optional[str] = Field(None, description="描述") scopes: Optional[List[str]] = Field(None, description="权限范围列表") rate_limit: Optional[int] = Field(None, description="速率限制（请求/分钟）", ge=1) + daily_request_limit: Optional[int] = Field(10000, description="每日请求数限制", ge=1) quota_limit: Optional[int] = Field(None, description="配额限制（总请求数）", ge=1) is_active: Optional[bool] = Field(None, description="是否激活") expires_at: Optional[datetime.datetime] = Field(None, description="过期时间") + @validator('scopes') + def validate_scopes(cls, v): + """验证权限范围格式""" + valid_scopes = { + 'app:all', + 'rag:search', 'rag:upload', 'rag:delete', + 'memory:read', 'memory:write', 'memory:delete', 'memory:search' + } + for scope in v: + if scope not in valid_scopes: + raise ValueError(f"无效范围: {scope}") + return v + class ApiKeyResponse(BaseModel): """API Key 响应（创建时返回，包含明文 Key）""" model_config = ConfigDict(from_attributes=True) - + id: uuid.UUID name: str description: Optional[str] @@ -45,6 +74,7 @@ class ApiKeyResponse(BaseModel): resource_id: Optional[uuid.UUID] resource_type: Optional[str] rate_limit: int + daily_request_limit: int quota_limit: Optional[int] expires_at: Optional[datetime.datetime] created_at: datetime.datetime @@ -53,7 +83,7 @@ class ApiKeyResponse(BaseModel): class ApiKey(BaseModel): """API Key 信息（不包含明文 Key）""" model_config = ConfigDict(from_attributes=True) - + id: uuid.UUID name: str description: Optional[str] @@ -63,6 +93,7 @@ class ApiKey(BaseModel): resource_id: Optional[uuid.UUID] resource_type: Optional[str] rate_limit: int + daily_request_limit: int quota_limit: Optional[int] quota_used: int expires_at: Optional[datetime.datetime] @@ -102,3 +133,27 @@ class ApiKeyAuth(BaseModel): scopes: List[str] resource_id: Optional[uuid.UUID] resource_type: Optional[str] + + +class ApiKeyLog(BaseModel): + """API Key 使用日志""" + model_config = ConfigDict(from_attributes=True) + + id: uuid.UUID + api_key_id: uuid.UUID + + # 请求信息 + endpoint: str + method: str + ip_address: Optional[str] + user_agent: Optional[str] + + # 响应信息 + status_code: Optional[int] + response_time: Optional[int] # 毫秒 + + # 业务信息 + tokens_used: Optional[int] + + # 时间信息 + created_at: datetime.datetime diff --git a/api/app/schemas/chunk_schema.py b/api/app/schemas/chunk_schema.py index cda7ed94..c38fe765 100644 --- a/api/app/schemas/chunk_schema.py +++ b/api/app/schemas/chunk_schema.py @@ -1,6 +1,8 @@ from pydantic import BaseModel, Field import uuid from enum import StrEnum +from app.core.rag.models.chunk import QAChunk +from typing import Union class RetrieveType(StrEnum): @@ -9,12 +11,35 @@ class RetrieveType(StrEnum): SEMANTIC = "semantic" HYBRID = "hybrid" + class ChunkCreate(BaseModel): - content: str + content: Union[str, QAChunk] = Field( + description="Content can be either a string or a QAChunk object" + ) + + @property + def chunk_content(self) -> str: + """ + Get the actual content string regardless of input type + """ + if isinstance(self.content, QAChunk): + return f"question: {self.content.question} answer: {self.content.answer}" + return self.content class ChunkUpdate(BaseModel): - content: str | None = Field(None) + content: Union[str, QAChunk] = Field( + description="Content can be either a string or a QAChunk object" + ) + + @property + def chunk_content(self) -> str: + """ + Get the actual content string regardless of input type + """ + if isinstance(self.content, QAChunk): + return f"question: {self.content.question} answer: {self.content.answer}" + return self.content class ChunkRetrieve(BaseModel): @@ -23,4 +48,4 @@ class ChunkRetrieve(BaseModel): similarity_threshold: float | None = Field(None) vector_similarity_weight: float | None = Field(None) top_k: int | None = Field(None) - retrieve_type: RetrieveType | None = Field(None) \ No newline at end of file + retrieve_type: RetrieveType | None = Field(None) diff --git a/api/app/schemas/memory_agent_schema.py b/api/app/schemas/memory_agent_schema.py index e7c17407..47dc6b2a 100644 --- a/api/app/schemas/memory_agent_schema.py +++ b/api/app/schemas/memory_agent_schema.py @@ -15,3 +15,7 @@ class Write_UserInput(BaseModel): message: str group_id: str config_id: Optional[str] = None + +class End_User_Information(BaseModel): + end_user_name: str # 这是要更新的用户名 + id: str # 宿主ID，用于匹配条件 diff --git a/api/app/schemas/multi_agent_schema.py b/api/app/schemas/multi_agent_schema.py index a1547167..86bd8e00 100644 --- a/api/app/schemas/multi_agent_schema.py +++ b/api/app/schemas/multi_agent_schema.py @@ -30,6 +30,31 @@ class ExecutionConfig(BaseModel): parallel_limit: int = Field(default=3, ge=1, le=10, description="并行限制") retry_on_failure: bool = Field(default=True, description="失败时是否重试") max_retries: int = Field(default=3, ge=0, le=10, description="最大重试次数") + + # 新增：路由模式配置 + routing_mode: str = Field( + default="master_agent", + pattern="^(master_agent|llm_router|rule_only)$", + description="路由模式：master_agent（Master Agent决策）| llm_router（旧LLM路由器）| rule_only（仅规则路由）" + ) + enable_rule_fast_path: bool = Field( + default=True, + description="是否启用规则快速路径（性能优化，高置信度关键词直接返回）" + ) + + # 新增：结果整合模式配置 + result_merge_mode: str = Field( + default="smart", + pattern="^(smart|master)$", + description="结果整合模式：smart（规则去重，快速）| master（Master Agent 智能整合，连贯）" + ) + + # 新增：子 Agent 执行模式配置 + sub_agent_execution_mode: str = Field( + default="parallel", + pattern="^(parallel|sequential)$", + description="子 Agent 执行模式：parallel（并行执行，快速）| sequential（串行执行，节省资源）" + ) # ==================== 多 Agent 配置 ==================== diff --git a/api/app/schemas/user_schema.py b/api/app/schemas/user_schema.py index 97006370..60f52aaf 100644 --- a/api/app/schemas/user_schema.py +++ b/api/app/schemas/user_schema.py @@ -65,6 +65,7 @@ class User(UserBase): model_config = ConfigDict(from_attributes=True) @field_validator("last_login_at", mode="before") + @classmethod def _last_login_to_ms(cls, v): if v is None: return None diff --git a/api/app/services/agent_registry.py b/api/app/services/agent_registry.py index 999d018b..2b6d92e3 100644 --- a/api/app/services/agent_registry.py +++ b/api/app/services/agent_registry.py @@ -27,7 +27,7 @@ class AgentRegistry: self._cache[str(agent.id)] = agent_info logger.info( - f"Agent 注册成功", + "Agent 注册成功", extra={ "agent_id": str(agent.id), "name": agent.app.name, @@ -92,7 +92,7 @@ class AgentRegistry: agents = self.db.scalars(stmt).all() logger.debug( - f"Agent 发现", + "Agent 发现", extra={ "query": query, "domain": domain, diff --git a/api/app/services/agent_server.py b/api/app/services/agent_server.py deleted file mode 100644 index 65d763fd..00000000 --- a/api/app/services/agent_server.py +++ /dev/null @@ -1,130 +0,0 @@ - - -from typing import Any, List - -from langchain_openai import ChatOpenAI -from langgraph.checkpoint.memory import InMemorySaver -from pydantic import BaseModel - -from langchain.agents import create_agent, AgentState -from langchain.agents.middleware import before_model -from langchain.tools import tool -from langchain_core.messages import RemoveMessage -from langgraph.graph.message import REMOVE_ALL_MESSAGES -from langgraph.runtime import Runtime - -from app.services.api_resquests_server import send_message, model, retrieval - - -class config(BaseModel): - template_str:str - params:dict - model_configs: List[dict] = [] - history_memory:bool - knowledge_base:bool - -class RemoryInput(BaseModel): - question: str - end_user_id: str - search_switch:str - -class ChatRequest(BaseModel): - end_user_id: str - message: str - search_switch:str - kb_ids: List[str] = [] - similarity_threshold:float - vector_similarity_weight:float - top_k:int - hybrid:bool - token:str - -class RetrievalInput(BaseModel): - message: str - kb_ids: List[str] = [] - similarity_threshold: float - vector_similarity_weight: float - top_k: int - hybrid: bool - token: str - -async def tool_Retrieval(req): - tool_result = retrieval_search.invoke({ - "message":req.message, "kb_ids":req.kb_ids, - "similarity_threshold":req.similarity_threshold, "vector_similarity_weight":req.vector_similarity_weight, - "top_k":req.top_k, "hybrid":req.hybrid, "token":req.token - }) - return tool_result -async def tool_memory(req): - tool_result = remory_sk.invoke({ - "question": req.message, - "end_user_id": req.end_user_id, - "search_switch": req.search_switch - }) - return tool_result - - -@before_model -# ========== 消息剪枝中间件 ========== -def trim_messages(state: AgentState, runtime: Runtime) -> dict[str, Any] | None: - """保留前1条 + 最近3~4条消息""" - messages = state["messages"] - if len(messages) <= 10: - return None - first_msg = messages[0] - recent_messages = messages[-10:] if len(messages) % 2 == 0 else messages[-11:] - new_messages = [first_msg] + recent_messages - - return { - "messages": [ - RemoveMessage(id=REMOVE_ALL_MESSAGES), - *new_messages - ] - } - -##-----------历史记忆------------ -@ tool(args_schema=RemoryInput) -def remory_sk(question: str, end_user_id: str, search_switch: str): - """ - 条件调用工具： - - 仅当 question 是疑问句时调用 send_message - - 根据 end_user_id 和 search_switch 参数决定是否执行检索 - - Args: - question: 用户的提问内容 - end_user_id: 用户唯一标识符 - search_switch: 搜索开关，控制是否执行检索 - - Returns: - 检索结果或空字符串 - """ - # 移除关于 configurable 的描述，避免混淆 - if not end_user_id or end_user_id == '123': - print("警告: 无效的 user_id 参数") - return '' - - if search_switch in ['on', 'off'] or not search_switch: - print("警告: 无效的 search_switch 参数") - return '' - return send_message(end_user_id, question, '[]', search_switch) - -#-------------检索------------ - - -@ tool(args_schema=RetrievalInput) -def retrieval_search(message,kb_ids,similarity_threshold,vector_similarity_weight,top_k,hybrid,token): - '''检索''' - search=retrieval(message,kb_ids,similarity_threshold,vector_similarity_weight,top_k,hybrid,token) - return search -async def create_dynamic_agent(model_name: str,model_id:str,PROMPT:str,token:str): - """根据模型名动态创建代理""" - model_name, api_key, api_base=await model(model_id,token) - llm = ChatOpenAI(model=model_name, base_url=api_base, temperature=0.2,api_key=api_key) - memory = InMemorySaver() - return create_agent( - llm, - tools=[remory_sk,retrieval_search], - middleware=[trim_messages], - checkpointer=memory, - system_prompt=PROMPT - ) \ No newline at end of file diff --git a/api/app/services/agent_tools.py b/api/app/services/agent_tools.py index 96032b7d..4c011a87 100644 --- a/api/app/services/agent_tools.py +++ b/api/app/services/agent_tools.py @@ -80,7 +80,7 @@ def create_agent_discovery_tool(registry: AgentRegistry, workspace_id: uuid.UUID result += "\n" logger.info( - f"Agent 发现成功", + "Agent 发现成功", extra={ "query": query, "domain": domain, @@ -91,7 +91,7 @@ def create_agent_discovery_tool(registry: AgentRegistry, workspace_id: uuid.UUID return result except Exception as e: - logger.error(f"Agent 发现失败", extra={"error": str(e)}) + logger.error("Agent 发现失败", extra={"error": str(e)}) return f"发现 Agent 失败: {str(e)}" return discover_agents @@ -138,7 +138,7 @@ def create_agent_invocation_tool( if workspace and workspace.storage_type: storage_type = workspace.storage_type logger.debug( - f"获取工作空间存储类型成功", + "获取工作空间存储类型成功", extra={ "workspace_id": str(workspace_id), "storage_type": storage_type @@ -146,7 +146,7 @@ def create_agent_invocation_tool( ) except Exception as e: logger.warning( - f"获取工作空间存储类型失败，使用默认值 neo4j", + "获取工作空间存储类型失败，使用默认值 neo4j", extra={"workspace_id": str(workspace_id), "error": str(e)} ) @@ -161,7 +161,7 @@ def create_agent_invocation_tool( if knowledge: user_rag_memory_id = str(knowledge.id) logger.debug( - f"获取 RAG 知识库成功", + "获取 RAG 知识库成功", extra={ "workspace_id": str(workspace_id), "knowledge_id": user_rag_memory_id @@ -169,13 +169,13 @@ def create_agent_invocation_tool( ) else: logger.warning( - f"未找到名为 'USER_RAG_MEMORY' 的知识库，将使用 neo4j 存储", + "未找到名为 'USER_RAG_MEMORY' 的知识库，将使用 neo4j 存储", extra={"workspace_id": str(workspace_id)} ) storage_type = 'neo4j' except Exception as e: logger.warning( - f"获取 RAG 知识库失败，将使用 neo4j 存储", + "获取 RAG 知识库失败，将使用 neo4j 存储", extra={"workspace_id": str(workspace_id), "error": str(e)} ) storage_type = 'neo4j' @@ -226,12 +226,12 @@ def create_agent_invocation_tool( # 6. 获取 Agent 配置 agent_config = db.get(AgentConfig, agent_uuid) if not agent_config: - return f"Agent 配置不存在" + return "Agent 配置不存在" # 7. 获取模型配置 model_config = db.get(ModelConfig, agent_config.default_model_config_id) if not model_config: - return f"Agent 模型配置不存在" + return "Agent 模型配置不存在" # 8. 创建调用记录 invocation = AgentInvocation( @@ -249,7 +249,7 @@ def create_agent_invocation_tool( db.refresh(invocation) logger.info( - f"Agent 调用开始", + "Agent 调用开始", extra={ "invocation_id": str(invocation.id), "caller_agent_id": str(current_agent_id), @@ -286,7 +286,7 @@ def create_agent_invocation_tool( db.commit() logger.info( - f"Agent 调用成功", + "Agent 调用成功", extra={ "invocation_id": str(invocation.id), "caller_agent_id": str(current_agent_id), @@ -306,7 +306,7 @@ def create_agent_invocation_tool( db.commit() logger.error( - f"Agent 调用失败", + "Agent 调用失败", extra={ "invocation_id": str(invocation.id), "caller_agent_id": str(current_agent_id), @@ -319,7 +319,7 @@ def create_agent_invocation_tool( except Exception as e: logger.error( - f"Agent 调用异常", + "Agent 调用异常", extra={ "caller_agent_id": str(current_agent_id), "callee_agent_id": agent_id, diff --git a/api/app/services/api_key_service.py b/api/app/services/api_key_service.py index 6deac112..53615e7e 100644 --- a/api/app/services/api_key_service.py +++ b/api/app/services/api_key_service.py @@ -1,16 +1,22 @@ """API Key Service""" -from sqlalchemy.orm import Session -from typing import Optional, Tuple, List +import time import uuid -import datetime import math +from typing import Optional, Tuple +from datetime import datetime, timedelta -from app.models.api_key_model import ApiKey, ApiKeyType -from app.repositories.api_key_repository import ApiKeyRepository +from sqlalchemy.orm import Session +from sqlalchemy import select + +from app.aioRedis import aio_redis +from app.models.api_key_model import ApiKey +from app.repositories.api_key_repository import ApiKeyRepository, ApiKeyLogRepository from app.schemas import api_key_schema from app.schemas.response_schema import PageData, PageMeta -from app.core.api_key_utils import generate_api_key -from app.core.exceptions import BusinessException +from app.core.api_key_utils import generate_api_key, hash_api_key, validate_resource_binding +from app.core.exceptions import ( + BusinessException, +) from app.core.error_codes import BizCode from app.core.logging_config import get_business_logger @@ -19,81 +25,108 @@ logger = get_business_logger() class ApiKeyService: """API Key 业务逻辑服务""" - + @staticmethod def create_api_key( - db: Session, - *, - workspace_id: uuid.UUID, - user_id: uuid.UUID, - data: api_key_schema.ApiKeyCreate + db: Session, + *, + workspace_id: uuid.UUID, + user_id: uuid.UUID, + data: api_key_schema.ApiKeyCreate ) -> Tuple[ApiKey, str]: - """创建 API Key - + """ + 创建 API Key Returns: Tuple[ApiKey, str]: (API Key 对象, API Key 明文) """ - # 生成 API Key - api_key, key_hash, key_prefix = generate_api_key(data.type) - - # 创建数据 - api_key_data = { - "id": uuid.uuid4(), - "name": data.name, - "description": data.description, - "key_prefix": key_prefix, - "key_hash": key_hash, - "type": data.type, - "scopes": data.scopes, - "workspace_id": workspace_id, - "resource_id": data.resource_id, - "resource_type": data.resource_type, - "rate_limit": data.rate_limit, - "quota_limit": data.quota_limit, - "expires_at": data.expires_at, - "created_by": user_id, - "created_at": datetime.datetime.now(), - "updated_at": datetime.datetime.now(), - } - - api_key_obj = ApiKeyRepository.create(db, api_key_data) - db.commit() - db.refresh(api_key_obj) - - logger.info(f"API Key 创建成功", extra={ - "api_key_id": str(api_key_obj.id), - "name": data.name, - "type": data.type - }) - - return api_key_obj, api_key - + try: + # 验证资源绑定 + if data.resource_type or data.resource_id: + is_valid, error_msg = validate_resource_binding( + data.resource_type, str(data.resource_id) if data.resource_id else None + ) + if not is_valid: + raise BusinessException(error_msg, BizCode.API_KEY_INVALID_RESOURCE) + + existing = db.scalar( + select(ApiKey).where( + ApiKey.workspace_id == workspace_id, + ApiKey.name == data.name, + ApiKey.is_active + ) + ) + if existing: + raise BusinessException(f"API Key 名称 '{data.name}' 已存在", BizCode.API_KEY_DUPLICATE_NAME) + + # 生成 API Key + api_key, key_hash, key_prefix = generate_api_key(data.type) + + # 创建数据 + api_key_data = { + "id": uuid.uuid4(), + "name": data.name, + "description": data.description, + "key_prefix": key_prefix, + "key_hash": key_hash, + "type": data.type, + "scopes": data.scopes, + "workspace_id": workspace_id, + "resource_id": data.resource_id, + "resource_type": data.resource_type, + "rate_limit": data.rate_limit or 10, + "daily_request_limit": data.daily_request_limit or 10000, + "quota_limit": data.quota_limit, + "expires_at": data.expires_at, + "created_by": user_id, + } + + api_key_obj = ApiKeyRepository.create(db, api_key_data) + db.commit() + + logger.info("API Key 创建成功", extra={ + "api_key_id": str(api_key_obj.id), + "workspace_id": str(workspace_id), + "api_key_name": data.name, + "type": data.type + }) + + return api_key_obj, api_key + + except Exception as e: + db.rollback() + logger.error(f"API Key 创建失败: {e}", extra={ + "workspace_id": str(workspace_id), + "api_key_name": getattr(data, 'name', 'unknown'), + "error": str(e) + }) + raise + @staticmethod def get_api_key( - db: Session, - api_key_id: uuid.UUID, - workspace_id: uuid.UUID + db: Session, + api_key_id: uuid.UUID, + workspace_id: uuid.UUID ) -> ApiKey: """获取 API Key""" api_key = ApiKeyRepository.get_by_id(db, api_key_id) if not api_key: - raise BusinessException("API Key 不存在", BizCode.NOT_FOUND) - + raise BusinessException(f"API Key {api_key_id} 不存在", BizCode.API_KEY_NOT_FOUND) + if api_key.workspace_id != workspace_id: raise BusinessException("无权访问此 API Key", BizCode.FORBIDDEN) - + return api_key - + @staticmethod def list_api_keys( - db: Session, - workspace_id: uuid.UUID, - query: api_key_schema.ApiKeyQuery + db: Session, + workspace_id: uuid.UUID, + query: api_key_schema.ApiKeyQuery ) -> PageData: """列出 API Keys""" items, total = ApiKeyRepository.list_by_workspace(db, workspace_id, query) pages = math.ceil(total / query.pagesize) if total > 0 else 0 - + return PageData( page=PageMeta( page=query.page, @@ -103,52 +136,69 @@ class ApiKeyService: ), items=[api_key_schema.ApiKey.model_validate(item) for item in items] ) - + @staticmethod def update_api_key( - db: Session, - api_key_id: uuid.UUID, - workspace_id: uuid.UUID, - data: api_key_schema.ApiKeyUpdate + db: Session, + api_key_id: uuid.UUID, + workspace_id: uuid.UUID, + data: api_key_schema.ApiKeyUpdate ) -> ApiKey: - """更新 API Key""" + """更新 API Key配置""" api_key = ApiKeyService.get_api_key(db, api_key_id, workspace_id) - + + # 检查名称重复 + if data.name and data.name != api_key.name: + existing = db.scalar( + select(ApiKey).where( + ApiKey.workspace_id == workspace_id, + ApiKey.name == data.name, + ApiKey.is_active, + ApiKey.id != api_key_id + ) + ) + if existing: + raise BusinessException(f"API Key 名称 '{data.name}' 已存在", BizCode.API_KEY_DUPLICATE_NAME) + update_data = data.model_dump(exclude_unset=True) ApiKeyRepository.update(db, api_key_id, update_data) db.commit() db.refresh(api_key) - - logger.info(f"API Key 更新成功", extra={"api_key_id": str(api_key_id)}) + + logger.info("API Key 更新成功", extra={"api_key_id": str(api_key_id)}) return api_key - + @staticmethod def delete_api_key( - db: Session, - api_key_id: uuid.UUID, - workspace_id: uuid.UUID + db: Session, + api_key_id: uuid.UUID, + workspace_id: uuid.UUID ) -> bool: """删除 API Key""" api_key = ApiKeyService.get_api_key(db, api_key_id, workspace_id) - + ApiKeyRepository.delete(db, api_key_id) db.commit() - - logger.info(f"API Key 删除成功", extra={"api_key_id": str(api_key_id)}) + + logger.info("API Key 删除成功", extra={"api_key_id": str(api_key_id)}) return True - + @staticmethod def regenerate_api_key( - db: Session, - api_key_id: uuid.UUID, - workspace_id: uuid.UUID + db: Session, + api_key_id: uuid.UUID, + workspace_id: uuid.UUID ) -> Tuple[ApiKey, str]: """重新生成 API Key""" api_key = ApiKeyService.get_api_key(db, api_key_id, workspace_id) - + + # 检查 API Key 是否激活 + if not api_key.is_active: + raise BusinessException("无法重新生成已停用的 API Key", BizCode.API_KEY_INACTIVE) + # 生成新的 API Key - new_api_key, key_hash, key_prefix = generate_api_key(ApiKeyType(api_key.type)) - + new_api_key, key_hash, key_prefix = generate_api_key(api_key_schema.ApiKeyType(api_key.type)) + # 更新 ApiKeyRepository.update(db, api_key_id, { "key_hash": key_hash, @@ -156,18 +206,201 @@ class ApiKeyService: }) db.commit() db.refresh(api_key) - - logger.info(f"API Key 重新生成成功", extra={"api_key_id": str(api_key_id)}) + + logger.info("API Key 重新生成成功", extra={"api_key_id": str(api_key_id)}) return api_key, new_api_key - + @staticmethod def get_stats( - db: Session, - api_key_id: uuid.UUID, - workspace_id: uuid.UUID + db: Session, + api_key_id: uuid.UUID, + workspace_id: uuid.UUID ) -> api_key_schema.ApiKeyStats: """获取使用统计""" api_key = ApiKeyService.get_api_key(db, api_key_id, workspace_id) - + stats_data = ApiKeyRepository.get_stats(db, api_key_id) return api_key_schema.ApiKeyStats(**stats_data) + + @staticmethod + def get_logs( + db: Session, + api_key_id: uuid.UUID, + workspace_id: uuid.UUID, + filters: dict, + page: int, + pagesize: int + ) -> PageData: + """获取 API Key 使用日志""" + # 验证 API Key 权限 + api_key = ApiKeyService.get_api_key(db, api_key_id, workspace_id) + + items, total = ApiKeyLogRepository.list_by_api_key( + db, api_key_id, filters, page, pagesize + ) + + # 计算分页信息 + pages = math.ceil(total / pagesize) if total > 0 else 0 + + return PageData( + page=PageMeta( + page=page, + pagesize=pagesize, + total=total, + hasnext=page < pages + ), + items=[api_key_schema.ApiKeyLog.model_validate(item) for item in items] + ) + + +class RateLimiterService: + def __init__(self): + self.redis = aio_redis + + async def check_qps(self, api_key_id: uuid.UUID, limit: int) -> Tuple[bool, dict]: + """ + 检查QPS限制 + Returns: + (is_allowed, rate_limit_info) + """ + key = f"rate_limit:qps:{api_key_id}" + async with self.redis.pipeline() as pipe: + pipe.incr(key) + pipe.expire(key, 1) # 1 秒过期 + results = await pipe.execute() + + current = results[0] + remaining = max(0, limit - current) + reset_time = int(time.time()) + 1 + + return current <= limit, { + "limit": limit, + "remaining": remaining, + "reset": reset_time + } + + async def check_daily_requests( + self, + api_key_id: uuid.UUID, + limit: int + ) -> Tuple[bool, dict]: + """检查日调用量限制""" + today = datetime.now().strftime("%Y%m%d") + key = f"rate_limit:daily:{api_key_id}:{today}" + + now = datetime.now() + tomorrow_0 = (now + timedelta(days=1)).replace( + hour=0, minute=0, second=0, microsecond=0 + ) + expire_seconds = int((tomorrow_0 - now).total_seconds()) + + async with self.redis.pipeline() as pipe: + pipe.incr(key) + pipe.expire(key, expire_seconds, nx=True) + results = await pipe.execute() + + current = results[0] + remaining = max(0, limit - current) + reset_time = int(tomorrow_0.timestamp()) + + return current <= limit, { + "limit": limit, + "remaining": remaining, + "reset": reset_time + } + + async def check_all_limits( + self, + api_key: ApiKey + ) -> Tuple[bool, str, dict]: + """ + 检查所有限制 + Returns: + (is_allowed, error_message, rate_limit_headers) + """ + # Check QPS + qps_ok, qps_info = await self.check_qps( + api_key.id, + api_key.rate_limit + ) + if not qps_ok: + return False, "QPS limit exceeded", { + "X-RateLimit-Limit-QPS": str(qps_info["limit"]), + "X-RateLimit-Remaining-QPS": str(qps_info["remaining"]), + "X-RateLimit-Reset": str(qps_info["reset"]) + } + + # Check daily requests + daily_ok, daily_info = await self.check_daily_requests( + api_key.id, + api_key.daily_request_limit + ) + if not daily_ok: + return False, "Daily request limit exceeded", { + "X-RateLimit-Limit-Day": str(daily_info["limit"]), + "X-RateLimit-Remaining-Day": str(daily_info["remaining"]), + "X-RateLimit-Reset": str(daily_info["reset"]) + } + + # All checks passed + headers = { + "X-RateLimit-Limit-QPS": str(qps_info["limit"]), + "X-RateLimit-Remaining-QPS": str(qps_info["remaining"]), + "X-RateLimit-Limit-Day": str(daily_info["limit"]), + "X-RateLimit-Remaining-Day": str(daily_info["remaining"]), + "X-RateLimit-Reset": str(daily_info["reset"]) + } + return True, "", headers + + +class ApiKeyAuthService: + @staticmethod + def validate_api_key( + db: Session, + api_key: str + ) -> Optional[ApiKey]: + """ + 验证API Key 有效性 + + 检查： + 1. Key hash 是否存在 + 2. is_active 是否为true + 3. expires_at 是否未过期 + 4. quota 是否未超限 + """ + key_hash = hash_api_key(api_key) + api_key_obj = ApiKeyRepository.get_by_hash(db, key_hash) + + if not api_key_obj: + return None + + if not api_key_obj.is_active: + return None + + if api_key_obj.expires_at and datetime.now() > api_key_obj.expires_at: + return None + + if api_key_obj.quota_limit and api_key_obj.quota_used >= api_key_obj.quota_limit: + return None + + return api_key_obj + + @staticmethod + def check_scope(api_key: ApiKey, required_scope: str) -> bool: + """检查权限范围""" + return required_scope in api_key.scopes + + @staticmethod + def check_resource( + api_key: ApiKey, + resource_type: str, + resource_id: uuid.UUID + ) -> bool: + """检查资源绑定""" + if not api_key.resource_id: + return True + + return ( + api_key.resource_type == resource_type and + api_key.resource_id == resource_id + ) diff --git a/api/app/services/app_service.py b/api/app/services/app_service.py index 621f0aa2..06007bf3 100644 --- a/api/app/services/app_service.py +++ b/api/app/services/app_service.py @@ -58,7 +58,7 @@ class AppService: """ if workspace_id is not None and app.workspace_id != workspace_id: logger.warning( - f"工作空间访问被拒", + "工作空间访问被拒", extra={"app_id": str(app.id), "workspace_id": str(workspace_id)} ) raise BusinessException("应用不在指定工作空间中", BizCode.WORKSPACE_NO_ACCESS) @@ -103,7 +103,7 @@ class AppService: """ if not self._check_app_accessible(app, workspace_id): logger.warning( - f"应用访问被拒", + "应用访问被拒", extra={"app_id": str(app.id), "workspace_id": str(workspace_id)} ) raise BusinessException("应用不可访问", BizCode.WORKSPACE_NO_ACCESS) @@ -122,7 +122,7 @@ class AppService: """ app = self.db.get(App, app_id) if not app: - logger.warning(f"应用不存在", extra={"app_id": str(app_id)}) + logger.warning("应用不存在", extra={"app_id": str(app_id)}) raise ResourceNotFoundException("应用", str(app_id)) return app @@ -257,7 +257,7 @@ class AppService: ) logger.info( - f"多智能体配置检查通过", + "多智能体配置检查通过", extra={ "app_id": str(app_id), "master_agent_id": str(multi_agent_config.master_agent_id), @@ -295,7 +295,7 @@ class AppService: updated_at=now, ) self.db.add(agent_cfg) - logger.debug(f"Agent 配置已创建", extra={"app_id": str(app_id)}) + logger.debug("Agent 配置已创建", extra={"app_id": str(app_id)}) def _create_multi_agent_config( self, @@ -380,7 +380,7 @@ class AppService: updated_at=now, ) self.db.add(multi_agent_cfg) - logger.debug(f"多 Agent 配置已创建", extra={"app_id": str(app_id), "mode": config.orchestration_mode}) + logger.debug("多 Agent 配置已创建", extra={"app_id": str(app_id), "mode": config.orchestration_mode}) def _get_next_version(self, app_id: uuid.UUID) -> int: """获取下一个版本号 @@ -474,7 +474,7 @@ class AppService: BusinessException: 当创建失败时 """ logger.info( - f"创建应用", + "创建应用", extra={"app_name": data.name, "type": data.type, "workspace_id": str(workspace_id)} ) @@ -511,12 +511,12 @@ class AppService: self.db.commit() self.db.refresh(app) - logger.info(f"应用创建成功", extra={"app_id": str(app.id), "app_name": app.name}) + logger.info("应用创建成功", extra={"app_id": str(app.id), "app_name": app.name}) return app except Exception as e: self.db.rollback() - logger.error(f"应用创建失败", extra={"app_name": data.name, "error": str(e)}) + logger.error("应用创建失败", extra={"app_name": data.name, "error": str(e)}) raise BusinessException(f"应用创建失败: {str(e)}", BizCode.INTERNAL_ERROR, cause=e) def update_app( @@ -540,7 +540,7 @@ class AppService: ResourceNotFoundException: 当应用不存在时 BusinessException: 当应用不在指定工作空间时 """ - logger.info(f"更新应用", extra={"app_id": str(app_id)}) + logger.info("更新应用", extra={"app_id": str(app_id)}) app = self._get_app_or_404(app_id) self._validate_workspace_access(app, workspace_id) @@ -556,9 +556,9 @@ class AppService: app.updated_at = datetime.datetime.now() self.db.commit() self.db.refresh(app) - logger.info(f"应用更新成功", extra={"app_id": str(app_id)}) + logger.info("应用更新成功", extra={"app_id": str(app_id)}) else: - logger.debug(f"应用无变更", extra={"app_id": str(app_id)}) + logger.debug("应用无变更", extra={"app_id": str(app_id)}) return app @@ -578,17 +578,17 @@ class AppService: ResourceNotFoundException: 当应用不存在时 BusinessException: 当应用不在指定工作空间时 """ - logger.info(f"删除应用", extra={"app_id": str(app_id)}) + logger.info("删除应用", extra={"app_id": str(app_id)}) app = self._get_app_or_404(app_id) self._validate_workspace_access(app, workspace_id) - # 删除应用（级联删除相关数据） - self.db.delete(app) + # 逻辑删除应用 + app.is_active = False self.db.commit() logger.info( - f"应用删除成功", + "应用删除成功", extra={ "app_id": str(app_id), "app_name": app.name, @@ -619,7 +619,7 @@ class AppService: ResourceNotFoundException: 当源应用不存在时 BusinessException: 当复制失败时 """ - logger.info(f"复制应用", extra={"source_app_id": str(app_id)}) + logger.info("复制应用", extra={"source_app_id": str(app_id)}) try: # 获取源应用 @@ -682,7 +682,7 @@ class AppService: self.db.refresh(new_app) logger.info( - f"应用复制成功", + "应用复制成功", extra={ "source_app_id": str(app_id), "new_app_id": str(new_app.id), @@ -695,7 +695,7 @@ class AppService: except Exception as e: self.db.rollback() logger.error( - f"应用复制失败", + "应用复制失败", extra={"source_app_id": str(app_id), "error": str(e)} ) raise BusinessException(f"应用复制失败: {str(e)}", BizCode.INTERNAL_ERROR, cause=e) @@ -734,7 +734,7 @@ class AppService: from app.models import AppShare logger.debug( - f"查询应用列表", + "查询应用列表", extra={ "workspace_id": str(workspace_id), "include_shared": include_shared, @@ -745,6 +745,7 @@ class AppService: # 构建查询条件 filters = [] + filters.append(App.is_active == True) if type: filters.append(App.type == type) if visibility: @@ -791,7 +792,7 @@ class AppService: items = list(self.db.scalars(stmt).all()) logger.debug( - f"应用列表查询完成", + "应用列表查询完成", extra={"total": total, "returned": len(items), "include_shared": include_shared} ) return items, int(total) @@ -819,7 +820,7 @@ class AppService: ResourceNotFoundException: 当应用不存在时 BusinessException: 当应用类型不支持或不在指定工作空间时 """ - logger.info(f"更新 Agent 配置", extra={"app_id": str(app_id)}) + logger.info("更新 Agent 配置", extra={"app_id": str(app_id)}) app = self._get_app_or_404(app_id) @@ -841,7 +842,7 @@ class AppService: updated_at=now, ) self.db.add(agent_cfg) - logger.debug(f"创建新的 Agent 配置", extra={"app_id": str(app_id)}) + logger.debug("创建新的 Agent 配置", extra={"app_id": str(app_id)}) # 转换为存储格式 storage_data = AgentConfigConverter.to_storage_format(data) @@ -867,7 +868,7 @@ class AppService: self.db.commit() self.db.refresh(agent_cfg) - logger.info(f"Agent 配置更新成功", extra={"app_id": str(app_id)}) + logger.info("Agent 配置更新成功", extra={"app_id": str(app_id)}) return agent_cfg def get_agent_config( @@ -891,7 +892,7 @@ class AppService: ResourceNotFoundException: 当应用不存在时 BusinessException: 当应用类型不支持或不可访问时 """ - logger.debug(f"获取 Agent 配置", extra={"app_id": str(app_id)}) + logger.debug("获取 Agent 配置", extra={"app_id": str(app_id)}) app = self._get_app_or_404(app_id) @@ -908,7 +909,7 @@ class AppService: return config # 返回默认配置模板（不保存到数据库） - logger.debug(f"配置不存在，返回默认模板", extra={"app_id": str(app_id)}) + logger.debug("配置不存在，返回默认模板", extra={"app_id": str(app_id)}) return self._create_default_agent_config(app_id) def _create_default_agent_config(self, app_id: uuid.UUID) -> AgentConfig: @@ -981,7 +982,7 @@ class AppService: ResourceNotFoundException: 当应用不存在时 BusinessException: 当应用缺少配置或不在指定工作空间时 """ - logger.info(f"发布应用", extra={"app_id": str(app_id), "publisher_id": str(publisher_id)}) + logger.info("发布应用", extra={"app_id": str(app_id), "publisher_id": str(publisher_id)}) app = self._get_app_or_404(app_id) # 检查应用归属 @@ -1039,7 +1040,7 @@ class AppService: } logger.info( - f"多智能体应用发布配置准备完成", + "多智能体应用发布配置准备完成", extra={ "app_id": str(app_id), "master_agent_id": str(multi_agent_cfg.master_agent_id), @@ -1083,7 +1084,7 @@ class AppService: self.db.refresh(release) logger.info( - f"应用发布成功", + "应用发布成功", extra={"app_id": str(app_id), "version": version, "release_id": str(release.id)} ) return release @@ -1107,7 +1108,7 @@ class AppService: ResourceNotFoundException: 当应用不存在时 BusinessException: 当应用不可访问时 """ - logger.debug(f"获取当前发布版本", extra={"app_id": str(app_id)}) + logger.debug("获取当前发布版本", extra={"app_id": str(app_id)}) app = self._get_app_or_404(app_id) # 只读操作，允许访问共享应用 @@ -1137,7 +1138,7 @@ class AppService: ResourceNotFoundException: 当应用不存在时 BusinessException: 当应用不可访问时 """ - logger.debug(f"列出发布版本", extra={"app_id": str(app_id)}) + logger.debug("列出发布版本", extra={"app_id": str(app_id)}) app = self._get_app_or_404(app_id) # 只读操作，允许访问共享应用 @@ -1171,7 +1172,7 @@ class AppService: ResourceNotFoundException: 当应用或版本不存在时 BusinessException: 当应用不在指定工作空间时 """ - logger.info(f"回滚应用", extra={"app_id": str(app_id), "version": version}) + logger.info("回滚应用", extra={"app_id": str(app_id), "version": version}) app = self._get_app_or_404(app_id) self._validate_app_accessible(app, workspace_id) @@ -1184,7 +1185,7 @@ class AppService: if not release: logger.warning( - f"发布版本不存在", + "发布版本不存在", extra={"app_id": str(app_id), "version": version} ) raise ResourceNotFoundException("发布版本", f"app_id={app_id}, version={version}") @@ -1196,7 +1197,7 @@ class AppService: self.db.refresh(release) logger.info( - f"应用回滚成功", + "应用回滚成功", extra={"app_id": str(app_id), "version": version, "release_id": str(release.id)} ) return release @@ -1229,7 +1230,7 @@ class AppService: from app.models import AppShare, Workspace logger.info( - f"分享应用", + "分享应用", extra={ "app_id": str(app_id), "target_workspaces": [str(wid) for wid in target_workspace_ids], @@ -1268,7 +1269,7 @@ class AppService: if existing_share: logger.debug( - f"应用已分享到该工作空间，跳过", + "应用已分享到该工作空间，跳过", extra={"app_id": str(app_id), "target_workspace_id": str(target_ws_id)} ) shares.append(existing_share) @@ -1288,14 +1289,14 @@ class AppService: shares.append(share) logger.debug( - f"创建分享记录", + "创建分享记录", extra={"app_id": str(app_id), "target_workspace_id": str(target_ws_id)} ) self.db.commit() logger.info( - f"应用分享成功", + "应用分享成功", extra={ "app_id": str(app_id), "shared_count": len(shares), @@ -1326,7 +1327,7 @@ class AppService: from app.models import AppShare logger.info( - f"取消应用分享", + "取消应用分享", extra={ "app_id": str(app_id), "target_workspace_id": str(target_workspace_id) @@ -1346,7 +1347,7 @@ class AppService: if not share: logger.warning( - f"分享记录不存在", + "分享记录不存在", extra={"app_id": str(app_id), "target_workspace_id": str(target_workspace_id)} ) raise ResourceNotFoundException( @@ -1359,7 +1360,7 @@ class AppService: self.db.commit() logger.info( - f"应用分享已取消", + "应用分享已取消", extra={"app_id": str(app_id), "target_workspace_id": str(target_workspace_id)} ) @@ -1384,7 +1385,7 @@ class AppService: """ from app.models import AppShare - logger.debug(f"列出应用分享记录", extra={"app_id": str(app_id)}) + logger.debug("列出应用分享记录", extra={"app_id": str(app_id)}) # 验证应用 app = self._get_app_or_404(app_id) @@ -1398,7 +1399,7 @@ class AppService: shares = list(self.db.scalars(stmt).all()) logger.debug( - f"应用分享记录查询完成", + "应用分享记录查询完成", extra={"app_id": str(app_id), "count": len(shares)} ) @@ -1435,7 +1436,7 @@ class AppService: """ from app.services.draft_run_service import DraftRunService - logger.info(f"试运行 Agent", extra={"app_id": str(app_id), "user_message": message[:50]}) + logger.info("试运行 Agent", extra={"app_id": str(app_id), "user_message": message[:50]}) # 1. 验证应用 app = self._get_app_or_404(app_id) @@ -1464,7 +1465,7 @@ class AppService: # 4. 调用试运行服务 logger.debug( - f"准备调用试运行服务", + "准备调用试运行服务", extra={ "app_id": str(app_id), "model": model_config.name, @@ -1485,7 +1486,7 @@ class AppService: ) logger.debug( - f"试运行服务返回结果", + "试运行服务返回结果", extra={ "result_type": str(type(result)), "result_keys": list(result.keys()) if isinstance(result, dict) else "not_dict", @@ -1495,7 +1496,7 @@ class AppService: ) logger.info( - f"试运行完成", + "试运行完成", extra={ "app_id": str(app_id), "elapsed_time": result.get("elapsed_time"), @@ -1534,7 +1535,7 @@ class AppService: """ from app.services.draft_run_service import DraftRunService - logger.info(f"流式试运行 Agent", extra={"app_id": str(app_id), "user_message": message[:50]}) + logger.info("流式试运行 Agent", extra={"app_id": str(app_id), "user_message": message[:50]}) # 1. 验证应用 app = self._get_app_or_404(app_id) @@ -1609,7 +1610,7 @@ class AppService: from app.models import ModelConfig logger.info( - f"多模型对比试运行", + "多模型对比试运行", extra={ "app_id": str(app_id), "model_count": len(models), @@ -1666,7 +1667,7 @@ class AppService: ) logger.info( - f"多模型对比完成", + "多模型对比完成", extra={ "app_id": str(app_id), "successful": result["successful_count"], @@ -1708,7 +1709,7 @@ class AppService: from app.models import ModelConfig logger.info( - f"多模型对比流式试运行", + "多模型对比流式试运行", extra={ "app_id": str(app_id), "model_count": len(models) @@ -1765,7 +1766,7 @@ class AppService: yield event logger.info( - f"多模型对比流式完成", + "多模型对比流式完成", extra={"app_id": str(app_id)} ) diff --git a/api/app/services/auth_service.py b/api/app/services/auth_service.py index 118b6bc5..877d8d5c 100644 --- a/api/app/services/auth_service.py +++ b/api/app/services/auth_service.py @@ -162,7 +162,7 @@ def register_user_with_invite( # 接受工作空间邀请（此时用户已成为工作空间成员，并且会 commit） invite_accept = InviteAcceptRequest(token=invite_token) workspace_service.accept_workspace_invite(db, invite_accept, user) - logger.info(f"用户接受邀请成功") + logger.info("用户接受邀请成功") # 重新查询用户对象以确保获取最新状态 from app.repositories import user_repository @@ -200,7 +200,7 @@ def bind_workspace_with_invite( # 接受工作空间邀请（此时用户已成为工作空间成员，并且会 commit） invite_accept = InviteAcceptRequest(token=invite_token) workspace_service.accept_workspace_invite(db, invite_accept, user) - logger.info(f"用户接受邀请成功") + logger.info("用户接受邀请成功") # 重新查询用户对象以确保获取最新状态 from app.repositories import user_repository diff --git a/api/app/services/conversation_service.py b/api/app/services/conversation_service.py index 42144441..63826726 100644 --- a/api/app/services/conversation_service.py +++ b/api/app/services/conversation_service.py @@ -42,7 +42,7 @@ class ConversationService: self.db.refresh(conversation) logger.info( - f"创建会话成功", + "创建会话成功", extra={ "conversation_id": str(conversation.id), "app_id": str(app_id), @@ -201,7 +201,7 @@ class ConversationService: ) logger.debug( - f"保存会话消息成功", + "保存会话消息成功", extra={ "conversation_id": str(conversation_id), "user_message_length": len(user_message), @@ -221,7 +221,7 @@ class ConversationService: self.db.commit() logger.info( - f"删除会话成功", + "删除会话成功", extra={ "conversation_id": str(conversation_id), "workspace_id": str(workspace_id) diff --git a/api/app/services/conversation_state_manager.py b/api/app/services/conversation_state_manager.py index b279696a..1fca6bc1 100644 --- a/api/app/services/conversation_state_manager.py +++ b/api/app/services/conversation_state_manager.py @@ -74,7 +74,7 @@ class ConversationStateManager: state["same_agent_turns"] = 0 logger.info( - f"Agent 切换", + "Agent 切换", extra={ "conversation_id": conversation_id, "from": state["current_agent_id"], diff --git a/api/app/services/draft_run_service.py b/api/app/services/draft_run_service.py index d65a3612..489ffe4b 100644 --- a/api/app/services/draft_run_service.py +++ b/api/app/services/draft_run_service.py @@ -14,10 +14,8 @@ from pydantic import BaseModel, Field from sqlalchemy.orm import Session from sqlalchemy import select -from app.services.memory_konwledges_server import write_rag -from app.tasks import write_message_task from app.models import AgentConfig, ModelConfig, ModelApiKey -from app.core.exceptions import BusinessException, ResourceNotFoundException +from app.core.exceptions import BusinessException from app.core.error_codes import BizCode from app.core.logging_config import get_business_logger from app.schemas.prompt_schema import render_prompt_message, PromptMessageRole @@ -25,7 +23,6 @@ from app.services.memory_agent_service import MemoryAgentService from app.services.model_parameter_merger import ModelParameterMerger from app.core.rag.nlp.search import knowledge_retrieval from app.services.langchain_tool_server import Search -from app.services.task_service import get_task_memory_write_result logger = get_business_logger() class KnowledgeRetrievalInput(BaseModel): @@ -40,10 +37,11 @@ class WebSearchInput(BaseModel): class LongTermMemoryInput(BaseModel): """长期记忆工具输入参数""" - question: str = Field(description="需要查询的问题") + question: str = Field(description="经过优化重写的查询问题。请将用户的原始问题重写为更合适的检索形式，包含关键词，上下文和具体描述，注意错词检查并且改写") def create_long_term_memory_tool(memory_config: Dict[str, Any], end_user_id: str, storage_type: Optional[str] = None,user_rag_memory_id: Optional[str] = None): - """创建长期记忆工具 + """创建记忆工具, + Args: memory_config: 记忆配置 @@ -55,40 +53,52 @@ def create_long_term_memory_tool(memory_config: Dict[str, Any], end_user_id: str """ # search_switch = memory_config.get("search_switch", "2") config_id= memory_config.get("memory_content",'17') - logger.info(f"创建长期记忆工具，配置: end_user_id={end_user_id}, config_id={config_id}, storage_type={storage_type}") - @tool(args_schema=LongTermMemoryInput) def long_term_memory(question: str) -> str: - """从长期记忆中检索历史对话信息。当需要回忆之前的对话内容、用户偏好或历史信息时使用此工具。 + """ + 从用户的历史记忆中检索相关信息。这是一个强大的工具，可以帮助你了解用户的背景、偏好和历史对话内容。 + + 以下场景不需要使用此工具： + 1. 情绪/社交问候场景（如"你好"、"谢谢"、"再见"等简单寒暄） + 2. 纯任务性场景（如"帮我写代码"、"翻译这段文字"等不需要历史上下文的任务） + 3. 处理外部内容时（如用户提供的文本、代码、RAG数据等，这些内容本身已经包含所需信息） + + 除上述场景外的所有其他情况都应该使用此工具，特别是： + - 用户询问个人信息或历史对话内容 + - 需要了解用户偏好、习惯或背景 + - 用户提到"之前"、"上次"、"记得"等涉及历史的词汇 + - 需要个性化回复或基于历史上下文的建议 + - 用户询问关于自己的任何信息 + 需要对question改写/优化： + 需要重点关注一以下几点 + - 相关的关键词，保持原问题的核心语义不变， 根据上下文，使问题更具体、更清晰，将模糊的表达转换为明确的搜索词 + - 使用同义词或相关术语扩展查询 Args: - question: 需要查询的问题 - end_user_id: 用户唯一标识符 - search_switch: 搜索开关（on/off） + question: question改写之后的内容 Returns: 检索到的历史记忆内容 """ logger.info(f" 长期记忆工具被调用！question={question}, user={end_user_id}") - try: memory_content = asyncio.run( MemoryAgentService().read_memory( group_id=end_user_id, message=question, history=[], - search_switch="2", + search_switch="1", config_id=config_id, storage_type=storage_type, user_rag_memory_id=user_rag_memory_id ) ) logger.info(f'用户ID：Agent:{end_user_id}') - logger.debug(f"调用长期记忆 API", extra={"question": question, "end_user_id": end_user_id}) + logger.debug("调用长期记忆 API", extra={"question": question, "end_user_id": end_user_id}) logger.info( - f"长期记忆检索成功", + "长期记忆检索成功", extra={ "end_user_id": end_user_id, "content_length": len(str(memory_content)) @@ -97,9 +107,8 @@ def create_long_term_memory_tool(memory_config: Dict[str, Any], end_user_id: str return f"检索到以下历史记忆：\n\n{memory_content}" except Exception as e: - logger.error(f"长期记忆检索失败", extra={"error": str(e), "error_type": type(e).__name__}) + logger.error("长期记忆检索失败", extra={"error": str(e), "error_type": type(e).__name__}) return f"记忆检索失败: {str(e)}" - return long_term_memory @@ -140,7 +149,7 @@ def create_web_search_tool(web_search_config: Dict[str, Any]): return f"搜索到以下网络信息：\n\n{search_result}" except Exception as e: - logger.error(f"网络搜索失败", extra={"error": str(e), "error_type": type(e).__name__}) + logger.error("网络搜索失败", extra={"error": str(e), "error_type": type(e).__name__}) return f"搜索失败: {str(e)}" return web_search_tool @@ -175,7 +184,7 @@ def create_knowledge_retrieval_tool(kb_config,kb_ids,user_id): retrieval_knowledge = [i.page_content for i in retrieve_chunks_result] context = '\n\n'.join(retrieval_knowledge) logger.info( - f"知识库检索成功", + "知识库检索成功", extra={ "kb_ids": kb_ids, "result_count": len(retrieval_knowledge), @@ -188,7 +197,7 @@ def create_knowledge_retrieval_tool(kb_config,kb_ids,user_id): logger.warning("知识库检索未找到结果") return "未找到相关信息" except Exception as e: - logger.error(f"知识库检索失败", extra={"error": str(e), "error_type": type(e).__name__}) + logger.error("知识库检索失败", extra={"error": str(e), "error_type": type(e).__name__}) return f"检索失败: {str(e)}" return knowledge_retrieval_tool @@ -233,6 +242,7 @@ class DraftRunService: Returns: Dict: 包含 AI 回复和元数据的字典 """ + memory_flag=False print('===========',storage_type) @@ -246,7 +256,7 @@ class DraftRunService: # 1. 获取 API Key 配置 api_key_config = await self._get_api_key(model_config.id) logger.debug( - f"API Key 配置获取成功", + "API Key 配置获取成功", extra={ "model_name": api_key_config["model_name"], "has_api_key": bool(api_key_config["api_key"]), @@ -305,7 +315,7 @@ class DraftRunService: tools.append(kb_tool) logger.debug( - f"已添加知识库检索工具", + "已添加知识库检索工具", extra={ "kb_ids": kb_ids, "tool_count": len(tools) @@ -315,6 +325,7 @@ class DraftRunService: # 添加长期记忆工具 if memory: if agent_config.memory and agent_config.memory.get("enabled"): + memory_flag=True memory_config = agent_config.memory if user_id: @@ -323,7 +334,7 @@ class DraftRunService: tools.append(memory_tool) logger.debug( - f"已添加长期记忆工具", + "已添加长期记忆工具", extra={ "user_id": user_id, "tool_count": len(tools) @@ -362,7 +373,7 @@ class DraftRunService: context = None logger.debug( - f"准备调用 LangChain Agent", + "准备调用 LangChain Agent", extra={ "model": api_key_config["model_name"], "has_history": bool(history), @@ -381,7 +392,8 @@ class DraftRunService: end_user_id=user_id, config_id=config_id, storage_type=storage_type, - user_rag_memory_id=user_rag_memory_id + user_rag_memory_id=user_rag_memory_id, + memory_flag=memory_flag ) elapsed_time = time.time() - start_time @@ -408,7 +420,7 @@ class DraftRunService: } logger.info( - f"试运行完成", + "试运行完成", extra={ "model": model_config.name, "elapsed_time": elapsed_time, @@ -420,7 +432,7 @@ class DraftRunService: return response except Exception as e: - logger.error(f"LangChain Agent 调用失败", extra={"error": str(e), "error_type": type(e).__name__}) + logger.error("LangChain Agent 调用失败", extra={"error": str(e), "error_type": type(e).__name__}) raise BusinessException(f"Agent 调用失败: {str(e)}", BizCode.INTERNAL_ERROR, cause=e) async def run_stream( @@ -453,6 +465,7 @@ class DraftRunService: Yields: str: SSE 格式的事件数据 """ + memory_flag=False if variables==None:variables={} from app.core.agent.langchain_agent import LangChainAgent @@ -486,17 +499,17 @@ class DraftRunService: # 添加网络搜索工具 if web_search: if agent_config.tools: - web_search = agent_config.tools.get("web_search", {}) - web_search_enable = web_search.get("enable", False) + web_search_config = agent_config.tools.get("web_search", {}) + web_search_enable = web_search_config.get("enabled", False) if web_search_enable: - logger.info("网络搜索已启用（流式）") + logger.info("网络搜索已启用") # 创建网络搜索工具 - search_tool = create_web_search_tool(web_search) + search_tool = create_web_search_tool(web_search_config) tools.append(search_tool) logger.debug( - "已添加网络搜索工具（流式）", + "已添加网络搜索工具", extra={ "tool_count": len(tools) } @@ -509,20 +522,20 @@ class DraftRunService: kb_ids = bool(knowledge_bases and knowledge_bases[0].get("kb_id")) if kb_ids: # 创建知识库检索工具 - kb_tool = create_knowledge_retrieval_tool(kb_config,kb_ids,user_id) + kb_tool = create_knowledge_retrieval_tool(kb_config, kb_ids, user_id) tools.append(kb_tool) logger.debug( - f"已添加知识库检索工具", + "已添加知识库检索工具", extra={ "kb_ids": kb_ids, "tool_count": len(tools) } ) - # 添加长期记忆工具 if memory: if agent_config.memory and agent_config.memory.get("enabled"): + memory_flag= True memory_config = agent_config.memory if user_id: # 创建长期记忆工具 @@ -530,13 +543,14 @@ class DraftRunService: tools.append(memory_tool) logger.debug( - f"已添加长期记忆工具", + "已添加长期记忆工具", extra={ "user_id": user_id, "tool_count": len(tools) } ) + # 4. 创建 LangChain Agent agent = LangChainAgent( model_name=api_key_config["model_name"], @@ -587,7 +601,8 @@ class DraftRunService: end_user_id=user_id, config_id=config_id, storage_type=storage_type, - user_rag_memory_id=user_rag_memory_id + user_rag_memory_id=user_rag_memory_id, + memory_flag=memory_flag ): full_content += chunk # 发送消息块事件 @@ -595,13 +610,6 @@ class DraftRunService: "content": chunk }) - if storage_type == "rag": - await write_rag(user_id, full_content, user_rag_memory_id) - else: - write_id = write_message_task.delay(user_id, full_content, config_id, storage_type, user_rag_memory_id) - write_status = get_task_memory_write_result(str(write_id)) - logger.info(f'Agent:{user_id};{full_content}--{write_status}') - elapsed_time = time.time() - start_time # 10. 保存会话消息 @@ -622,7 +630,7 @@ class DraftRunService: }) logger.info( - f"流式试运行完成", + "流式试运行完成", extra={ "model": model_config.name, "elapsed_time": elapsed_time, @@ -631,7 +639,7 @@ class DraftRunService: ) except Exception as e: - logger.error(f"流式 Agent 调用失败", extra={"error": str(e)}) + logger.error("流式 Agent 调用失败", extra={"error": str(e)}) # 发送错误事件 yield self._format_sse_event("error", { "error": str(e), @@ -737,7 +745,7 @@ class DraftRunService: self.db.refresh(new_conversation) logger.info( - f"创建草稿会话成功", + "创建草稿会话成功", extra={ "conversation_id": new_conv_id, "workspace_id": str(workspace_id) @@ -754,7 +762,7 @@ class DraftRunService: # 验证会话属于当前工作空间 if conversation.workspace_id != workspace_id: logger.warning( - f"会话不属于当前工作空间", + "会话不属于当前工作空间", extra={ "conversation_id": conversation_id, "conversation_workspace_id": str(conversation.workspace_id), @@ -762,12 +770,12 @@ class DraftRunService: } ) raise BusinessException( - f"会话不属于当前工作空间", + "会话不属于当前工作空间", BizCode.PERMISSION_DENIED ) logger.debug( - f"使用现有会话", + "使用现有会话", extra={ "conversation_id": conversation_id, "workspace_id": str(workspace_id) @@ -778,7 +786,7 @@ class DraftRunService: raise except Exception as e: logger.error( - f"会话不存在或无效", + "会话不存在或无效", extra={"conversation_id": conversation_id, "error": str(e)} ) raise BusinessException( @@ -811,7 +819,7 @@ class DraftRunService: ) logger.debug( - f"加载会话历史", + "加载会话历史", extra={ "conversation_id": conversation_id, "max_history": max_history, @@ -823,7 +831,7 @@ class DraftRunService: except Exception as e: # 新会话没有历史记录是正常的 - logger.debug(f"加载会话历史失败（可能是新会话）", extra={"error": str(e)}) + logger.debug("加载会话历史失败（可能是新会话）", extra={"error": str(e)}) return [] async def _save_conversation_message( @@ -864,7 +872,7 @@ class DraftRunService: ) logger.debug( - f"保存会话消息", + "保存会话消息", extra={ "conversation_id": conversation_id, "user_message_length": len(user_message), @@ -873,7 +881,7 @@ class DraftRunService: ) except Exception as e: - logger.warning(f"保存会话消息失败", extra={"error": str(e)}) + logger.warning("保存会话消息失败", extra={"error": str(e)}) async def _get_config_snapshot(self, app_id: uuid.UUID) -> Dict[str, Any]: """获取当前配置快照 @@ -936,7 +944,7 @@ class DraftRunService: except Exception as e: # 对于多 Agent 应用，没有直接的 AgentConfig 是正常的 - logger.debug(f"获取配置快照失败（可能是多 Agent 应用）", extra={"error": str(e)}) + logger.debug("获取配置快照失败（可能是多 Agent 应用）", extra={"error": str(e)}) return {} def _replace_variables( @@ -1015,7 +1023,7 @@ class DraftRunService: Dict: 对比结果 """ logger.info( - f"多模型对比试运行", + "多模型对比试运行", extra={ "model_count": len(models), "parallel": parallel @@ -1074,9 +1082,9 @@ class DraftRunService: "error": None } - except asyncio.TimeoutError: + except TimeoutError: logger.warning( - f"模型运行超时", + "模型运行超时", extra={ "model_config_id": str(model_info["model_config_id"]), "timeout": timeout @@ -1093,7 +1101,7 @@ class DraftRunService: } except Exception as e: logger.error( - f"模型运行失败", + "模型运行失败", extra={ "model_config_id": str(model_info["model_config_id"]), "error": str(e) @@ -1134,7 +1142,7 @@ class DraftRunService: ) if successful else None logger.info( - f"多模型对比完成", + "多模型对比完成", extra={ "successful": len(successful), "failed": len(failed), @@ -1207,16 +1215,20 @@ class DraftRunService: ) -> AsyncGenerator[str, None]: """多模型对比试运行（流式返回） - 支持并行或串行执行，通过 model_index 区分不同模型的事件 + 参考 run_compare 的实现，支持并行或串行执行 Args: agent_config: Agent 配置 - models: 模型配置列表 + models: 模型配置列表，每项包含 model_config, parameters, label, model_config_id message: 用户消息 workspace_id: 工作空间ID conversation_id: 会话ID user_id: 用户ID variables: 变量参数 + storage_type: 存储类型 + user_rag_memory_id: RAG 记忆 ID + web_search: 是否启用网络搜索 + memory: 是否启用记忆 parallel: 是否并行执行 timeout: 超时时间（秒） @@ -1224,14 +1236,10 @@ class DraftRunService: str: SSE 格式的事件数据 """ logger.info( - f"多模型对比流式试运行", + "多模型对比流式试运行", extra={"model_count": len(models), "parallel": parallel} ) - # 确保有 conversation_id - if not conversation_id: - conversation_id = str(uuid.uuid4()) - # 发送开始事件 yield self._format_sse_event("compare_start", { "conversation_id": conversation_id, @@ -1242,185 +1250,190 @@ class DraftRunService: results = [] - if parallel: - # 并行执行所有模型 - import asyncio + async def run_single_model_stream(idx: int, model_info: Dict[str, Any], event_queue: asyncio.Queue): + """运行单个模型（流式）并将事件放入队列""" + model_label = model_info["label"] + model_config_id = str(model_info["model_config_id"]) + # 使用模型自己的 conversation_id，如果没有则使用全局的 + model_conversation_id = model_info.get("conversation_id") or conversation_id - # 创建事件队列用于收集所有模型的事件 - event_queue = asyncio.Queue() + try: + # 发送模型开始事件 + await event_queue.put(self._format_sse_event("model_start", { + "model_index": idx, + "model_config_id": model_config_id, + "model_name": model_info["model_config"].name, + "label": model_label, + "conversation_id": model_conversation_id, + "timestamp": time.time() + })) - async def run_single_model_stream(idx: int, model_info: Dict[str, Any]): - """运行单个模型并将事件放入队列""" - model_label = model_info["label"] - model_config_id = str(model_info["model_config_id"]) - # 使用模型自己的 conversation_id，如果没有则使用全局的 - model_conversation_id = model_info.get("conversation_id") or conversation_id + start_time = time.time() + full_content = "" + returned_conversation_id = model_conversation_id + + # 临时修改参数 + original_params = agent_config.model_parameters + agent_config.model_parameters = model_info["parameters"] try: - # 发送模型开始事件 - await event_queue.put(self._format_sse_event("model_start", { - "model_index": idx, - "model_config_id": model_config_id, - "model_name": model_info["model_config"].name, - "label": model_label, - "conversation_id": model_conversation_id, - "timestamp": time.time() - })) + # 流式调用单个模型 + async for event_str in self.run_stream( + agent_config=agent_config, + model_config=model_info["model_config"], + message=message, + workspace_id=workspace_id, + conversation_id=model_conversation_id, + user_id=user_id, + variables=variables, + storage_type=storage_type, + user_rag_memory_id=user_rag_memory_id, + web_search=web_search, + memory=memory + ): + # 解析原始事件 + try: + lines = event_str.strip().split('\n') + event_type = None + event_data = None - start_time = time.time() - full_content = "" + for line in lines: + if line.startswith('event: '): + event_type = line[7:].strip() + elif line.startswith('data: '): + event_data = json.loads(line[6:]) - # 临时修改参数（并行任务中安全） - original_params = agent_config.model_parameters - agent_config.model_parameters = model_info["parameters"] + # 从 start 事件中获取实际的 conversation_id + if event_type == "start" and event_data: + conv_id = event_data.get("conversation_id") + if conv_id: + returned_conversation_id = conv_id - try: - # 流式调用单个模型 - async for event_str in self.run_stream( - agent_config=agent_config, - model_config=model_info["model_config"], - message=message, - workspace_id=workspace_id, - conversation_id=model_conversation_id, - user_id=user_id, - variables=variables, - storage_type=storage_type, - user_rag_memory_id=user_rag_memory_id, - web_search=web_search, - memory=memory - ): - # 解析原始事件 - try: - lines = event_str.strip().split('\n') - event_type = None - event_data = None + # 累积消息内容 + if event_type == "message" and event_data: + chunk = event_data.get("content", "") + full_content += chunk - for line in lines: - if line.startswith('event: '): - event_type = line[7:].strip() - elif line.startswith('data: '): - event_data = json.loads(line[6:]) + # 转发消息块事件（带模型标识） + await event_queue.put(self._format_sse_event("model_message", { + "model_index": idx, + "model_config_id": model_config_id, + "label": model_label, + "conversation_id": returned_conversation_id, + "content": chunk + })) + except Exception as e: + logger.warning(f"解析流式事件失败: {e}") + finally: + # 恢复原始参数 + agent_config.model_parameters = original_params - # 从 start 事件中获取 conversation_id - if event_type == "start" and event_data: - returned_conv_id = event_data.get("conversation_id") - if returned_conv_id: - model_conversation_id = returned_conv_id + elapsed = time.time() - start_time - if event_type == "message" and event_data: - chunk = event_data.get("content", "") - full_content += chunk + # 构建结果（参考 run_compare） + result = { + "model_config_id": model_info["model_config_id"], + "model_name": model_info["model_config"].name, + "label": model_label, + "conversation_id": returned_conversation_id, + "parameters_used": model_info["parameters"], + "message": full_content, + "elapsed_time": elapsed, + "error": None + } - # 转发消息块事件（带模型标识和 conversation_id） - await event_queue.put(self._format_sse_event("model_message", { - "model_index": idx, - "model_config_id": model_config_id, - "label": model_label, - "conversation_id": model_conversation_id, - "content": chunk - })) - except Exception as e: - logger.warning(f"解析流式事件失败: {e}") - finally: - # 恢复原始参数 - agent_config.model_parameters = original_params + # 发送模型完成事件 + await event_queue.put(self._format_sse_event("model_end", { + "model_index": idx, + "model_config_id": model_config_id, + "label": model_label, + "conversation_id": returned_conversation_id, + "elapsed_time": elapsed, + "message_length": len(full_content), + "timestamp": time.time() + })) - elapsed = time.time() - start_time + return result - # 模型完成 - result = { - "model_config_id": model_info["model_config_id"], - "model_name": model_info["model_config"].name, - "label": model_label, - "parameters_used": model_info["parameters"], - "message": full_content, - "elapsed_time": elapsed, - "error": None - } + except TimeoutError: + logger.warning(f"模型运行超时: {model_label}") + result = { + "model_config_id": model_info["model_config_id"], + "model_name": model_info["model_config"].name, + "label": model_label, + "conversation_id": model_conversation_id, + "parameters_used": model_info["parameters"], + "elapsed_time": timeout, + "error": f"执行超时（{timeout}秒）" + } - # 发送模型完成事件 - await event_queue.put(self._format_sse_event("model_end", { - "model_index": idx, - "model_config_id": model_config_id, - "label": model_label, - "conversation_id": model_conversation_id, - "elapsed_time": elapsed, - "message_length": len(full_content), - "timestamp": time.time() - })) + await event_queue.put(self._format_sse_event("model_error", { + "model_index": idx, + "model_config_id": model_config_id, + "label": model_label, + "conversation_id": model_conversation_id, + "error": result["error"], + "timestamp": time.time() + })) - return result + return result - except asyncio.TimeoutError: - logger.warning(f"模型运行超时: {model_label}") - result = { - "model_config_id": model_info["model_config_id"], - "model_name": model_info["model_config"].name, - "label": model_label, - "elapsed_time": timeout, - "error": f"执行超时（{timeout}秒）" - } + except Exception as e: + logger.error(f"模型运行失败: {model_label}, error: {e}") + result = { + "model_config_id": model_info["model_config_id"], + "model_name": model_info["model_config"].name, + "label": model_label, + "conversation_id": model_conversation_id, + "parameters_used": model_info["parameters"], + "elapsed_time": 0, + "error": str(e) + } - await event_queue.put(self._format_sse_event("model_error", { - "model_index": idx, - "model_config_id": model_config_id, - "label": model_label, - "conversation_id": model_conversation_id, - "error": result["error"], - "timestamp": time.time() - })) + await event_queue.put(self._format_sse_event("model_error", { + "model_index": idx, + "model_config_id": model_config_id, + "label": model_label, + "conversation_id": model_conversation_id, + "error": str(e), + "timestamp": time.time() + })) - return result + return result - except Exception as e: - logger.error(f"模型运行失败: {model_label}, error: {e}") - result = { - "model_config_id": model_info["model_config_id"], - "model_name": model_info["model_config"].name, - "label": model_label, - "elapsed_time": 0, - "error": str(e) - } + if parallel: + # 并行执行所有模型（参考 run_compare） + logger.debug(f"并行执行 {len(models)} 个模型（流式）") - await event_queue.put(self._format_sse_event("model_error", { - "model_index": idx, - "model_config_id": model_config_id, - "label": model_label, - "conversation_id": model_conversation_id, - "error": str(e), - "timestamp": time.time() - })) - - return result + # 创建事件队列 + event_queue = asyncio.Queue() # 启动所有模型的并行任务 tasks = [ - asyncio.create_task(run_single_model_stream(idx, model_info)) + asyncio.create_task(run_single_model_stream(idx, model_info, event_queue)) for idx, model_info in enumerate(models) ] - # 持续从队列中取出事件并发送 - completed_count = 0 - while completed_count < len(models): + # 持续从队列中取出事件并转发 + completed_tasks = set() + while len(completed_tasks) < len(tasks): try: - # 等待事件或任务完成 + # 尝试从队列获取事件 event = await asyncio.wait_for(event_queue.get(), timeout=0.1) yield event - except asyncio.TimeoutError: + except TimeoutError: # 检查是否有任务完成 for task in tasks: - if task.done() and task not in [t for t in tasks if hasattr(t, '_result_retrieved')]: - result = await task - results.append(result) - task._result_retrieved = True - completed_count += 1 + if task.done() and task not in completed_tasks: + completed_tasks.add(task) + try: + result = await task + if result: + results.append(result) + except Exception as e: + logger.error(f"获取任务结果失败: {e}") continue - # 等待所有任务完成 - all_results = await asyncio.gather(*tasks, return_exceptions=False) - results = [r for r in all_results if r not in results] - results.extend([r for r in all_results if r not in results]) - # 清空队列中剩余的事件 while not event_queue.empty(): try: @@ -1430,163 +1443,67 @@ class DraftRunService: break else: - # 串行执行每个模型 + # 串行执行每个模型（参考 run_compare） + logger.debug(f"串行执行 {len(models)} 个模型（流式）") + for idx, model_info in enumerate(models): - model_label = model_info["label"] - model_config_id = str(model_info["model_config_id"]) - # 使用模型自己的 conversation_id，如果没有则使用全局的 - model_conversation_id = model_info.get("conversation_id") or conversation_id + # 创建临时队列用于单个模型 + event_queue = asyncio.Queue() - # 发送模型开始事件 - yield self._format_sse_event("model_start", { - "model_index": idx, - "model_config_id": model_config_id, - "model_name": model_info["model_config"].name, - "label": model_label, - "conversation_id": model_conversation_id, - "timestamp": time.time() - }) - - try: - start_time = time.time() - full_content = "" - - # 临时修改参数 - original_params = agent_config.model_parameters - agent_config.model_parameters = model_info["parameters"] + # 运行单个模型 + result = await run_single_model_stream(idx, model_info, event_queue) + if result: + results.append(result) + # 转发该模型的所有事件 + while not event_queue.empty(): try: - # 流式调用单个模型 - async for event_str in self.run_stream( - agent_config=agent_config, - model_config=model_info["model_config"], - message=message, - workspace_id=workspace_id, - conversation_id=model_conversation_id, - user_id=user_id, - variables=variables, - storage_type=storage_type, - user_rag_memory_id=user_rag_memory_id, - web_search=web_search, - memory=memory - ): - # 解析原始事件 - try: - # SSE 格式: "event: xxx\ndata: {...}\n\n" - lines = event_str.strip().split('\n') - event_type = None - event_data = None + event = event_queue.get_nowait() + yield event + except asyncio.QueueEmpty: + break - for line in lines: - if line.startswith('event: '): - event_type = line[7:].strip() - elif line.startswith('data: '): - event_data = json.loads(line[6:]) - - if event_type == "message" and event_data: - # 累积内容 - chunk = event_data.get("content", "") - full_content += chunk - - # 转发消息块事件（带模型标识） - yield self._format_sse_event("model_message", { - "model_index": idx, - "model_config_id": model_config_id, - "label": model_label, - "content": chunk - }) - - except Exception as e: - logger.warning(f"解析流式事件失败: {e}") - finally: - # 恢复原始参数 - agent_config.model_parameters = original_params - - elapsed = time.time() - start_time - - # 模型完成 - result = { - "model_config_id": model_info["model_config_id"], - "model_name": model_info["model_config"].name, - "label": model_label, - "parameters_used": model_info["parameters"], - "message": full_content, - "elapsed_time": elapsed, - "error": None - } - results.append(result) - - # 发送模型完成事件 - yield self._format_sse_event("model_end", { - "model_index": idx, - "model_config_id": model_config_id, - "label": model_label, - "elapsed_time": elapsed, - "message_length": len(full_content), - "timestamp": time.time() - }) - - except asyncio.TimeoutError: - logger.warning(f"模型运行超时: {model_label}") - result = { - "model_config_id": model_info["model_config_id"], - "model_name": model_info["model_config"].name, - "label": model_label, - "elapsed_time": timeout, - "error": f"执行超时（{timeout}秒）" - } - results.append(result) - - # 发送模型错误事件 - yield self._format_sse_event("model_error", { - "model_index": idx, - "model_config_id": model_config_id, - "label": model_label, - "error": result["error"], - "timestamp": time.time() - }) - - except Exception as e: - logger.error(f"模型运行失败: {model_label}, error: {e}") - result = { - "model_config_id": model_info["model_config_id"], - "model_name": model_info["model_config"].name, - "label": model_label, - "elapsed_time": 0, - "error": str(e) - } - results.append(result) - - # 发送模型错误事件 - yield self._format_sse_event("model_error", { - "model_index": idx, - "model_config_id": model_config_id, - "label": model_label, - "error": str(e), - "timestamp": time.time() - }) - - # 统计分析 + # 统计分析（参考 run_compare） successful = [r for r in results if not r.get("error")] failed = [r for r in results if r.get("error")] fastest = min(successful, key=lambda x: x["elapsed_time"]) if successful else None + cheapest = min( + successful, + key=lambda x: x.get("cost_estimate") or float("inf") + ) if successful else None - # 发送对比完成事件 + # 构建结果摘要（包含完整的 message） + results_summary = [] + for r in results: + results_summary.append({ + "model_config_id": str(r["model_config_id"]), + "model_name": r["model_name"], + "label": r["label"], + "conversation_id": r.get("conversation_id"), + "message": r.get("message"), # 包含完整消息 + "elapsed_time": r.get("elapsed_time", 0), + "error": r.get("error") + }) + + # 发送对比完成事件（参考 run_compare 的返回格式） yield self._format_sse_event("compare_end", { "conversation_id": conversation_id, + "results": results_summary, # 包含完整结果 "total_elapsed_time": sum(r.get("elapsed_time", 0) for r in results), "successful_count": len(successful), "failed_count": len(failed), "fastest_model": fastest["label"] if fastest else None, + "cheapest_model": cheapest["label"] if cheapest else None, "timestamp": time.time() }) logger.info( - f"多模型对比流式完成", + "多模型对比流式完成", extra={ "successful": len(successful), - "failed": len(failed) + "failed": len(failed), + "total_time": sum(r.get("elapsed_time", 0) for r in results) } ) @@ -1603,7 +1520,7 @@ async def draft_run( top_k: int = 3 ) -> Dict[str, Any]: """试运行 Agent（便捷函数） - + Args: db: 数据库会话 agent_config: Agent 配置 @@ -1613,7 +1530,7 @@ async def draft_run( kb_ids: 知识库ID列表 similarity_threshold: 相似度阈值 top_k: 检索返回的文档数量 - + Returns: Dict: 包含 AI 回复和元数据的字典 """ diff --git a/api/app/services/llm_router.py b/api/app/services/llm_router.py index a6935862..089f2c07 100644 --- a/api/app/services/llm_router.py +++ b/api/app/services/llm_router.py @@ -88,7 +88,7 @@ class LLMRouter: 路由结果 """ logger.info( - f"开始 LLM 智能路由", + "开始 LLM 智能路由", extra={ "message_length": len(message), "conversation_id": conversation_id, @@ -177,7 +177,7 @@ class LLMRouter: } logger.info( - f"路由完成", + "路由完成", extra={ "agent_id": agent_id, "strategy": strategy, @@ -393,7 +393,7 @@ class LLMRouter: # 打印供应商信息 logger.info( - f"LLM 路由使用模型", + "LLM 路由使用模型", extra={ "provider": api_key_config.provider, "model_name": api_key_config.model_name, @@ -680,6 +680,6 @@ class LLMRouter: return self.routing_rules[0].get("target_agent_id") if self.sub_agents: - return list(self.sub_agents.keys())[0] + return next(iter(self.sub_agents.keys())) return "default-agent" diff --git a/api/app/services/master_agent_router.py b/api/app/services/master_agent_router.py new file mode 100644 index 00000000..aa473706 --- /dev/null +++ b/api/app/services/master_agent_router.py @@ -0,0 +1,593 @@ +"""Master Agent 路由器 - 让 Master Agent 真正成为决策中心""" +import json +import re +import uuid +from typing import Dict, Any, List, Optional, Tuple +from sqlalchemy.orm import Session + +from app.services.conversation_state_manager import ConversationStateManager +from app.models import ModelConfig, AgentConfig +from app.core.logging_config import get_business_logger + +logger = get_business_logger() + + +class MasterAgentRouter: + """Master Agent 路由器 + + 让 Master Agent 作为"大脑"，负责： + 1. 分析用户意图 + 2. 选择最合适的 Sub Agent + 3. 决定是否需要多 Agent 协作 + 4. 管理会话上下文 + + 优势： + - 更智能的决策（基于完整上下文） + - 减少 LLM 调用次数 + - 架构更清晰（Master Agent 真正起作用） + """ + + def __init__( + self, + db: Session, + master_agent_config: AgentConfig, + master_model_config: ModelConfig, + sub_agents: Dict[str, Any], + state_manager: ConversationStateManager, + enable_rule_fast_path: bool = True + ): + """初始化 Master Agent 路由器 + + Args: + db: 数据库会话 + master_agent_config: Master Agent 配置 + master_model_config: Master Agent 使用的模型配置 + sub_agents: 子 Agent 配置字典 + state_manager: 会话状态管理器 + enable_rule_fast_path: 是否启用规则快速路径（性能优化） + """ + self.db = db + self.master_agent_config = master_agent_config + self.master_model_config = master_model_config + self.sub_agents = sub_agents + self.state_manager = state_manager + self.enable_rule_fast_path = enable_rule_fast_path + + logger.info( + "Master Agent 路由器初始化", + extra={ + "master_agent": master_agent_config.name, + "sub_agent_count": len(sub_agents), + "enable_rule_fast_path": enable_rule_fast_path + } + ) + + async def route( + self, + message: str, + conversation_id: Optional[str] = None, + variables: Optional[Dict[str, Any]] = None + ) -> Dict[str, Any]: + """智能路由决策 + + Args: + message: 用户消息 + conversation_id: 会话 ID + variables: 变量参数 + + Returns: + 路由决策结果 + """ + logger.info( + "开始 Master Agent 路由", + extra={ + "message_length": len(message), + "conversation_id": conversation_id + } + ) + + # 1. 获取会话状态 + state = None + if conversation_id: + state = self.state_manager.get_state(conversation_id) + + # 2. 尝试规则快速路径（可选的性能优化） + if self.enable_rule_fast_path: + rule_result = self._try_rule_fast_path(message, state) + if rule_result: + logger.info( + "规则快速路径命中", + extra={ + "agent_id": rule_result["selected_agent_id"], + "confidence": rule_result["confidence"] + } + ) + + # 更新会话状态 + if conversation_id: + self.state_manager.update_state( + conversation_id, + rule_result["selected_agent_id"], + message, + rule_result.get("topic"), + rule_result["confidence"] + ) + + return rule_result + + # 3. 调用 Master Agent 做决策 + decision = await self._master_agent_decide(message, state, variables) + + # 4. 更新会话状态 + if conversation_id: + self.state_manager.update_state( + conversation_id, + decision["selected_agent_id"], + message, + decision.get("topic"), + decision["confidence"] + ) + + logger.info( + "Master Agent 路由完成", + extra={ + "agent_id": decision["selected_agent_id"], + "strategy": decision["strategy"], + "confidence": decision["confidence"] + } + ) + + return decision + + def _try_rule_fast_path( + self, + message: str, + state: Optional[Dict[str, Any]] + ) -> Optional[Dict[str, Any]]: + """尝试规则快速路径（性能优化） + + 对于明确的关键词匹配，直接返回结果，不调用 Master Agent + + Args: + message: 用户消息 + state: 会话状态 + + Returns: + 如果命中规则返回决策结果，否则返回 None + """ + # 定义高置信度关键词规则 + high_confidence_rules = [ + { + "keywords": ["数学", "方程", "计算", "求解"], + "agent_role": "数学", + "confidence_threshold": 0.9 + }, + { + "keywords": ["物理", "力学", "电路", "光学"], + "agent_role": "物理", + "confidence_threshold": 0.9 + }, + { + "keywords": ["订单", "发货", "物流", "快递"], + "agent_role": "订单", + "confidence_threshold": 0.9 + }, + { + "keywords": ["退款", "退货", "售后"], + "agent_role": "退款", + "confidence_threshold": 0.9 + } + ] + + message_lower = message.lower() + + for rule in high_confidence_rules: + matched_keywords = [kw for kw in rule["keywords"] if kw in message_lower] + + if matched_keywords: + confidence = len(matched_keywords) / len(rule["keywords"]) + + if confidence >= rule["confidence_threshold"]: + # 查找对应的 agent + for agent_id, agent_data in self.sub_agents.items(): + agent_info = agent_data.get("info", {}) + if agent_info.get("role") == rule["agent_role"]: + return { + "selected_agent_id": agent_id, + "confidence": confidence, + "strategy": "rule_fast_path", + "reasoning": f"关键词匹配: {', '.join(matched_keywords)}", + "topic": rule["agent_role"], + "need_collaboration": False, + "routing_method": "rule" + } + + return None + + async def _master_agent_decide( + self, + message: str, + state: Optional[Dict[str, Any]], + variables: Optional[Dict[str, Any]] + ) -> Dict[str, Any]: + """让 Master Agent 做路由决策 + + Args: + message: 用户消息 + state: 会话状态 + variables: 变量参数 + + Returns: + 决策结果 + """ + # 1. 构建决策 prompt + prompt = self._build_decision_prompt(message, state, variables) + + # 2. 调用 Master Agent 的 LLM + try: + response = await self._call_master_agent_llm(prompt) + + # 3. 解析决策 + decision = self._parse_decision(response) + + # 4. 验证决策 + decision = self._validate_decision(decision) + + return decision + + except Exception as e: + logger.error(f"Master Agent 决策失败: {str(e)}") + # 降级到默认 agent + return self._get_fallback_decision(message) + + def _build_decision_prompt( + self, + message: str, + state: Optional[Dict[str, Any]], + variables: Optional[Dict[str, Any]] + ) -> str: + """构建 Master Agent 的决策 prompt + + Args: + message: 用户消息 + state: 会话状态 + variables: 变量参数 + + Returns: + prompt 字符串 + """ + # 1. 构建 Sub Agent 描述（简化版，提升性能） + agent_descriptions = [] + for agent_id, agent_data in self.sub_agents.items(): + agent_info = agent_data.get("info", {}) + + name = agent_info.get("name", "未命名") + role = agent_info.get("role", "") + capabilities = agent_info.get("capabilities", []) + + # 简化格式：一行描述 + desc = f"- {agent_id}: {name}" + if role: + desc += f" ({role})" + if capabilities: + desc += f" - {', '.join(capabilities[:3])}" # 只取前3个能力 + + agent_descriptions.append(desc) + + agents_text = "\n".join(agent_descriptions) + + # 2. 构建会话上下文 + context_text = "" + if state: + current_agent = state.get("current_agent_id") + last_topic = state.get("last_topic") + same_turns = state.get("same_agent_turns", 0) + + if current_agent: + context_text = f""" +当前会话上下文： +- 当前使用的 Agent: {current_agent} +- 上一个主题: {last_topic} +- 连续使用轮数: {same_turns} +""" + + # 获取第一个可用的 agent_id 作为示例 + example_agent_id = next(iter(self.sub_agents.keys())) if self.sub_agents else "agent_id" + + # 3. 构建完整 prompt（简化版，提升性能） + prompt = f"""路由任务：分析问题并选择合适的 Agent。 + +可用 Agent： +{agents_text} +{context_text} +问题："{message}" + +返回 JSON 格式决策： + +**情况1：单一问题（最常见）** +{{"selected_agent_id": "{example_agent_id}", "confidence": 0.9, "need_collaboration": false, "reasoning": "选择理由"}} + +**情况2：需要拆分成多个独立子问题** +当用户问题包含多个完全独立的子问题时使用（如"写诗+做数学题"）。 +必须提供 sub_questions 数组，每个子问题必须指定 agent_id： +{{"selected_agent_id": "{example_agent_id}", "confidence": 0.9, "need_collaboration": true, "need_decomposition": true, + "sub_questions": [ + {{"question": "具体的子问题1", "agent_id": "{example_agent_id}", "order": 1, "depends_on": []}}, + {{"question": "具体的子问题2", "agent_id": "{example_agent_id}", "order": 2, "depends_on": []}} + ], + "collaboration_strategy": "decomposition", "reasoning": "问题包含X个独立子问题"}} + +**情况3：需要多个Agent协作分析同一问题** +{{"selected_agent_id": "{example_agent_id}", "confidence": 0.9, "need_collaboration": true, + "collaboration_agents": [{{"agent_id": "{example_agent_id}", "role": "primary", "task": "主要任务", "order": 1}}], + "collaboration_strategy": "sequential", "reasoning": "需要多角度分析"}} + +重要规则： +1. selected_agent_id 必须从上面的可用 Agent 列表中选择 +2. 如果选择情况2（拆分），sub_questions 数组不能为空，必须包含具体的子问题 +3. 每个子问题的 agent_id 也必须从可用列表中选择 +4. depends_on 表示依赖关系（如 [1] 表示依赖第1个子问题的结果） +5. 大多数情况应该选择情况1（单一Agent），只有明确需要时才拆分或协作 +6. 只做路由决策，不要回答问题内容 + +请返回 JSON：""" + + return prompt + + async def _call_master_agent_llm(self, prompt: str) -> str: + """调用 Master Agent 的 LLM + + Args: + prompt: 提示词 + + Returns: + LLM 响应 + """ + try: + from app.core.models import RedBearLLM + from app.core.models.base import RedBearModelConfig + from app.models import ModelApiKey, ModelType + + # 获取 API Key 配置 + api_key_config = self.db.query(ModelApiKey).filter( + ModelApiKey.model_config_id == self.master_model_config.id, + ModelApiKey.is_active == True + ).first() + + if not api_key_config: + raise Exception("Master Agent 模型没有可用的 API Key") + + logger.info( + "调用 Master Agent LLM", + extra={ + "provider": api_key_config.provider, + "model_name": api_key_config.model_name + } + ) + + # 创建 RedBearModelConfig + model_config = RedBearModelConfig( + model_name=api_key_config.model_name, + provider=api_key_config.provider, + api_key=api_key_config.api_key, + base_url=api_key_config.api_base, + temperature=0.3, # 决策任务使用较低温度 + max_tokens=1000 + ) + + # 创建 LLM 实例 + llm = RedBearLLM(model_config, type=ModelType.CHAT) + + # 调用模型 + response = await llm.ainvoke(prompt) + + # 提取响应内容 + if hasattr(response, 'content'): + return response.content + else: + return str(response) + + except Exception as e: + logger.error(f"Master Agent LLM 调用失败: {str(e)}") + raise + + def _parse_decision(self, response: str) -> Dict[str, Any]: + """解析 Master Agent 的决策 + + Args: + response: LLM 响应 + + Returns: + 决策字典 + """ + try: + # 提取 JSON + json_match = re.search(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', response, re.DOTALL) + if json_match: + decision = json.loads(json_match.group()) + + # 添加默认值 + decision.setdefault("confidence", 0.8) + decision.setdefault("strategy", "master_agent") + decision.setdefault("routing_method", "master_agent") + decision.setdefault("need_collaboration", False) + decision.setdefault("collaboration_agents", []) + + return decision + else: + raise ValueError("无法从响应中提取 JSON") + + except Exception as e: + logger.error(f"解析 Master Agent 决策失败: {str(e)}") + logger.debug(f"原始响应: {response}") + raise + + def _validate_decision(self, decision: Dict[str, Any]) -> Dict[str, Any]: + """验证决策的有效性 + + Args: + decision: 决策字典 + + Returns: + 验证后的决策 + """ + # 验证 agent_id + selected_agent_id = decision.get("selected_agent_id") + if selected_agent_id not in self.sub_agents: + logger.warning(f"Master Agent 返回的 agent_id 无效: {selected_agent_id}") + # 使用默认 agent + decision["selected_agent_id"] = self._get_default_agent_id() + decision["confidence"] = 0.5 + decision["reasoning"] = "原始选择无效，使用默认 Agent" + + # 验证 confidence + confidence = decision.get("confidence", 0.8) + if not isinstance(confidence, (int, float)) or confidence < 0 or confidence > 1: + decision["confidence"] = 0.8 + + # 验证协作 agents + if decision.get("need_collaboration"): + # 检查是否是问题拆分模式 + if decision.get("need_decomposition") or decision.get("sub_questions"): + # 问题拆分模式 + sub_questions = decision.get("sub_questions", []) + + # 验证每个子问题 + valid_sub_questions = [] + for sub_q in sub_questions: + if isinstance(sub_q, dict): + agent_id = sub_q.get("agent_id") + question = sub_q.get("question") + + if agent_id in self.sub_agents and question: + # 确保有必要的字段 + sub_q.setdefault("order", len(valid_sub_questions) + 1) + sub_q.setdefault("depends_on", []) + valid_sub_questions.append(sub_q) + else: + # 记录验证失败的原因 + logger.warning( + "子问题验证失败", + extra={ + "agent_id": agent_id, + "has_question": bool(question), + "agent_exists": agent_id in self.sub_agents if agent_id else False, + "available_agents": list(self.sub_agents.keys()) + } + ) + + decision["sub_questions"] = valid_sub_questions + + # 如果所有子问题都验证失败，降级处理 + if not valid_sub_questions and sub_questions: + logger.warning( + "所有子问题验证失败，降级到单 Agent 模式", + extra={ + "original_sub_question_count": len(sub_questions), + "available_agents": list(self.sub_agents.keys()) + } + ) + # 降级：取消协作标记，使用默认 Agent + decision["need_collaboration"] = False + decision["need_decomposition"] = False + decision["collaboration_strategy"] = None + # 选择第一个可用的 Agent + if self.sub_agents: + first_agent_id = next(iter(self.sub_agents.keys())) + decision["selected_agent_id"] = first_agent_id + logger.info(f"降级使用默认 Agent: {first_agent_id}") + + # 设置协作策略为 decomposition + decision["collaboration_strategy"] = "decomposition" + + logger.info( + "问题拆分决策验证完成", + extra={ + "sub_question_count": len(valid_sub_questions), + "strategy": "decomposition" + } + ) + else: + # 普通协作模式 + collaboration_agents = decision.get("collaboration_agents", []) + + # 如果是简单列表格式，转换为详细格式 + if collaboration_agents and isinstance(collaboration_agents[0], str): + collaboration_agents = [ + { + "agent_id": agent_id, + "role": "primary" if i == 0 else "secondary", + "task": "协作处理", + "order": i + 1 + } + for i, agent_id in enumerate(collaboration_agents) + ] + + # 验证每个协作 agent + valid_agents = [] + for agent_info in collaboration_agents: + if isinstance(agent_info, dict): + agent_id = agent_info.get("agent_id") + if agent_id in self.sub_agents: + # 确保有必要的字段 + agent_info.setdefault("role", "secondary") + agent_info.setdefault("task", "协作处理") + agent_info.setdefault("order", len(valid_agents) + 1) + valid_agents.append(agent_info) + elif isinstance(agent_info, str) and agent_info in self.sub_agents: + valid_agents.append({ + "agent_id": agent_info, + "role": "secondary", + "task": "协作处理", + "order": len(valid_agents) + 1 + }) + + decision["collaboration_agents"] = valid_agents + + # 设置默认协作策略 + if not decision.get("collaboration_strategy"): + decision["collaboration_strategy"] = "sequential" + + logger.info( + "协作决策验证完成", + extra={ + "collaboration_agent_count": len(valid_agents), + "strategy": decision.get("collaboration_strategy") + } + ) + + return decision + + def _get_fallback_decision(self, message: str) -> Dict[str, Any]: + """获取降级决策（当 Master Agent 失败时） + + Args: + message: 用户消息 + + Returns: + 降级决策 + """ + default_agent_id = self._get_default_agent_id() + + return { + "selected_agent_id": default_agent_id, + "confidence": 0.5, + "strategy": "fallback", + "reasoning": "Master Agent 决策失败，使用默认 Agent", + "topic": "未知", + "need_collaboration": False, + "collaboration_agents": [], + "routing_method": "fallback" + } + + def _get_default_agent_id(self) -> str: + """获取默认 Agent ID + + Returns: + 默认 Agent ID + """ + if self.sub_agents: + # 返回第一个 agent + return next(iter(self.sub_agents.keys())) + + return "default-agent" diff --git a/api/app/services/memory_agent_service.py b/api/app/services/memory_agent_service.py index d4336703..83c73f53 100644 --- a/api/app/services/memory_agent_service.py +++ b/api/app/services/memory_agent_service.py @@ -29,8 +29,7 @@ from app.core.memory.agent.utils.mcp_tools import get_mcp_server_config from app.core.memory.agent.utils.type_classifier import status_typle from app.db import get_db from app.repositories.neo4j.neo4j_connector import Neo4jConnector -# TODO 后续更新 -# from app.core.memory.analytics.hot_memory_tags import get_hot_memory_tags +from app.core.memory.analytics.hot_memory_tags import get_hot_memory_tags from app.core.memory.utils.llm.llm_utils import get_llm_client from app.schemas.memory_storage_schema import ApiResponse, ok, fail from app.models.knowledge_model import Knowledge, KnowledgeType @@ -697,7 +696,7 @@ class MemoryAgentService: logger.info(f"知识库类型统计成功 (workspace_id={current_workspace_id}): {result}") else: # 没有提供 workspace_id，所有知识库类型返回 0 - logger.info(f"未提供 workspace_id，知识库类型统计全部为 0") + logger.info("未提供 workspace_id，知识库类型统计全部为 0") except Exception as e: logger.error(f"知识库类型统计失败: {e}") @@ -720,7 +719,7 @@ class MemoryAgentService: end_users = [] for app_id in app_ids: end_user_orm_list = end_user_repository.get_end_users_by_app_id(db, app_id) - end_users.extend([EndUserSchema.model_validate(h) for h in end_user_orm_list]) + end_users.extend(h for h in end_user_orm_list) # 统计所有宿主的 Chunk 总数 total_chunks = 0 @@ -742,7 +741,7 @@ class MemoryAgentService: else: # 没有 workspace_id 时，返回 0 result["memory"] = 0 - logger.info(f"未提供 workspace_id，memory 统计为 0") + logger.info("未提供 workspace_id，memory 统计为 0") except Exception as e: logger.error(f"Neo4j memory统计失败: {e}", exc_info=True) diff --git a/api/app/services/memory_dashboard_service.py b/api/app/services/memory_dashboard_service.py index 31a6db3d..be4ec12f 100644 --- a/api/app/services/memory_dashboard_service.py +++ b/api/app/services/memory_dashboard_service.py @@ -1,5 +1,5 @@ from sqlalchemy.orm import Session -from typing import List +from typing import List, Optional import uuid from fastapi import HTTPException @@ -24,6 +24,30 @@ from app.core.logging_config import get_business_logger business_logger = get_business_logger() +def get_current_workspace_type( + db: Session, + workspace_id: uuid.UUID, + current_user: User +) -> Optional[str]: + """获取当前工作空间类型""" + business_logger.info(f"获取工作空间类型: workspace_id={workspace_id}, 操作者: {current_user.username}") + + try: + from app.repositories.workspace_repository import get_workspace_by_id + + workspace = get_workspace_by_id(db, workspace_id) + if not workspace: + business_logger.warning(f"工作空间不存在: workspace_id={workspace_id}") + return None + + business_logger.info(f"成功获取工作空间类型: {workspace.storage_type}") + return workspace.storage_type + + except Exception as e: + business_logger.error(f"获取工作空间类型失败: workspace_id={workspace_id} - {str(e)}") + raise + + def get_workspace_end_users( db: Session, workspace_id: uuid.UUID, @@ -169,7 +193,7 @@ def get_workspace_memory_list( business_logger.warning(f"获取宿主列表失败: {str(e)}") result["hosts"] = [] - business_logger.info(f"成功获取工作空间记忆列表") + business_logger.info("成功获取工作空间记忆列表") return result except HTTPException: @@ -587,7 +611,7 @@ async def get_chunk_insight( "insight": insight } - business_logger.info(f"成功获取chunk洞察") + business_logger.info("成功获取chunk洞察") return result except Exception as e: diff --git a/api/app/services/memory_konwledges_server.py b/api/app/services/memory_konwledges_server.py index dd9163a7..c6297e12 100644 --- a/api/app/services/memory_konwledges_server.py +++ b/api/app/services/memory_konwledges_server.py @@ -168,7 +168,7 @@ async def get_document_chunks( # 执行分页查询 try: - api_logger.debug(f"开始执行文档块查询") + api_logger.debug("开始执行文档块查询") vector_service = ElasticSearchVectorFactory().init_vector(knowledge=db_knowledge) total, items = vector_service.search_by_segment( document_id=str(document_id), @@ -516,67 +516,18 @@ async def write_rag(group_id, message, user_rag_memory_id): db=db, current_user=current_user ) - await parse_document_by_id(document, db=db, current_user=current_user) + # 重新查询刚创建的文档ID + new_document_id = find_document_id_by_kb_and_filename( + db=db, + kb_id=user_rag_memory_id, + file_name=f"{group_id}.txt" + ) + + if new_document_id: + await parse_document_by_id(new_document_id, db=db, current_user=current_user) + else: + api_logger.error(f"创建文档后无法找到文档ID: group_id={group_id}") return result finally: # 确保数据库会话被关闭 - db.close() -# 在异步环境中调用示例 - - -async def example_usage(): - - # 获取数据库会话 - db_gen = get_db() - db = next(db_gen) - - # 创建 CustomTextFileCreate 对象 - title = '2f6ff1eb-50c7-4765-8e89-e4566be19122' - create_data = CustomTextFileCreate( - title=title, - content="莫扎特在巴黎经历母亲去世后返回萨尔茨堡，他随后创作的交响曲主题是否与格鲁克在维也纳推动的“改革歌剧”理念存在共通之处？贝多芬早年曾师从海顿，而海顿又受雇于埃斯特哈齐家族——这种师承体系如何影响了当时欧洲宫廷音乐的传承结构？斯卡拉歌剧院选择萨列里的歌剧作为开幕演出，是否与当时米兰政治环境和奥地利宫廷影响有关？" - ) - - # 创建用户对象 - current_user = SimpleUser("6243c125-9420-402c-bbb5-d1977811ac96") - - # 上传文件 - result = await memory_konwledges_up( - kb_id="c71df60a-36a6-4759-a2ce-101e3087b401", - parent_id="c71df60a-36a6-4759-a2ce-101e3087b401", - create_data=create_data, - db=db, - current_user=current_user - ) - print(result) - #找到document_id - - # 使用刚创建的文档ID进行解析 - document = find_document_id_by_kb_and_filename(db=db, kb_id="c71df60a-36a6-4759-a2ce-101e3087b401", file_name=f"{title}.txt") - print('====',document) - res___=await parse_document_by_id(document, db=db, current_user=current_user) - print(res___) - - # result='e8cf9ace-d1a9-4af2-b0c4-3fc94f4f8042' - # document_id='d22e8173-50d0-4e10-a7de-aa638ef893bc' - # - # '''更新块''' - # - # new_content = "这是新的 chunk 内容，用来覆盖原来的内容" - # # 构造 ChunkUpdate 对象 - # update_data = ChunkCreate(content=new_content) - # updated_chunk = await create_document_chunk( - # kb_id= result, - # document_id=document_id, - # create_data= update_data, - # db=db, - # current_user=current_user - # ) - # print(updated_chunk) - return '','','' - - - -if __name__ == "__main__": - # asyncio.run(example_usage()) - asyncio.run(write_rag('1111','22222',"c71df60a-36a6-4759-a2ce-101e3087b401")) \ No newline at end of file + db.close() \ No newline at end of file diff --git a/api/app/services/memory_storage_service.py b/api/app/services/memory_storage_service.py index 7ba14f3d..51ca9619 100644 --- a/api/app/services/memory_storage_service.py +++ b/api/app/services/memory_storage_service.py @@ -7,9 +7,12 @@ Handles business logic for memory storage operations. from typing import Dict, List, Optional, Any import os import json +from sqlalchemy.orm import Session from dotenv import load_dotenv +from app.models.user_model import User +from app.models.end_user_model import EndUser from app.core.logging_config import get_logger from app.schemas.memory_storage_schema import ( ConfigFilter, @@ -23,11 +26,10 @@ from app.schemas.memory_storage_schema import ( ) from app.repositories.data_config_repository import DataConfigRepository from app.repositories.neo4j.neo4j_connector import Neo4jConnector -# TODO 后续更新 -# from app.core.memory.analytics.hot_memory_tags import get_hot_memory_tags -# from app.core.memory.analytics.memory_insight import MemoryInsight -# from app.core.memory.analytics.recent_activity_stats import get_recent_activity_stats -# from app.core.memory.analytics.user_summary import generate_user_summary +from app.core.memory.analytics.hot_memory_tags import get_hot_memory_tags +from app.core.memory.analytics.memory_insight import MemoryInsight +from app.core.memory.analytics.recent_activity_stats import get_recent_activity_stats +from app.core.memory.analytics.user_summary import generate_user_summary from app.repositories.data_config_repository import DataConfigRepository logger = get_logger(__name__) @@ -52,7 +54,7 @@ class MemoryStorageService: Returns: Storage information dictionary """ - logger.info(f"Getting storage info ") + logger.info("Getting storage info ") # Empty wrapper - implement your logic here result = { @@ -65,30 +67,28 @@ class MemoryStorageService: class DataConfigService: # 数据配置服务类（PostgreSQL） """Service layer for config params CRUD. - The DB connection is optional; when absent, methods return a failure - response containing an SQL preview to aid integration. + 使用 SQLAlchemy ORM 进行数据库操作。 """ - def __init__(self, db_conn: Optional[Any] = None) -> None: - self.db_conn = db_conn - - # --- Driver compatibility helpers --- - @staticmethod - def _is_pgsql_conn(conn: Any) -> bool: # 判断是否为 PostgreSQL 连接 - mod = type(conn).__module__ - return ("psycopg2" in mod) or ("psycopg" in mod) - + def __init__(self, db: Session) -> None: + """初始化服务 + + Args: + db: SQLAlchemy 数据库会话 + """ + self.db = db + @staticmethod def _convert_timestamps_to_format(data_list: List[Dict[str, Any]]) -> List[Dict[str, Any]]: """将 created_at 和 updated_at 字段从 datetime 对象转换为 YYYYMMDDHHmmss 格式""" from datetime import datetime - + for item in data_list: for field in ['created_at', 'updated_at']: if field in item and item[field] is not None: value = item[field] dt = None - + # 如果是 datetime 对象，直接使用 if isinstance(value, datetime): dt = value @@ -98,24 +98,21 @@ class DataConfigService: # 数据配置服务类（PostgreSQL） dt = datetime.fromisoformat(value.replace('Z', '+00:00')) except Exception: pass # 保持原值 - + # 转换为 YYYYMMDDHHmmss 格式 if dt: item[field] = dt.strftime('%Y%m%d%H%M%S') - + return data_list # --- Create --- def create(self, params: ConfigParamsCreate) -> Dict[str, Any]: # 创建配置参数（仅名称与描述） - if self.db_conn is None: - raise ConnectionError("数据库连接未配置") - # 如果workspace_id存在且模型字段未全部指定，则自动获取 if params.workspace_id and not all([params.llm_id, params.embedding_id, params.rerank_id]): configs = self._get_workspace_configs(params.workspace_id) if configs is None: raise ValueError(f"工作空间不存在: workspace_id={params.workspace_id}") - + # 只在未指定时填充（允许手动覆盖） if not params.llm_id: params.llm_id = configs.get('llm') @@ -123,19 +120,16 @@ class DataConfigService: # 数据配置服务类（PostgreSQL） params.embedding_id = configs.get('embedding') if not params.rerank_id: params.rerank_id = configs.get('rerank') - - query, qparams = DataConfigRepository.build_insert(params) - cur = self.db_conn.cursor() - # PostgreSQL 使用 psycopg2 的命名参数格式 - cur.execute(query, qparams) - self.db_conn.commit() - return {"affected": getattr(cur, "rowcount", None)} - + + config = DataConfigRepository.create(self.db, params) + self.db.commit() + return {"affected": 1, "config_id": config.config_id} + def _get_workspace_configs(self, workspace_id) -> Optional[Dict[str, Any]]: """获取工作空间模型配置（内部方法，便于测试）""" from app.db import SessionLocal from app.repositories.workspace_repository import get_workspace_models_configs - + db_session = SessionLocal() try: return get_workspace_models_configs(db_session, workspace_id) @@ -143,121 +137,91 @@ class DataConfigService: # 数据配置服务类（PostgreSQL） db_session.close() # --- Delete --- - def delete(self, key: ConfigParamsDelete) -> Dict[str, Any]: # 删除配置参数（按配置名称） - query, qparams = DataConfigRepository.build_delete(key) - if self.db_conn is None: - raise ConnectionError("数据库连接未配置") - - cur = self.db_conn.cursor() - cur.execute(query, qparams) - affected = getattr(cur, "rowcount", None) - self.db_conn.commit() - # 如果没有任何行被删除，抛出异常 - if not affected: + def delete(self, key: ConfigParamsDelete) -> Dict[str, Any]: # 删除配置参数（按配置ID） + success = DataConfigRepository.delete(self.db, key.config_id) + if not success: raise ValueError("未找到配置") - return {"affected": affected} + return {"affected": 1} # --- Update --- def update(self, update: ConfigUpdate) -> Dict[str, Any]: # 部分更新配置参数 - query, qparams = DataConfigRepository.build_update(update) - - if self.db_conn is None: - raise ConnectionError("数据库连接未配置") - - cur = self.db_conn.cursor() - cur.execute(query, qparams) - affected = getattr(cur, "rowcount", None) - self.db_conn.commit() - if not affected: + config = DataConfigRepository.update(self.db, update) + if not config: raise ValueError("未找到配置") - return {"affected": affected} - - + return {"affected": 1} def update_extracted(self, update: ConfigUpdateExtracted) -> Dict[str, Any]: # 更新记忆萃取引擎配置参数 - query, qparams = DataConfigRepository.build_update_extracted(update) - - if self.db_conn is None: - raise ConnectionError("数据库连接未配置") - - cur = self.db_conn.cursor() - cur.execute(query, qparams) - affected = getattr(cur, "rowcount", None) - self.db_conn.commit() - if not affected: + config = DataConfigRepository.update_extracted(self.db, update) + if not config: raise ValueError("未找到配置") - return {"affected": affected} + return {"affected": 1} - # --- Forget config params --- def update_forget(self, update: ConfigUpdateForget) -> Dict[str, Any]: # 保存遗忘引擎的配置 - query, qparams = DataConfigRepository.build_update_forget(update) - - if self.db_conn is None: - raise ConnectionError("数据库连接未配置") - - cur = self.db_conn.cursor() - cur.execute(query, qparams) - affected = getattr(cur, "rowcount", None) - self.db_conn.commit() - if not affected: + config = DataConfigRepository.update_forget(self.db, update) + if not config: raise ValueError("未找到配置") - return {"affected": affected} - + return {"affected": 1} + # --- Read --- - def get_extracted(self, key: ConfigKey) -> Dict[str, Any]: # 获取配置参数 - query, qparams = DataConfigRepository.build_select_extracted(key) - if self.db_conn is None: - raise ConnectionError("数据库连接未配置") - - cur = self.db_conn.cursor() - cur.execute(query, qparams) - row = cur.fetchone() - if not row: + def get_extracted(self, key: ConfigKey) -> Dict[str, Any]: # 获取萃取配置参数 + result = DataConfigRepository.get_extracted_config(self.db, key.config_id) + if not result: raise ValueError("未找到配置") - # Map row to dict (DB-API cursor description available for many drivers) - columns = [desc[0] for desc in cur.description] - raw = {columns[i]: row[i] for i in range(len(columns))} - # 将 created_at 和 updated_at 转换为 YYYYMMDDHHmmss 格式 - data_list = self._convert_timestamps_to_format([raw]) - return data_list[0] if data_list else raw + return result - def get_forget(self, key: ConfigKey) -> Dict[str, Any]: # 获取配置参数 - query, qparams = DataConfigRepository.build_select_forget(key) - if self.db_conn is None: - raise ConnectionError("数据库连接未配置") - - cur = self.db_conn.cursor() - cur.execute(query, qparams) - row = cur.fetchone() - if not row: + def get_forget(self, key: ConfigKey) -> Dict[str, Any]: # 获取遗忘配置参数 + result = DataConfigRepository.get_forget_config(self.db, key.config_id) + if not result: raise ValueError("未找到配置") - # Map row to dict (DB-API cursor description available for many drivers) - columns = [desc[0] for desc in cur.description] - raw = {columns[i]: row[i] for i in range(len(columns))} - # 将 created_at 和 updated_at 转换为 YYYYMMDDHHmmss 格式 - data_list = self._convert_timestamps_to_format([raw]) - return data_list[0] if data_list else raw + return result # --- Read All --- def get_all(self, workspace_id = None) -> List[Dict[str, Any]]: # 获取所有配置参数 - query, qparams = DataConfigRepository.build_select_all(workspace_id) - if self.db_conn is None: - raise ConnectionError("数据库连接未配置") + configs = DataConfigRepository.get_all(self.db, workspace_id) - cur = self.db_conn.cursor() - cur.execute(query, qparams) - rows = cur.fetchall() - # 如果没有查询到任何配置，返回空列表（这是正常情况，不应抛出异常） - if not rows: - return [] - # Map rows to list of dicts - columns = [desc[0] for desc in cur.description] - data_list = [dict(zip(columns, row)) for row in rows] - # 将 UUID 转换为字符串，将 created_at 和 updated_at 转换为 YYYYMMDDHHmmss 格式 - for item in data_list: - if 'workspace_id' in item and item['workspace_id'] is not None: - item['workspace_id'] = str(item['workspace_id']) + # 将 ORM 对象转换为字典列表 + data_list = [] + for config in configs: + config_dict = { + "config_id": config.config_id, + "config_name": config.config_name, + "config_desc": config.config_desc, + "workspace_id": str(config.workspace_id) if config.workspace_id else None, + "group_id": config.group_id, + "user_id": config.user_id, + "apply_id": config.apply_id, + "llm_id": config.llm_id, + "embedding_id": config.embedding_id, + "rerank_id": config.rerank_id, + "llm": config.llm, + "enable_llm_dedup_blockwise": config.enable_llm_dedup_blockwise, + "enable_llm_disambiguation": config.enable_llm_disambiguation, + "deep_retrieval": config.deep_retrieval, + "t_type_strict": config.t_type_strict, + "t_name_strict": config.t_name_strict, + "t_overall": config.t_overall, + "state": config.state, + "chunker_strategy": config.chunker_strategy, + "pruning_enabled": config.pruning_enabled, + "pruning_scene": config.pruning_scene, + "pruning_threshold": config.pruning_threshold, + "enable_self_reflexion": config.enable_self_reflexion, + "iteration_period": config.iteration_period, + "reflexion_range": config.reflexion_range, + "baseline": config.baseline, + "statement_granularity": config.statement_granularity, + "include_dialogue_context": config.include_dialogue_context, + "max_context": config.max_context, + "lambda_time": config.lambda_time, + "lambda_mem": config.lambda_mem, + "offset": config.offset, + "created_at": config.created_at, + "updated_at": config.updated_at, + } + data_list.append(config_dict) + + # 将 created_at 和 updated_at 转换为 YYYYMMDDHHmmss 格式 return self._convert_timestamps_to_format(data_list) @@ -296,7 +260,7 @@ class DataConfigService: # 数据配置服务类（PostgreSQL） # 应用内存覆写并刷新常量（在导入主管线前） # 注意：仅在内存中覆写配置，不修改 runtime.json 文件 from app.core.memory.utils.config.definitions import reload_configuration_from_database - + ok_override = reload_configuration_from_database(cid) if not ok_override: raise RuntimeError("运行时覆写失败，config_id 无效或刷新常量失败") @@ -308,7 +272,7 @@ class DataConfigService: # 数据配置服务类（PostgreSQL） logger.info(f"[PILOT_RUN] Calling pipeline_main with dialogue_text length: {len(dialogue_text)}, is_pilot_run=True") await pipeline_main(dialogue_text=dialogue_text, is_pilot_run=True) logger.info("[PILOT_RUN] pipeline_main completed") - + # 调用自我反思 # data = [ # { @@ -346,10 +310,10 @@ class DataConfigService: # 数据配置服务类（PostgreSQL） result_path = settings.get_memory_output_path("extracted_result.json") if not os.path.isfile(result_path): raise FileNotFoundError(f"试运行完成，但未找到提取结果文件: {result_path}") - + with open(result_path, "r", encoding="utf-8") as rf: extracted_result = json.load(rf) - + extracted_result["self_reflexion"] = reflexion_result if reflexion_result else None return { "config_id": cid, @@ -405,7 +369,7 @@ async def search_all(end_user_id: Optional[str] = None) -> Dict[str, Any]: DataConfigRepository.SEARCH_FOR_ALL, group_id=end_user_id, ) - + # 检查结果是否为空或长度不足 if not result or len(result) < 4: data = { @@ -418,7 +382,7 @@ async def search_all(end_user_id: Optional[str] = None) -> Dict[str, Any]: }, } return data - + data = { "total": result[-1]["Count"], "counts": { @@ -504,14 +468,27 @@ async def search_entity_graph(end_user_id: Optional[str] = None) -> Dict[str, An return data -async def analytics_hot_memory_tags(end_user_id: Optional[str] = None, limit: int = 10) -> List[Dict[str, Any]]: +async def analytics_hot_memory_tags( + db: Session, + current_user: User, + limit: int = 10 +) -> List[Dict[str, Any]]: """ 获取热门记忆标签，按数量排序并返回前N个 """ + workspace_id = current_user.current_workspace_id # 获取更多标签供LLM筛选（获取limit*4个标签） raw_limit = limit * 4 - tags = await get_hot_memory_tags(end_user_id, limit=raw_limit) + from app.services.memory_dashboard_service import get_workspace_end_users + end_users = get_workspace_end_users(db, workspace_id, current_user) + tags = [] + for end_user in end_users: + tag = await get_hot_memory_tags(str(end_user.id), limit=raw_limit) + if tag: + # 将每个用户的标签列表展平到总列表中 + tags.extend(tag) + # 按频率降序排序（虽然数据库已经排序，但为了确保正确性再次排序） sorted_tags = sorted(tags, key=lambda x: x[1], reverse=True) diff --git a/api/app/services/model_parameter_merger.py b/api/app/services/model_parameter_merger.py index 25506f1c..262e3d49 100644 --- a/api/app/services/model_parameter_merger.py +++ b/api/app/services/model_parameter_merger.py @@ -53,13 +53,13 @@ class ModelParameterMerger: # 应用模型配置参数 if model_config_params: - for key in default_params.keys(): + for key in default_params: if key in model_config_params: merged[key] = model_config_params[key] # 应用 Agent 配置参数（优先级最高） if agent_config_params: - for key in default_params.keys(): + for key in default_params: if key in agent_config_params and agent_config_params[key] is not None: merged[key] = agent_config_params[key] @@ -67,7 +67,7 @@ class ModelParameterMerger: merged = {k: v for k, v in merged.items() if v is not None} logger.debug( - f"参数合并完成", + "参数合并完成", extra={ "model_params": model_config_params, "agent_params": agent_config_params, diff --git a/api/app/services/model_service.py b/api/app/services/model_service.py index b6fb0560..1d2822c0 100644 --- a/api/app/services/model_service.py +++ b/api/app/services/model_service.py @@ -24,17 +24,17 @@ class ModelConfigService: """模型配置服务""" @staticmethod - def get_model_by_id(db: Session, model_id: uuid.UUID) -> ModelConfig: + def get_model_by_id(db: Session, model_id: uuid.UUID, tenant_id: uuid.UUID | None = None) -> ModelConfig: """根据ID获取模型配置""" - model = ModelConfigRepository.get_by_id(db, model_id) + model = ModelConfigRepository.get_by_id(db, model_id, tenant_id=tenant_id) if not model: raise BusinessException("模型配置不存在", BizCode.MODEL_NOT_FOUND) return model @staticmethod - def get_model_list(db: Session, query: ModelConfigQuery) -> PageData: + def get_model_list(db: Session, query: ModelConfigQuery, tenant_id: uuid.UUID | None = None) -> PageData: """获取模型配置列表""" - models, total = ModelConfigRepository.get_list(db, query) + models, total = ModelConfigRepository.get_list(db, query, tenant_id=tenant_id) pages = math.ceil(total / query.pagesize) if total > 0 else 0 return PageData( @@ -48,17 +48,17 @@ class ModelConfigService: ) @staticmethod - def get_model_by_name(db: Session, name: str) -> ModelConfig: + def get_model_by_name(db: Session, name: str, tenant_id: uuid.UUID | None = None) -> ModelConfig: """根据名称获取模型配置""" - model = ModelConfigRepository.get_by_name(db, name) + model = ModelConfigRepository.get_by_name(db, name, tenant_id=tenant_id) if not model: raise BusinessException("模型配置不存在", BizCode.MODEL_NOT_FOUND) return model @staticmethod - def search_models_by_name(db: Session, name: str, limit: int = 10) -> List[ModelConfig]: + def search_models_by_name(db: Session, name: str, tenant_id: uuid.UUID | None = None, limit: int = 10) -> List[ModelConfig]: """按名称模糊匹配获取模型配置列表""" - return ModelConfigRepository.search_by_name(db, name, limit) + return ModelConfigRepository.search_by_name(db, name, tenant_id=tenant_id, limit=limit) @staticmethod async def validate_model_config( @@ -220,10 +220,10 @@ class ModelConfigService: } @staticmethod - async def create_model(db: Session, model_data: ModelConfigCreate) -> ModelConfig: + async def create_model(db: Session, model_data: ModelConfigCreate, tenant_id: uuid.UUID) -> ModelConfig: """创建模型配置""" - # 检查名称是否已存在 - if ModelConfigRepository.get_by_name(db, model_data.name): + # 检查名称是否已存在（同租户内） + if ModelConfigRepository.get_by_name(db, model_data.name, tenant_id=tenant_id): raise BusinessException("模型名称已存在", BizCode.DUPLICATE_NAME) # 验证配置 @@ -247,6 +247,8 @@ class ModelConfigService: # 事务处理 api_key_data = model_data.api_keys model_config_data = model_data.dict(exclude={"api_keys", "skip_validation"}) + # 添加租户ID + model_config_data["tenant_id"] = tenant_id model = ModelConfigRepository.create(db, model_config_data) db.flush() # 获取生成的 ID @@ -263,28 +265,28 @@ class ModelConfigService: return model @staticmethod - def update_model(db: Session, model_id: uuid.UUID, model_data: ModelConfigUpdate) -> ModelConfig: + def update_model(db: Session, model_id: uuid.UUID, model_data: ModelConfigUpdate, tenant_id: uuid.UUID | None = None) -> ModelConfig: """更新模型配置""" - existing_model = ModelConfigRepository.get_by_id(db, model_id) + existing_model = ModelConfigRepository.get_by_id(db, model_id, tenant_id=tenant_id) if not existing_model: raise BusinessException("模型配置不存在", BizCode.MODEL_NOT_FOUND) if model_data.name and model_data.name != existing_model.name: - if ModelConfigRepository.get_by_name(db, model_data.name): + if ModelConfigRepository.get_by_name(db, model_data.name, tenant_id=tenant_id): raise BusinessException("模型名称已存在", BizCode.DUPLICATE_NAME) - model = ModelConfigRepository.update(db, model_id, model_data) + model = ModelConfigRepository.update(db, model_id, model_data, tenant_id=tenant_id) db.commit() db.refresh(model) return model @staticmethod - def delete_model(db: Session, model_id: uuid.UUID) -> bool: + def delete_model(db: Session, model_id: uuid.UUID, tenant_id: uuid.UUID | None = None) -> bool: """删除模型配置""" - if not ModelConfigRepository.get_by_id(db, model_id): + if not ModelConfigRepository.get_by_id(db, model_id, tenant_id=tenant_id): raise BusinessException("模型配置不存在", BizCode.MODEL_NOT_FOUND) - success = ModelConfigRepository.delete(db, model_id) + success = ModelConfigRepository.delete(db, model_id, tenant_id=tenant_id) db.commit() return success diff --git a/api/app/services/multi_agent_orchestrator.py b/api/app/services/multi_agent_orchestrator.py index b62ab690..18315714 100644 --- a/api/app/services/multi_agent_orchestrator.py +++ b/api/app/services/multi_agent_orchestrator.py @@ -1,13 +1,13 @@ -"""多 Agent 编排器""" +"""多 Agent 编排器 - Master Agent 作为决策中心""" import uuid import time import asyncio -from typing import Dict, Any, List, Optional +from typing import Dict, Any, List, Optional, AsyncIterator, Tuple from sqlalchemy.orm import Session from app.models import MultiAgentConfig, AgentConfig, ModelConfig from app.services.agent_registry import AgentRegistry -from app.services.llm_router import LLMRouter +from app.services.master_agent_router import MasterAgentRouter from app.services.conversation_state_manager import ConversationStateManager from app.core.exceptions import BusinessException, ResourceNotFoundException from app.core.error_codes import BizCode @@ -43,35 +43,34 @@ class MultiAgentOrchestrator: "info": sub_agent_info } - # 初始化 LLM 路由器（使用主 Agent 的模型） - self.llm_router = None - if self.master_agent and hasattr(self.master_agent, 'default_model_config_id'): - routing_model = self.db.get(ModelConfig, self.master_agent.default_model_config_id) - if routing_model: - state_manager = ConversationStateManager() - self.llm_router = LLMRouter( - db=db, - state_manager=state_manager, - routing_rules=config.routing_rules or [], - sub_agents=self.sub_agents, - routing_model_config=routing_model, - use_llm=True - ) - logger.info( - f"LLM 路由器已初始化（使用主 Agent 模型）", - extra={ - "routing_model": routing_model.name, - "routing_model_id": str(routing_model.id) - } - ) + # 初始化会话状态管理器 + self.state_manager = ConversationStateManager() + + # 获取 Master Agent 的模型配置 + if not hasattr(self.master_agent, 'default_model_config_id'): + raise BusinessException("Master Agent 缺少模型配置", BizCode.AGENT_CONFIG_MISSING) + + self.master_model_config = self.db.get(ModelConfig, self.master_agent.default_model_config_id) + if not self.master_model_config: + raise BusinessException("Master Agent 模型配置不存在", BizCode.AGENT_CONFIG_MISSING) + + # 初始化 Master Agent 路由器 + self.router = MasterAgentRouter( + db=db, + master_agent_config=self.master_agent, + master_model_config=self.master_model_config, + sub_agents=self.sub_agents, + state_manager=self.state_manager, + enable_rule_fast_path=config.execution_config.get("enable_rule_fast_path", True) + ) logger.info( - f"多 Agent 编排器初始化", + "多 Agent 编排器初始化完成", extra={ "config_id": str(config.id), - "mode": config.orchestration_mode, - "sub_agent_count": len(self.sub_agents), - "has_llm_router": self.llm_router is not None + "master_agent": self.master_agent.name, + "model": self.master_model_config.name, + "sub_agent_count": len(self.sub_agents) } ) @@ -104,7 +103,7 @@ class MultiAgentOrchestrator: start_time = time.time() logger.info( - f"开始执行多 Agent 任务（流式）", + "开始执行多 Agent 任务（流式）", extra={ "mode": self.config.orchestration_mode, "message_length": len(message) @@ -201,7 +200,7 @@ class MultiAgentOrchestrator: }) logger.info( - f"多 Agent 任务完成（流式）", + "多 Agent 任务完成（流式）", extra={ "mode": self.config.orchestration_mode, "elapsed_time": elapsed_time @@ -210,7 +209,7 @@ class MultiAgentOrchestrator: except Exception as e: logger.error( - f"多 Agent 任务执行失败（流式）", + "多 Agent 任务执行失败（流式）", extra={"error": str(e), "mode": self.config.orchestration_mode} ) # 发送错误事件 @@ -229,13 +228,14 @@ class MultiAgentOrchestrator: web_search: bool = False, memory: bool = True ) -> Dict[str, Any]: - """执行多 Agent 任务 + """执行多 Agent 任务（基于 Master Agent 决策） Args: message: 用户消息 conversation_id: 会话 ID user_id: 用户 ID variables: 变量参数 + use_llm_routing: 是否使用 LLM 路由（保留参数，实际总是使用 Master Agent） Returns: 执行结果 @@ -243,56 +243,33 @@ class MultiAgentOrchestrator: start_time = time.time() logger.info( - f"开始执行多 Agent 任务", - extra={ - "mode": self.config.orchestration_mode, - "message_length": len(message) - } + "开始执行多 Agent 任务", + extra={"message_length": len(message)} ) try: - # 1. 主 Agent 分析任务 + # 1. Master Agent 分析任务并做出决策 task_analysis = await self._analyze_task(message, variables) - task_analysis["use_llm_routing"] = use_llm_routing - # 2. 根据模式执行 - if self.config.orchestration_mode == "sequential": - results = await self._execute_sequential( - task_analysis, - conversation_id, - user_id, - web_search, - memory - ) - elif self.config.orchestration_mode == "parallel": - results = await self._execute_parallel( - task_analysis, - conversation_id, - user_id, - web_search, - memory - ) - elif self.config.orchestration_mode == "conditional": - results = await self._execute_conditional( - task_analysis, - conversation_id, - user_id, - web_search, - memory - ) - elif self.config.orchestration_mode == "loop": - results = await self._execute_loop( - task_analysis, - conversation_id, - user_id, - web_search, - memory - ) - else: - raise BusinessException( - f"不支持的编排模式: {self.config.orchestration_mode}", - BizCode.INVALID_PARAMETER - ) + routing_decision = task_analysis.get("routing_decision") + if not routing_decision: + raise BusinessException("Master Agent 未返回路由决策", BizCode.AGENT_CONFIG_MISSING) + + logger.info( + "Master Agent 决策", + extra={ + "need_collaboration": routing_decision.get("need_collaboration"), + "strategy": routing_decision.get("collaboration_strategy"), + "confidence": routing_decision.get("confidence") + } + ) + + # 2. 根据 Master Agent 的决策执行 + results = await self._execute_conditional( + task_analysis, + conversation_id, + user_id + ) # 3. 整合结果 final_result = await self._aggregate_results(results) @@ -302,10 +279,8 @@ class MultiAgentOrchestrator: # 4. 提取子 Agent 的 conversation_id（用于多轮对话） sub_conversation_id = None if isinstance(results, dict): - # conditional 或 loop 模式 sub_conversation_id = results.get("conversation_id") or results.get("result", {}).get("conversation_id") elif isinstance(results, list) and results: - # sequential 或 parallel 模式，使用第一个成功的结果 for item in results: if "result" in item: sub_conversation_id = item["result"].get("conversation_id") @@ -313,27 +288,26 @@ class MultiAgentOrchestrator: break logger.info( - f"多 Agent 任务完成", + "多 Agent 任务完成", extra={ - "mode": self.config.orchestration_mode, + "strategy": routing_decision.get("collaboration_strategy", "single"), "elapsed_time": elapsed_time, - "sub_agent_count": len(results) if isinstance(results, list) else 1, "sub_conversation_id": sub_conversation_id } ) return { "message": final_result, - "conversation_id": sub_conversation_id, # 返回子 Agent 的会话 ID + "conversation_id": sub_conversation_id, "elapsed_time": elapsed_time, - "mode": self.config.orchestration_mode, + "strategy": routing_decision.get("collaboration_strategy", "single"), "sub_results": results } except Exception as e: logger.error( - f"多 Agent 任务执行失败", - extra={"error": str(e), "mode": self.config.orchestration_mode} + "多 Agent 任务执行失败", + extra={"error": str(e)} ) raise @@ -342,22 +316,42 @@ class MultiAgentOrchestrator: message: str, variables: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: - """主 Agent 分析任务 + """Master Agent 分析任务并做出路由决策 Args: message: 用户消息 variables: 变量参数 Returns: - 任务分析结果 + 任务分析结果，包含路由决策 """ - # 简化版本：直接返回基本信息 - # 在实际应用中，可以让主 Agent 使用 LLM 分析任务 + logger.info( + "Master Agent 开始分析任务", + extra={"message_length": len(message)} + ) + + # 使用 Master Agent 路由器进行决策 + routing_decision = await self.router.route( + message=message, + conversation_id=None, # 会在后续传入 + variables=variables + ) + + logger.info( + "Master Agent 分析完成", + extra={ + "selected_agent": routing_decision.get("selected_agent_id"), + "confidence": routing_decision.get("confidence"), + "strategy": routing_decision.get("strategy") + } + ) + return { "message": message, "variables": variables or {}, "sub_agents": self.config.sub_agents, - "initial_context": variables or {} + "initial_context": variables or {}, + "routing_decision": routing_decision } async def _execute_sequential( @@ -399,7 +393,7 @@ class MultiAgentOrchestrator: continue logger.info( - f"执行子 Agent", + "执行子 Agent", extra={ "agent_id": agent_id, "agent_name": sub_agent_info.get("name"), @@ -489,7 +483,7 @@ class MultiAgentOrchestrator: return_exceptions=True ) - for (agent_id, agent_name, _), result in zip(batch, batch_results): + for (agent_id, agent_name, _), result in zip(batch, batch_results, strict=False): if isinstance(result, Exception): logger.error(f"子 Agent 执行失败: {agent_name}", extra={"error": str(result)}) results.append({ @@ -507,6 +501,418 @@ class MultiAgentOrchestrator: return results + async def _execute_collaboration_stream( + self, + task_analysis: Dict[str, Any], + conversation_id: Optional[uuid.UUID], + user_id: Optional[str], + routing_decision: Dict[str, Any] + ): + """多 Agent 协作流式执行 + + Args: + task_analysis: 任务分析结果 + conversation_id: 会话 ID + user_id: 用户 ID + routing_decision: 路由决策 + + Yields: + SSE 格式的事件流 + """ + message = task_analysis.get("message", "") + initial_context = task_analysis.get("initial_context", {}) + collaboration_strategy = routing_decision.get("collaboration_strategy", "sequential") + + # 获取协作信息 + if collaboration_strategy == "decomposition": + collaboration_agents = routing_decision.get("sub_questions", []) + else: + collaboration_agents = routing_decision.get("collaboration_agents", []) + + logger.info( + "开始流式协作执行", + extra={ + "strategy": collaboration_strategy, + "agent_count": len(collaboration_agents) + } + ) + + # 1. 发送编排计划事件（在执行前） + # 构建子任务信息 + sub_tasks = [] + for item in collaboration_agents: + if collaboration_strategy == "decomposition": + # 问题拆分模式 + agent_id = item.get("agent_id") + agent_data = self.sub_agents.get(agent_id) + if agent_data: + sub_tasks.append({ + "agent_id": agent_id, + "agent_name": agent_data.get("info", {}).get("name", agent_id), + "sub_question": item.get("question", ""), + "order": item.get("order", 0) + }) + else: + # 其他协作模式 + agent_id = item.get("agent_id") + agent_data = self.sub_agents.get(agent_id) + if agent_data: + sub_tasks.append({ + "agent_id": agent_id, + "agent_name": agent_data.get("info", {}).get("name", agent_id), + "role": item.get("role", "secondary"), + "order": item.get("order", 0) + }) + + yield self._format_sse_event("orchestration_plan", { + "agent_count": len(sub_tasks), + "strategy": collaboration_strategy, + "sub_tasks": sub_tasks + }) + + # 2. 流式执行所有子 Agent + results = [] + + # 获取执行模式配置 + execution_mode = self.config.execution_config.get("sub_agent_execution_mode", "parallel") + + if collaboration_strategy == "decomposition": + # 问题拆分模式 + # 检查是否有依赖关系 + has_dependencies = self._check_dependencies(collaboration_agents) + + if has_dependencies or execution_mode == "sequential": + # 有依赖或配置为串行：串行流式执行 + logger.info("使用串行流式执行（问题拆分）") + for sub_q in sorted(collaboration_agents, key=lambda x: x.get("order", 0)): + sub_question = sub_q.get("question", "") + agent_id = sub_q.get("agent_id") + + agent_data = self.sub_agents.get(agent_id) + if not agent_data: + continue + + agent_name = agent_data.get("info", {}).get("name", agent_id) + + # 发送子问题开始事件 + yield self._format_sse_event("sub_question_start", { + "question": sub_question, + "agent_name": agent_name + }) + + # 流式执行子 Agent，收集结果 + result_content = "" + async for event in self._execute_sub_agent_stream( + agent_data["config"], + sub_question, + initial_context, + conversation_id, + user_id + ): + # 解析原始事件 + if "data:" in event: + try: + import json + data_line = event.split("data: ", 1)[1].strip() + data = json.loads(data_line) + + # 提取内容 + if "content" in data: + content = data["content"] + result_content += content + + # 转换为子 Agent 专用事件，带上 agent 信息 + yield self._format_sse_event("sub_agent_message", { + "content": content, + "agent_id": agent_id, + "agent_name": agent_name, + "sub_question": sub_question + }) + except: + pass + else: + # 非 data 事件直接转发 + yield event + + results.append({ + "agent_id": agent_id, + "agent_name": agent_name, + "sub_question": sub_question, + "result": {"message": result_content} + }) + + # 发送子问题完成事件 + yield self._format_sse_event("sub_question_end", { + "agent_name": agent_name + }) + else: + # 无依赖且配置为并行：并行流式执行 + logger.info(f"使用并行流式执行（问题拆分），共 {len(collaboration_agents)} 个子问题") + + # 准备并行任务 + agent_tasks = [] + agent_info_map = {} + result_contents = {} + + for sub_q in collaboration_agents: + sub_question = sub_q.get("question", "") + agent_id = sub_q.get("agent_id") + + agent_data = self.sub_agents.get(agent_id) + if not agent_data: + continue + + agent_name = agent_data.get("info", {}).get("name", agent_id) + agent_info_map[agent_id] = { + "name": agent_name, + "sub_question": sub_question + } + result_contents[agent_id] = "" + + agent_tasks.append(( + agent_id, + agent_name, + agent_data["config"], + sub_question, + initial_context + )) + + # 发送子问题开始事件 + yield self._format_sse_event("sub_question_start", { + "question": sub_question, + "agent_name": agent_name + }) + + # 并行流式执行 + async for agent_id, agent_name, event_type, content in self._parallel_stream_agents( + agent_tasks, + conversation_id, + user_id + ): + if event_type == "content": + # 累积结果 + result_contents[agent_id] += content + + # 实时返回 + yield self._format_sse_event("sub_agent_message", { + "content": content, + "agent_id": agent_id, + "agent_name": agent_name, + "sub_question": agent_info_map[agent_id]["sub_question"] + }) + + elif event_type == "done": + # Agent 完成 + results.append({ + "agent_id": agent_id, + "agent_name": agent_name, + "sub_question": agent_info_map[agent_id]["sub_question"], + "result": {"message": result_contents[agent_id]} + }) + + yield self._format_sse_event("sub_question_end", { + "agent_name": agent_name + }) + + elif event_type == "error": + logger.error(f"Agent {agent_name} 执行失败: {content}") + else: + # 其他协作模式（sequential/parallel/hierarchical） + if collaboration_strategy == "parallel" and execution_mode == "parallel": + # 并行协作 + 并行流式执行 + logger.info(f"使用并行流式执行（并行协作），共 {len(collaboration_agents)} 个 Agent") + + # 准备并行任务 + agent_tasks = [] + agent_info_map = {} + result_contents = {} + + for agent_info in collaboration_agents: + agent_id = agent_info.get("agent_id") + agent_data = self.sub_agents.get(agent_id) + if not agent_data: + continue + + agent_name = agent_data.get("info", {}).get("name", agent_id) + agent_info_map[agent_id] = { + "name": agent_name, + "role": agent_info.get("role", "secondary"), + "task": agent_info.get("task", "") + } + result_contents[agent_id] = "" + + # 构建该 Agent 的消息 + agent_task = agent_info.get("task", "处理任务") + agent_message = f"""原始问题：{message} + +你的任务：{agent_task} + +请完成你的任务。""" + + agent_tasks.append(( + agent_id, + agent_name, + agent_data["config"], + agent_message, + initial_context.copy() + )) + + # 发送 Agent 开始事件 + yield self._format_sse_event("agent_start", { + "agent_name": agent_name + }) + + # 并行流式执行 + async for agent_id, agent_name, event_type, content in self._parallel_stream_agents( + agent_tasks, + conversation_id, + user_id + ): + if event_type == "content": + # 累积结果 + result_contents[agent_id] += content + + # 实时返回 + yield self._format_sse_event("sub_agent_message", { + "content": content, + "agent_id": agent_id, + "agent_name": agent_name, + "role": agent_info_map[agent_id]["role"] + }) + + elif event_type == "done": + # Agent 完成 + results.append({ + "agent_id": agent_id, + "agent_name": agent_name, + "role": agent_info_map[agent_id]["role"], + "task": agent_info_map[agent_id]["task"], + "result": {"message": result_contents[agent_id]} + }) + + yield self._format_sse_event("agent_end", { + "agent_name": agent_name + }) + + elif event_type == "error": + logger.error(f"Agent {agent_name} 执行失败: {content}") + else: + # 顺序协作或层级协作 - 串行流式执行 + logger.info(f"使用串行流式执行（{collaboration_strategy}）") + for agent_info in collaboration_agents: + agent_id = agent_info.get("agent_id") + agent_data = self.sub_agents.get(agent_id) + if not agent_data: + continue + + agent_name = agent_data.get("info", {}).get("name", agent_id) + + # 发送 Agent 开始事件 + yield self._format_sse_event("agent_start", { + "agent_name": agent_name + }) + + # 流式执行子 Agent，收集结果 + result_content = "" + async for event in self._execute_sub_agent_stream( + agent_data["config"], + message, + initial_context, + conversation_id, + user_id + ): + # 解析原始事件 + if "data:" in event: + try: + import json + data_line = event.split("data: ", 1)[1].strip() + data = json.loads(data_line) + + # 提取内容 + if "content" in data: + content = data["content"] + result_content += content + + # 转换为子 Agent 专用事件，带上 agent 信息 + yield self._format_sse_event("sub_agent_message", { + "content": content, + "agent_id": agent_id, + "agent_name": agent_name, + "role": agent_info.get("role", "secondary") + }) + except: + pass + else: + # 非 data 事件直接转发 + yield event + + results.append({ + "agent_id": agent_id, + "agent_name": agent_name, + "result": {"message": result_content} + }) + + # 发送 Agent 完成事件 + yield self._format_sse_event("agent_end", { + "agent_name": agent_name + }) + + # 3. 智能整合结果 + merge_mode = self.config.execution_config.get("result_merge_mode", "smart") + + # 智能判断是否需要整合 + need_merge = self._should_merge_results(results, collaboration_strategy) + + if not need_merge: + # 不需要整合：用户已经看到所有内容了 + logger.info("跳过整合阶段（用户已看到所有 Agent 输出）") + # 不发送额外的 message 事件，避免重复 + elif merge_mode == "master" and len(results) > 1: + # Master Agent 整合（非流式，避免等待时间） + logger.info("开始 Master Agent 整合") + + # 发送整合开始提示 + yield self._format_sse_event("merge_start", { + "merge_mode": "master", + "agent_count": len(results), + "message": "正在整合多个专家的回答..." + }) + + # 非流式整合（更快） + try: + final_response = await self._master_merge_results( + results, + collaboration_strategy, + message + ) + + # 发送整合后的结果 + yield self._format_sse_event("merge_complete", { + "content": final_response + }) + except Exception as e: + logger.error(f"Master Agent 整合失败，降级到 smart 模式: {str(e)}") + final_response = self._smart_merge_results(results, collaboration_strategy) + yield self._format_sse_event("merge_complete", { + "content": final_response + }) + else: + # Smart 模式：快速整合 + logger.info("使用 Smart 模式整合") + + yield self._format_sse_event("merge_start", { + "merge_mode": "smart", + "agent_count": len(results) + }) + + final_response = self._smart_merge_results(results, collaboration_strategy) + + # 只有在需要时才发送整合结果 + if final_response and final_response != "": + yield self._format_sse_event("merge_complete", { + "content": final_response + }) + async def _execute_conditional_stream( self, task_analysis: Dict[str, Any], @@ -517,10 +923,10 @@ class MultiAgentOrchestrator: storage_type: str = '', user_rag_memory_id: str = '' ): - """条件路由执行（流式） + """条件路由执行（流式，重构版 - 使用 Master Agent 决策） Args: - task_analysis: 任务分析结果 + task_analysis: 任务分析结果（包含 Master Agent 的决策） conversation_id: 会话 ID user_id: 用户 ID @@ -531,42 +937,70 @@ class MultiAgentOrchestrator: raise BusinessException("没有可用的子 Agent", BizCode.AGENT_CONFIG_MISSING) message = task_analysis.get("message", "") + routing_decision = task_analysis.get("routing_decision") - # 使用路由规则选择 Agent - use_llm = task_analysis.get("use_llm_routing", True) - selected_agent_info = await self._route_by_rules( - message, - task_analysis["sub_agents"], - use_llm=use_llm, - conversation_id=str(conversation_id) if conversation_id else None - ) + # 1. 检查是否需要协作 + if routing_decision and routing_decision.get("need_collaboration"): + # 需要多 Agent 协作，使用流式整合 + logger.info("检测到需要多 Agent 协作，使用流式整合") + + async for event in self._execute_collaboration_stream( + task_analysis, + conversation_id, + user_id, + routing_decision + ): + yield event + return - if not selected_agent_info: - selected_agent_info = task_analysis["sub_agents"][0] - logger.info("未匹配到路由规则，使用默认 Agent") + # 2. 单 Agent 模式：如果有 Master Agent 的决策，直接使用 + if routing_decision and routing_decision.get("selected_agent_id"): + agent_id = routing_decision["selected_agent_id"] + + logger.info( + "使用 Master Agent 的路由决策（流式）", + extra={ + "agent_id": agent_id, + "confidence": routing_decision.get("confidence"), + "reasoning": routing_decision.get("reasoning") + } + ) + else: + # 2. 降级：使用旧的路由逻辑 + logger.warning("未获取到 Master Agent 决策，使用旧路由逻辑（流式）") + use_llm = task_analysis.get("use_llm_routing", True) + selected_agent_info = await self._route_by_rules( + message, + task_analysis["sub_agents"], + use_llm=use_llm, + conversation_id=str(conversation_id) if conversation_id else None + ) + + if not selected_agent_info: + selected_agent_info = task_analysis["sub_agents"][0] + logger.info("未匹配到路由规则，使用默认 Agent") + + agent_id = selected_agent_info["agent_id"] - agent_id = selected_agent_info["agent_id"] + # 3. 获取 Agent 配置 agent_data = self.sub_agents.get(agent_id) - if not agent_data: raise BusinessException(f"子 Agent 不存在: {agent_id}", BizCode.AGENT_CONFIG_MISSING) - logger.info( - f"条件路由选择 Agent（流式）", - extra={ - "agent_id": agent_id, - "agent_name": selected_agent_info.get("name"), - "message_preview": message[:50] - } - ) + agent_info = agent_data.get("info", {}) - # 发送路由信息事件 + # 4. 发送路由信息事件 yield self._format_sse_event("agent_selected", { "agent_id": agent_id, - "agent_name": selected_agent_info.get("name") + "agent_name": agent_info.get("name"), + "routing_decision": { + "confidence": routing_decision.get("confidence") if routing_decision else None, + "reasoning": routing_decision.get("reasoning") if routing_decision else None, + "strategy": routing_decision.get("strategy") if routing_decision else None + } }) - # 流式执行子 Agent + # 5. 流式执行子 Agent sub_conversation_id = None async for event in self._execute_sub_agent_stream( agent_data["config"], @@ -592,7 +1026,7 @@ class MultiAgentOrchestrator: yield event - # 如果有会话 ID，发送一个包含它的事件 + # 6. 如果有会话 ID，发送一个包含它的事件 if sub_conversation_id: yield self._format_sse_event("conversation", { "conversation_id": sub_conversation_id @@ -608,10 +1042,10 @@ class MultiAgentOrchestrator: storage_type: str = '', user_rag_memory_id: str = '' ) -> Dict[str, Any]: - """条件路由执行 - 根据路由规则选择合适的 Agent + """条件路由执行（重构版 - 使用 Master Agent 的决策） Args: - task_analysis: 任务分析结果 + task_analysis: 任务分析结果（包含 Master Agent 的决策） conversation_id: 会话 ID user_id: 用户 ID @@ -622,36 +1056,76 @@ class MultiAgentOrchestrator: raise BusinessException("没有可用的子 Agent", BizCode.AGENT_CONFIG_MISSING) message = task_analysis.get("message", "") + routing_decision = task_analysis.get("routing_decision") - # 使用路由规则选择 Agent（默认启用 LLM） - use_llm = task_analysis.get("use_llm_routing", True) - selected_agent_info = await self._route_by_rules( - message, - task_analysis["sub_agents"], - use_llm=use_llm, - conversation_id=str(conversation_id) if conversation_id else None + if not routing_decision: + raise BusinessException("缺少路由决策", BizCode.AGENT_CONFIG_MISSING) + + agent_id = routing_decision["selected_agent_id"] + + logger.info( + "执行 Master Agent 的路由决策", + extra={ + "agent_id": agent_id, + "confidence": routing_decision.get("confidence"), + "reasoning": routing_decision.get("reasoning") + } ) - if not selected_agent_info: - # 如果没有匹配的规则，使用第一个 Agent - selected_agent_info = task_analysis["sub_agents"][0] - logger.info("未匹配到路由规则，使用默认 Agent") + # 检查是否需要协作 + if routing_decision.get("need_collaboration"): + collaboration_strategy = routing_decision.get("collaboration_strategy", "sequential") + + # 根据策略获取协作信息 + if collaboration_strategy == "decomposition": + # 问题拆分模式：使用 sub_questions + collaboration_agents = routing_decision.get("sub_questions", []) + logger.info( + "Master Agent 建议问题拆分", + extra={ + "sub_question_count": len(collaboration_agents), + "strategy": collaboration_strategy + } + ) + else: + # 其他协作模式：使用 collaboration_agents + collaboration_agents = routing_decision.get("collaboration_agents", []) + logger.info( + "Master Agent 建议多 Agent 协作", + extra={ + "collaboration_agent_count": len(collaboration_agents), + "strategy": collaboration_strategy + } + ) + + # 执行多 Agent 协作 + return await self._execute_collaboration( + message=message, + collaboration_agents=collaboration_agents, + strategy=collaboration_strategy, + initial_context=task_analysis.get("initial_context", {}), + conversation_id=conversation_id, + user_id=user_id, + routing_decision=routing_decision + ) - agent_id = selected_agent_info["agent_id"] + # 3. 获取 Agent 配置 agent_data = self.sub_agents.get(agent_id) - if not agent_data: raise BusinessException(f"子 Agent 不存在: {agent_id}", BizCode.AGENT_CONFIG_MISSING) + agent_info = agent_data.get("info", {}) + logger.info( - f"条件路由选择 Agent", + "执行选中的 Agent", extra={ "agent_id": agent_id, - "agent_name": selected_agent_info.get("name"), + "agent_name": agent_info.get("name"), "message_preview": message[:50] } ) + # 4. 执行 Agent result = await self._execute_sub_agent( agent_data["config"], message, @@ -664,140 +1138,15 @@ class MultiAgentOrchestrator: user_rag_memory_id ) - # 确保返回子 Agent 的 conversation_id + # 5. 返回结果 return { "agent_id": agent_id, - "agent_name": selected_agent_info.get("name"), + "agent_name": agent_info.get("name"), "result": result, - "conversation_id": result.get("conversation_id") # 传递子 Agent 的会话 ID + "conversation_id": result.get("conversation_id"), + "routing_decision": routing_decision # 包含 Master Agent 的决策信息 } - async def _route_by_rules( - self, - message: str, - sub_agents: List[Dict[str, Any]], - use_llm: bool = True, - conversation_id: Optional[str] = None - ) -> Optional[Dict[str, Any]]: - """根据路由规则选择 Agent（支持 LLM 增强） - - Args: - message: 用户消息 - sub_agents: 子 Agent 列表 - use_llm: 是否使用 LLM 辅助路由 - conversation_id: 会话 ID（用于多轮对话状态管理） - - Returns: - 选中的 Agent 信息，如果没有匹配则返回 None - """ - # 如果配置了 LLM 路由器，优先使用 - if self.llm_router and use_llm: - try: - logger.info("使用 LLM 路由器进行智能路由") - routing_result = await self.llm_router.route( - message=message, - conversation_id=conversation_id, - force_new=False - ) - - selected_agent_id = routing_result["agent_id"] - confidence = routing_result["confidence"] - method = routing_result.get("routing_method", "unknown") - - logger.info( - f"LLM 路由完成", - extra={ - "agent_id": selected_agent_id, - "confidence": confidence, - "method": method, - "strategy": routing_result.get("strategy"), - "topic": routing_result.get("topic") - } - ) - - # 查找对应的 Agent - for agent in sub_agents: - if agent["agent_id"] == selected_agent_id: - return agent - - logger.warning(f"LLM 路由返回的 agent_id 不在子 Agent 列表中: {selected_agent_id}") - - except Exception as e: - logger.error(f"LLM 路由失败，降级到关键词路由: {str(e)}") - - # 降级到关键词路由 - if not self.config.routing_rules: - return None - - message_lower = message.lower() - best_match = None - best_score = 0 - - # 关键词匹配 - for rule in self.config.routing_rules: - target_agent_id = rule.get("target_agent_id") - condition = rule.get("condition", "") - priority = rule.get("priority", 1) - - # 解析条件表达式（简化版本：支持 contains_any） - score = self._evaluate_condition(condition, message_lower) - - # 考虑优先级 - weighted_score = score * priority - - if weighted_score > best_score: - # 找到对应的 Agent - for agent in sub_agents: - if agent["agent_id"] == target_agent_id: - best_match = agent - best_score = weighted_score - break - - if best_match: - logger.info( - f"关键词路由", - extra={ - "agent_name": best_match.get("name"), - "score": best_score - } - ) - - return best_match - - - def _evaluate_condition(self, condition: str, message: str) -> float: - """评估条件表达式 - - Args: - condition: 条件表达式，如 "contains_any(['数学', '物理'])" - message: 消息文本（已转小写） - - Returns: - 匹配分数 (0-1) - """ - import re - - # 解析 contains_any(['keyword1', 'keyword2', ...]) - match = re.search(r"contains_any\(\[(.*?)\]\)", condition) - if not match: - return 0 - - # 提取关键词列表 - keywords_str = match.group(1) - keywords = [k.strip().strip("'\"") for k in keywords_str.split(",")] - - # 计算匹配分数 - matched_count = 0 - for keyword in keywords: - if keyword.lower() in message: - matched_count += 1 - - if not keywords: - return 0 - - # 返回匹配比例 - return matched_count / len(keywords) - async def _execute_loop( self, task_analysis: Dict[str, Any], @@ -836,7 +1185,7 @@ class MultiAgentOrchestrator: result = None for i in range(max_iterations): logger.info( - f"循环执行 Agent", + "循环执行 Agent", extra={ "iteration": i + 1, "max_iterations": max_iterations, @@ -898,7 +1247,7 @@ class MultiAgentOrchestrator: model_config = self.db.get(ModelConfig, agent_config.default_model_config_id) if not model_config: raise BusinessException( - f"Agent 模型配置不存在", + "Agent 模型配置不存在", BizCode.AGENT_CONFIG_MISSING ) @@ -949,7 +1298,7 @@ class MultiAgentOrchestrator: model_config = self.db.get(ModelConfig, agent_config.default_model_config_id) if not model_config: raise BusinessException( - f"Agent 模型配置不存在", + "Agent 模型配置不存在", BizCode.AGENT_CONFIG_MISSING ) @@ -1114,3 +1463,1299 @@ class MultiAgentOrchestrator: self.default_model_config_id = release.default_model_config_id return AgentConfigProxy(release, app, config_data) + + async def _execute_collaboration( + self, + message: str, + collaboration_agents: List[Dict[str, Any]], + strategy: str, + initial_context: Dict[str, Any], + conversation_id: Optional[uuid.UUID], + user_id: Optional[str], + routing_decision: Dict[str, Any] + ) -> Dict[str, Any]: + """执行多 Agent 协作 + + Args: + message: 用户消息 + collaboration_agents: 协作 Agent 列表 + strategy: 协作策略（sequential/parallel/hierarchical） + initial_context: 初始上下文 + conversation_id: 会话 ID + user_id: 用户 ID + routing_decision: 路由决策 + + Returns: + 协作执行结果 + """ + logger.info( + "开始多 Agent 协作", + extra={ + "agent_count": len(collaboration_agents), + "strategy": strategy + } + ) + + if strategy == "decomposition": + # 问题拆分：每个 Agent 处理一个子问题 + return await self._execute_decomposition_collaboration( + message, collaboration_agents, initial_context, + conversation_id, user_id, routing_decision + ) + elif strategy == "sequential": + # 顺序协作：按顺序执行，后续 Agent 可以使用前面的结果 + return await self._execute_sequential_collaboration( + message, collaboration_agents, initial_context, + conversation_id, user_id, routing_decision + ) + elif strategy == "parallel": + # 并行协作：同时执行所有 Agent + return await self._execute_parallel_collaboration( + message, collaboration_agents, initial_context, + conversation_id, user_id, routing_decision + ) + elif strategy == "hierarchical": + # 层级协作：主 Agent 协调，其他 Agent 辅助 + return await self._execute_hierarchical_collaboration( + message, collaboration_agents, initial_context, + conversation_id, user_id, routing_decision + ) + else: + # 默认使用顺序协作 + return await self._execute_sequential_collaboration( + message, collaboration_agents, initial_context, + conversation_id, user_id, routing_decision + ) + + def _check_dependencies(self, sub_questions: List[Dict[str, Any]]) -> bool: + """检测子问题是否有依赖关系 + + Args: + sub_questions: 子问题列表 + + Returns: + True 如果有依赖关系，False 如果完全独立 + """ + for sub_q in sub_questions: + depends_on = sub_q.get("depends_on", []) + if depends_on and len(depends_on) > 0: + logger.info( + "检测到依赖关系", + extra={ + "question": sub_q.get("question", "")[:50], + "depends_on": depends_on + } + ) + return True + return False + + async def _execute_decomposition_collaboration( + self, + message: str, + collaboration_agents: List[Dict[str, Any]], + initial_context: Dict[str, Any], + conversation_id: Optional[uuid.UUID], + user_id: Optional[str], + routing_decision: Dict[str, Any] + ) -> Dict[str, Any]: + """问题拆分执行 + + 每个 Agent 处理一个独立的子问题，避免重复 + + 示例： + 原问题："写一首关于雪的古诗，并计算3+8" + 拆分后： + - 子问题1："写一首关于雪的古诗" → 文科导师 + - 子问题2："计算3+8" → 理科导师 + + Args: + collaboration_agents: 在 decomposition 模式下，这就是 sub_questions 列表 + """ + results = [] + + # collaboration_agents 在 decomposition 模式下就是 sub_questions + sub_questions = collaboration_agents + + if not sub_questions: + # 如果没有子问题，降级到普通协作 + logger.warning( + "问题拆分模式但没有子问题，降级到顺序协作", + extra={ + "collaboration_agents": collaboration_agents, + "routing_decision": routing_decision + } + ) + return await self._execute_sequential_collaboration( + message, collaboration_agents, initial_context, + conversation_id, user_id, routing_decision + ) + + logger.info( + "开始问题拆分执行", + extra={ + "sub_question_count": len(sub_questions), + "original_message": message[:50] + } + ) + + # 检测是否有依赖关系 + has_dependencies = self._check_dependencies(sub_questions) + + # 获取执行模式配置 + execution_mode = self.config.execution_config.get("sub_agent_execution_mode", "parallel") + + # 如果有依赖关系，强制使用串行模式 + if has_dependencies: + logger.info("检测到子问题有依赖关系，强制使用串行执行") + execution_mode = "sequential" + + if execution_mode == "sequential": + # 串行执行模式 + logger.info(f"串行执行 {len(sub_questions)} 个子问题") + + # 用于存储已完成的子问题结果（按 order 索引） + completed_results = {} + + for sub_q in sorted(sub_questions, key=lambda x: x.get("order", 0)): + sub_question = sub_q.get("question", "") + agent_id = sub_q.get("agent_id") + order = sub_q.get("order", 0) + depends_on = sub_q.get("depends_on", []) + + agent_data = self.sub_agents.get(agent_id) + if not agent_data: + logger.warning( + f"子问题对应的 Agent 不存在: {agent_id}", + extra={ + "sub_question": sub_question, + "available_agents": list(self.sub_agents.keys()) + } + ) + continue + + agent_name = agent_data.get("info", {}).get("name", agent_id) + + # 如果有依赖，构建包含依赖结果的上下文 + context_with_deps = initial_context.copy() + if depends_on: + dependency_results = [] + for dep_order in depends_on: + if dep_order in completed_results: + dep_result = completed_results[dep_order] + dependency_results.append({ + "question": dep_result.get("sub_question"), + "answer": dep_result.get("result", {}).get("message", "") + }) + + if dependency_results: + context_with_deps["previous_results"] = dependency_results + logger.info( + "子问题依赖前置结果", + extra={ + "current_order": order, + "depends_on": depends_on, + "dependency_count": len(dependency_results) + } + ) + + logger.info( + "处理子问题（串行）", + extra={ + "sub_question": sub_question, + "agent_id": agent_id, + "agent_name": agent_name, + "has_dependencies": bool(depends_on) + } + ) + + # 串行执行 + try: + result = await self._execute_sub_agent( + agent_data["config"], + sub_question, + context_with_deps, # 使用包含依赖结果的上下文 + conversation_id, + user_id + ) + result_entry = { + "agent_id": agent_id, + "agent_name": agent_name, + "sub_question": sub_question, + "result": result, + "conversation_id": result.get("conversation_id"), + "order": order + } + results.append(result_entry) + completed_results[order] = result_entry # 保存结果供后续依赖使用 + except Exception as e: + logger.error(f"子问题执行失败: {str(e)}") + results.append({ + "agent_id": agent_id, + "agent_name": agent_name, + "sub_question": sub_question, + "error": str(e), + "order": order + }) + else: + # 并行执行模式（默认） + tasks = [] + agent_infos = [] + + for sub_q in sorted(sub_questions, key=lambda x: x.get("order", 0)): + sub_question = sub_q.get("question", "") + agent_id = sub_q.get("agent_id") + + agent_data = self.sub_agents.get(agent_id) + if not agent_data: + logger.warning(f"子问题对应的 Agent 不存在: {agent_id}") + continue + + agent_name = agent_data.get("info", {}).get("name", agent_id) + + logger.info( + "准备处理子问题（并行）", + extra={ + "sub_question": sub_question, + "agent_id": agent_id, + "agent_name": agent_name + } + ) + + # 创建异步任务 + task = self._execute_sub_agent( + agent_data["config"], + sub_question, + initial_context, + conversation_id, + user_id + ) + tasks.append(task) + agent_infos.append({ + "agent_id": agent_id, + "agent_name": agent_name, + "sub_question": sub_question + }) + + # 并行执行所有任务 + logger.info(f"并行执行 {len(tasks)} 个子问题") + task_results = await asyncio.gather(*tasks, return_exceptions=True) + + # 处理结果 + for i, result in enumerate(task_results): + if isinstance(result, Exception): + logger.error(f"子问题执行失败: {str(result)}") + results.append({ + "agent_id": agent_infos[i]["agent_id"], + "agent_name": agent_infos[i]["agent_name"], + "sub_question": agent_infos[i]["sub_question"], + "error": str(result) + }) + else: + results.append({ + "agent_id": agent_infos[i]["agent_id"], + "agent_name": agent_infos[i]["agent_name"], + "sub_question": agent_infos[i]["sub_question"], + "result": result, + "conversation_id": result.get("conversation_id") + }) + + # 整合结果（问题拆分模式） + final_response = await self._merge_decomposition_results(results, message) + + return { + "agent_id": "decomposition", + "agent_name": "问题拆分协作", + "result": { + "message": final_response, + "conversation_id": results[0].get("conversation_id") if results else None + }, + "conversation_id": results[0].get("conversation_id") if results else None, + "routing_decision": routing_decision, + "collaboration_results": results + } + + async def _execute_sequential_collaboration( + self, + message: str, + collaboration_agents: List[Dict[str, Any]], + initial_context: Dict[str, Any], + conversation_id: Optional[uuid.UUID], + user_id: Optional[str], + routing_decision: Dict[str, Any] + ) -> Dict[str, Any]: + """顺序协作执行 + + 每个 Agent 按顺序执行，后续 Agent 可以看到前面 Agent 的结果 + """ + results = [] + context = initial_context.copy() + accumulated_response = [] + + # 按 order 排序 + sorted_agents = sorted(collaboration_agents, key=lambda x: x.get("order", 0)) + + for agent_info in sorted_agents: + agent_id = agent_info["agent_id"] + agent_data = self.sub_agents.get(agent_id) + + if not agent_data: + logger.warning(f"协作 Agent 不存在: {agent_id}") + continue + + agent_name = agent_data.get("info", {}).get("name", agent_id) + agent_task = agent_info.get("task", "处理任务") + + logger.info( + "执行协作 Agent", + extra={ + "agent_id": agent_id, + "agent_name": agent_name, + "role": agent_info.get("role"), + "task": agent_task, + "order": agent_info.get("order") + } + ) + + # 构建该 Agent 的消息（包含任务说明和前面的结果） + agent_message = message + if context.get("previous_results"): + agent_message = f"""原始问题：{message} + +你的任务：{agent_task} + +前面专家的分析结果： +{context['previous_results']} + +请基于以上信息，完成你的任务。""" + + # 执行 Agent + result = await self._execute_sub_agent( + agent_data["config"], + agent_message, + context, + conversation_id, + user_id + ) + + agent_response = result.get("message", "") + + results.append({ + "agent_id": agent_id, + "agent_name": agent_name, + "role": agent_info.get("role"), + "task": agent_task, + "result": result, + "conversation_id": result.get("conversation_id") + }) + + # 更新上下文 + context[f"result_from_{agent_name}"] = agent_response + + # 累积响应 + accumulated_response.append(f"【{agent_name}】\n{agent_response}") + + # 更新 previous_results 供下一个 Agent 使用 + context["previous_results"] = "\n\n".join(accumulated_response) + + # 整合最终结果 + final_response = await self._merge_collaboration_results( + results, + strategy="sequential", + original_question=message + ) + + return { + "agent_id": "collaboration", + "agent_name": "多Agent协作", + "result": { + "message": final_response, + "conversation_id": results[0].get("conversation_id") if results else None + }, + "conversation_id": results[0].get("conversation_id") if results else None, + "routing_decision": routing_decision, + "collaboration_results": results + } + + async def _execute_parallel_collaboration( + self, + message: str, + collaboration_agents: List[Dict[str, Any]], + initial_context: Dict[str, Any], + conversation_id: Optional[uuid.UUID], + user_id: Optional[str], + routing_decision: Dict[str, Any] + ) -> Dict[str, Any]: + """并行协作执行 + + 所有 Agent 同时执行，互不依赖 + """ + tasks = [] + agent_infos = [] + + for agent_info in collaboration_agents: + agent_id = agent_info["agent_id"] + agent_data = self.sub_agents.get(agent_id) + + if not agent_data: + continue + + agent_task = agent_info.get("task", "处理任务") + + # 构建该 Agent 的消息 + agent_message = f"""原始问题：{message} + +你的任务：{agent_task} + +请完成你的任务。""" + + # 创建任务 + task = self._execute_sub_agent( + agent_data["config"], + agent_message, + initial_context.copy(), + conversation_id, + user_id + ) + tasks.append(task) + agent_infos.append((agent_id, agent_data, agent_info)) + + # 并行执行 + task_results = await asyncio.gather(*tasks, return_exceptions=True) + + # 处理结果 + results = [] + for (agent_id, agent_data, agent_info), result in zip(agent_infos, task_results, strict=False): + agent_name = agent_data.get("info", {}).get("name", agent_id) + + if isinstance(result, Exception): + logger.error(f"协作 Agent 执行失败: {agent_name}", extra={"error": str(result)}) + results.append({ + "agent_id": agent_id, + "agent_name": agent_name, + "error": str(result) + }) + else: + results.append({ + "agent_id": agent_id, + "agent_name": agent_name, + "role": agent_info.get("role"), + "task": agent_info.get("task"), + "result": result, + "conversation_id": result.get("conversation_id") + }) + + # 整合结果 + final_response = await self._merge_collaboration_results( + results, + strategy="parallel", + original_question=message + ) + + return { + "agent_id": "collaboration", + "agent_name": "多Agent协作", + "result": { + "message": final_response, + "conversation_id": results[0].get("conversation_id") if results else None + }, + "conversation_id": results[0].get("conversation_id") if results else None, + "routing_decision": routing_decision, + "collaboration_results": results + } + + async def _execute_hierarchical_collaboration( + self, + message: str, + collaboration_agents: List[Dict[str, Any]], + initial_context: Dict[str, Any], + conversation_id: Optional[uuid.UUID], + user_id: Optional[str], + routing_decision: Dict[str, Any] + ) -> Dict[str, Any]: + """层级协作执行 + + 主 Agent（primary）负责协调，其他 Agent 提供辅助信息 + """ + # 找到主 Agent 和辅助 Agents + primary_agent = None + secondary_agents = [] + + for agent_info in collaboration_agents: + if agent_info.get("role") == "primary": + primary_agent = agent_info + else: + secondary_agents.append(agent_info) + + if not primary_agent: + # 如果没有指定主 Agent，使用第一个 + primary_agent = collaboration_agents[0] + secondary_agents = collaboration_agents[1:] + + # 1. 先执行辅助 Agents（并行） + secondary_results = [] + if secondary_agents: + tasks = [] + agent_infos = [] + + for agent_info in secondary_agents: + agent_id = agent_info["agent_id"] + agent_data = self.sub_agents.get(agent_id) + + if not agent_data: + continue + + agent_task = agent_info.get("task", "提供专业意见") + agent_message = f"""问题：{message} + +请从你的专业角度提供意见：{agent_task}""" + + task = self._execute_sub_agent( + agent_data["config"], + agent_message, + initial_context.copy(), + conversation_id, + user_id + ) + tasks.append(task) + agent_infos.append((agent_id, agent_data, agent_info)) + + # 并行执行辅助 Agents + task_results = await asyncio.gather(*tasks, return_exceptions=True) + + for (agent_id, agent_data, agent_info), result in zip(agent_infos, task_results, strict=False): + agent_name = agent_data.get("info", {}).get("name", agent_id) + + if not isinstance(result, Exception): + secondary_results.append({ + "agent_id": agent_id, + "agent_name": agent_name, + "role": "secondary", + "result": result + }) + + # 2. 执行主 Agent（整合辅助 Agents 的结果） + primary_agent_id = primary_agent["agent_id"] + primary_agent_data = self.sub_agents.get(primary_agent_id) + + if not primary_agent_data: + raise BusinessException(f"主协作 Agent 不存在: {primary_agent_id}", BizCode.AGENT_CONFIG_MISSING) + + # 构建主 Agent 的消息（包含辅助 Agents 的结果） + primary_message = f"""问题：{message} + +你的任务：{primary_agent.get('task', '综合分析并给出最终答案')} +""" + + if secondary_results: + expert_opinions = [] + for sec_result in secondary_results: + expert_opinions.append( + f"【{sec_result['agent_name']}的意见】\n{sec_result['result'].get('message', '')}" + ) + + primary_message += f""" + +其他专家的意见： +{chr(10).join(expert_opinions)} + +请综合以上专家意见，给出你的最终答案。""" + + # 执行主 Agent + primary_result = await self._execute_sub_agent( + primary_agent_data["config"], + primary_message, + initial_context, + conversation_id, + user_id + ) + + primary_agent_name = primary_agent_data.get("info", {}).get("name", primary_agent_id) + + # 整合所有结果 + all_results = [*secondary_results, {"agent_id": primary_agent_id, "agent_name": primary_agent_name, "role": "primary", "result": primary_result, "conversation_id": primary_result.get("conversation_id")}] + + return { + "agent_id": primary_agent_id, + "agent_name": primary_agent_name, + "result": primary_result, + "conversation_id": primary_result.get("conversation_id"), + "routing_decision": routing_decision, + "collaboration_results": all_results + } + + async def _merge_decomposition_results( + self, + results: List[Dict[str, Any]], + original_question: str = None + ) -> str: + """整合问题拆分的结果 + + 每个 Agent 处理了不同的子问题，需要按顺序组合 + + Args: + results: 结果列表，每个包含 sub_question 和 result + original_question: 原始用户问题 + + Returns: + 整合后的响应 + """ + if not results: + return "未获取到有效结果" + + # 获取整合模式 + merge_mode = self.config.execution_config.get("result_merge_mode", "smart") + + if merge_mode == "master": + # 使用 Master Agent 整合 + return await self._master_merge_results(results, "decomposition", original_question) + else: + # smart 模式：直接组合答案 + parts = [] + for result in results: + message = result.get("result", {}).get("message", "") + if message: + parts.append(message) + + return "\n\n".join(parts) + + async def _merge_collaboration_results( + self, + results: List[Dict[str, Any]], + strategy: str, + original_question: str = None + ) -> str: + """整合协作结果（智能去重和合并） + + Args: + results: 协作结果列表 + strategy: 协作策略 + original_question: 原始用户问题 + + Returns: + 整合后的响应 + """ + if not results: + logger.error( + "协作结果为空", + extra={ + "strategy": strategy, + "has_original_question": bool(original_question) + } + ) + return "协作执行失败，没有可用结果" + + # 获取整合策略配置 + merge_mode = self.config.execution_config.get("result_merge_mode", "smart") + + if merge_mode == "master": + # Master Agent 整合：让 Master Agent 结合原始问题和子 Agent 答案生成最终回复 + return await self._master_merge_results(results, strategy, original_question) + else: + # 默认使用智能整合 + return self._smart_merge_results(results, strategy) + + def _smart_merge_results( + self, + results: List[Dict[str, Any]], + strategy: str + ) -> str: + """智能整合结果（去重、提取关键信息） + + 适用场景：多个 Agent 回答相似问题，需要去重和优化 + + 注意：在流式场景下，用户已经看到了所有 Agent 的输出， + 这个方法主要用于生成一个"整合后的版本"供后续使用（如保存到数据库） + """ + if not results: + return "" + + # 提取所有消息 + messages = [] + for result in results: + if "error" in result: + continue + message = result.get("result", {}).get("message", "") + if message: + messages.append(message) + + if not messages: + return "" + + if len(messages) == 1: + # 只有一个结果，直接返回 + return messages[0] + + # 多个结果：根据策略智能整合 + if strategy == "decomposition": + # 问题拆分：用户已经看到所有子问题的答案了 + # 返回空字符串，表示不需要额外的整合输出 + return "" + + elif strategy == "sequential": + # 顺序协作：返回最后一个 Agent 的结果（它包含了前面的信息） + return self._merge_sequential_smart(results) + + elif strategy == "parallel": + # 并行协作：检查是否需要去重 + return self._merge_parallel_smart(results) + + elif strategy == "hierarchical": + # 层级协作：只返回主 Agent 的结果 + return self._merge_hierarchical_smart(results) + + else: + # 默认：返回最完整的一个 + return max(messages, key=len) + + def _merge_sequential_smart(self, results: List[Dict[str, Any]]) -> str: + """智能整合顺序协作结果 + + 顺序协作的特点：后续 Agent 会引用前面的结果 + 策略：只保留最后一个 Agent 的完整回答（它已经包含了前面的信息） + """ + if not results: + return "" + + # 获取最后一个成功的结果 + for result in reversed(results): + if "error" not in result: + message = result.get("result", {}).get("message", "") + if message: + return message + + return "未获取到有效结果" + + def _merge_parallel_smart(self, results: List[Dict[str, Any]]) -> str: + """智能整合并行协作结果 + + 并行协作的特点：多个独立观点 + 策略： + 1. 如果回答高度相似（重复），只保留一个 + 2. 如果回答不同，合并所有观点（但不显示 Agent 名称） + """ + messages = [] + for result in results: + if "error" in result: + continue + message = result.get("result", {}).get("message", "") + if message: + messages.append(message) + + if not messages: + return "未获取到有效结果" + + if len(messages) == 1: + return messages[0] + + # 检查相似度 + similarity = self._calculate_similarity(messages) + + if similarity > 0.7: + # 高度相似，只返回最长的一个 + return max(messages, key=len) + else: + # 不同观点，合并（不显示 Agent 名称） + # 使用分隔符区分不同部分 + return "\n\n---\n\n".join(messages) + + def _merge_hierarchical_smart(self, results: List[Dict[str, Any]]) -> str: + """智能整合层级协作结果 + + 层级协作的特点：主 Agent 已经综合了辅助 Agent 的意见 + 策略：只返回主 Agent 的结果 + """ + # 找到主 Agent 的结果 + for result in results: + if result.get("role") == "primary": + message = result.get("result", {}).get("message", "") + if message: + return message + + # 如果没有找到主 Agent，返回最后一个 + if results: + last_result = results[-1] + return last_result.get("result", {}).get("message", "") + + return "未获取到有效结果" + + async def _master_merge_results( + self, + results: List[Dict[str, Any]], + strategy: str, + original_question: str = None + ) -> str: + """使用 Master Agent 整合多个子 Agent 的结果 + + Args: + results: 子 Agent 的响应结果列表 + strategy: 协作策略 + original_question: 原始用户问题 + + Returns: + Master Agent 整合后的最终回复 + """ + if not results: + return "没有收到任何 Agent 的响应" + + if len(results) == 1: + # 只有一个结果，直接返回 + return results[0].get('result', {}).get('message', '') + + # 构建子 Agent 回答的汇总 + agent_responses = [] + for i, result in enumerate(results, 1): + if "error" in result: + continue + + agent_name = result.get('agent_name', f'Agent {i}') + task = result.get('task', '') + message = result.get('result', {}).get('message', '') + + if message: + response_info = { + 'agent_name': agent_name, + 'task': task, + 'response': message + } + agent_responses.append(response_info) + + if not agent_responses: + return "未获取到有效结果" + + # 构建 Master Agent 的整合 prompt + responses_text = "" + for resp in agent_responses: + agent_name = resp['agent_name'] + task = resp['task'] + response = resp['response'] + + if task: + responses_text += f"\n### {agent_name}（任务：{task}）的回答：\n{response}\n" + else: + responses_text += f"\n### {agent_name} 的回答：\n{response}\n" + + # 根据策略调整整合指令 + strategy_instructions = { + "decomposition": "这些是针对不同子问题的回答，请将它们整合成一个完整、连贯的答案。", + "sequential": "这些是按顺序协作的结果，后面的 Agent 可能依赖前面的结果，请整合成最终答案。", + "parallel": "这些是从不同角度并行分析的结果，请综合这些观点给出全面的答案。", + "hierarchical": "这些是层级协作的结果，请综合各方意见给出最终答案。" + } + + strategy_instruction = strategy_instructions.get(strategy, "请整合这些回答，生成统一的最终答案。") + + question_context = f"\n**原始问题**：{original_question}\n" if original_question else "" + + merge_prompt = f"""你是一个智能助手，现在需要整合多个专业 Agent 的回答，生成一个统一、连贯、完整的最终答案。 +{question_context} +**各个专业 Agent 的回答**： +{responses_text} + +**整合要求**： +{strategy_instruction} + +请注意： +1. 结合原始问题和各个 Agent 的专业回答 +2. 去除重复内容，保留所有有价值的信息 +3. 确保答案逻辑清晰、表达流畅 +4. 如果不同 Agent 的观点有冲突，请合理说明 +5. 直接给出整合后的答案，不要添加"根据以上回答"等元信息 + +请生成最终的整合答案：""" + + try: + # 调用 Master Agent 的 LLM 进行整合 + from app.core.models import RedBearLLM + from app.core.models.base import RedBearModelConfig + from app.models import ModelApiKey, ModelType + + # 获取 Master Agent 的模型配置 + master_agent_release = self.config.master_agent_release + if not master_agent_release: + logger.warning("没有配置 Master Agent，使用简单整合") + return self._smart_merge_results(results, strategy) + + # 获取 API Key 配置 + api_key_config = self.db.query(ModelApiKey).filter( + ModelApiKey.model_config_id == master_agent_release.default_model_config_id, + ModelApiKey.is_active == True + ).first() + + if not api_key_config: + logger.warning("Master Agent 没有可用的 API Key，使用简单整合") + return self._smart_merge_results(results, strategy) + + logger.info( + "使用 Master Agent 整合结果", + extra={ + "agent_count": len(agent_responses), + "strategy": strategy, + "has_original_question": bool(original_question) + } + ) + + # 创建 RedBearModelConfig + model_config = RedBearModelConfig( + model_name=api_key_config.model_name, + provider=api_key_config.provider, + api_key=api_key_config.api_key, + base_url=api_key_config.api_base, + temperature=0.7, # 整合任务使用中等温度 + max_tokens=2000 + ) + + # 创建 LLM 实例 + llm = RedBearLLM(model_config, type=ModelType.CHAT) + + # 调用模型进行整合 + response = await llm.ainvoke(merge_prompt) + + # 提取响应内容 + if hasattr(response, 'content'): + merged_response = response.content + else: + merged_response = str(response) + + logger.info( + "Master Agent 整合完成", + extra={ + "merged_length": len(merged_response) + } + ) + + return merged_response + + except Exception as e: + logger.error(f"Master Agent 整合失败: {str(e)}") + # 降级到智能整合 + return self._smart_merge_results(results, strategy) + + async def _master_merge_results_stream( + self, + results: List[Dict[str, Any]], + strategy: str, + original_question: str = None + ): + """使用 Master Agent 流式整合多个子 Agent 的结果 + + Args: + results: 子 Agent 的响应结果列表 + strategy: 协作策略 + original_question: 原始用户问题 + + Yields: + SSE 格式的事件流 + """ + if not results: + yield self._format_sse_event("message", {"content": "没有收到任何 Agent 的响应"}) + return + + if len(results) == 1: + # 只有一个结果，直接返回 + yield self._format_sse_event("message", { + "content": results[0].get('result', {}).get('message', '') + }) + return + + # 构建子 Agent 回答的汇总（与非流式版本相同） + agent_responses = [] + for i, result in enumerate(results, 1): + if "error" in result: + continue + + agent_name = result.get('agent_name', f'Agent {i}') + task = result.get('task', '') + sub_question = result.get('sub_question', '') + message = result.get('result', {}).get('message', '') + + if message: + response_info = { + 'agent_name': agent_name, + 'task': task or sub_question, + 'response': message + } + agent_responses.append(response_info) + + if not agent_responses: + yield self._format_sse_event("message", {"content": "未获取到有效结果"}) + return + + # 构建整合 prompt + responses_text = "" + for resp in agent_responses: + agent_name = resp['agent_name'] + task = resp['task'] + response = resp['response'] + + if task: + responses_text += f"\n### {agent_name}（任务：{task}）的回答：\n{response}\n" + else: + responses_text += f"\n### {agent_name} 的回答：\n{response}\n" + + strategy_instructions = { + "decomposition": "这些是针对不同子问题的回答，请将它们整合成一个完整、连贯的答案。", + "sequential": "这些是按顺序协作的结果，后面的 Agent 可能依赖前面的结果，请整合成最终答案。", + "parallel": "这些是从不同角度并行分析的结果，请综合这些观点给出全面的答案。", + "hierarchical": "这些是层级协作的结果，请综合各方意见给出最终答案。" + } + + strategy_instruction = strategy_instructions.get(strategy, "请整合这些回答，生成统一的最终答案。") + question_context = f"\n**原始问题**：{original_question}\n" if original_question else "" + + merge_prompt = f"""你是一个智能助手，现在需要整合多个专业 Agent 的回答，生成一个统一、连贯、完整的最终答案。 +{question_context} +**各个专业 Agent 的回答**： +{responses_text} + +**整合要求**： +{strategy_instruction} + +请注意： +1. 结合原始问题和各个 Agent 的专业回答 +2. 去除重复内容，保留所有有价值的信息 +3. 确保答案逻辑清晰、表达流畅 +4. 如果不同 Agent 的观点有冲突，请合理说明 +5. 直接给出整合后的答案，不要添加"根据以上回答"等元信息 + +请生成最终的整合答案：""" + + try: + from app.core.models import RedBearLLM + from app.core.models.base import RedBearModelConfig + from app.models import ModelApiKey, ModelType + + # 获取 Master Agent 的模型配置 + master_agent_release = self.config.master_agent_release + if not master_agent_release: + logger.warning("没有配置 Master Agent，使用简单整合") + final_response = self._smart_merge_results(results, strategy) + yield self._format_sse_event("message", {"content": final_response}) + return + + # 获取 API Key 配置 + api_key_config = self.db.query(ModelApiKey).filter( + ModelApiKey.model_config_id == master_agent_release.default_model_config_id, + ModelApiKey.is_active == True + ).first() + + if not api_key_config: + logger.warning("Master Agent 没有可用的 API Key，使用简单整合") + final_response = self._smart_merge_results(results, strategy) + yield self._format_sse_event("message", {"content": final_response}) + return + + logger.info( + "开始 Master Agent 流式整合", + extra={ + "agent_count": len(agent_responses), + "strategy": strategy + } + ) + + # 创建 RedBearModelConfig（启用流式） + model_config = RedBearModelConfig( + model_name=api_key_config.model_name, + provider=api_key_config.provider, + api_key=api_key_config.api_key, + base_url=api_key_config.api_base, + temperature=0.7, + max_tokens=2000, + extra_params={"streaming": True} # 启用流式输出 + ) + + # 创建 LLM 实例 + llm = RedBearLLM(model_config, type=ModelType.CHAT) + + logger.info("开始流式调用 Master Agent LLM") + + # 流式调用模型进行整合 + try: + chunk_count = 0 + logger.debug(f"开始流式调用，provider={api_key_config.provider}") + + # 获取底层模型 + underlying_model = llm._model if hasattr(llm, '_model') else llm + logger.debug(f"底层模型类型: {type(underlying_model).__name__}") + + # 使用底层模型的 astream 方法直接流式输出 + # 这样可以绕过可能的包装器累积问题 + async for chunk in underlying_model.astream(merge_prompt): + chunk_count += 1 + + # 提取内容 + if hasattr(chunk, 'content'): + content = chunk.content + elif isinstance(chunk, str): + content = chunk + else: + content = str(chunk) + + if content: + if chunk_count <= 5: + logger.debug(f"收到流式 chunk #{chunk_count}: {content[:30]}...") + yield self._format_sse_event("message", {"content": content}) + + logger.info(f"Master Agent 流式整合完成，共 {chunk_count} 个 chunks") + + except AttributeError as e: + # 如果底层模型不支持流式，降级到非流式 + logger.warning(f"底层模型不支持流式，降级到非流式: {str(e)}") + response = await llm.ainvoke(merge_prompt) + if hasattr(response, 'content'): + content = response.content + else: + content = str(response) + yield self._format_sse_event("message", {"content": content}) + + except Exception as e: + logger.error(f"Master Agent 流式整合失败: {str(e)}") + # 降级到智能整合 + final_response = self._smart_merge_results(results, strategy) + yield self._format_sse_event("message", {"content": final_response}) + + def _should_merge_results( + self, + results: List[Dict[str, Any]], + strategy: str + ) -> bool: + """判断是否需要整合结果 + + Args: + results: Agent 执行结果 + strategy: 协作策略 + + Returns: + True 如果需要整合，False 如果不需要 + """ + if not results or len(results) == 1: + # 没有结果或只有一个结果，不需要整合 + return False + + if strategy == "decomposition": + # 问题拆分：每个子问题独立，用户已经看到所有答案 + # 通常不需要整合（除非配置要求） + return self.config.execution_config.get("force_merge_decomposition", False) + + if strategy == "hierarchical": + # 层级协作：主 Agent 已经整合了，不需要再整合 + return False + + # sequential 和 parallel 模式：可能需要整合去重 + return True + + async def _parallel_stream_agents( + self, + agent_tasks: List[Tuple[str, str, Any, str, Dict[str, Any]]], + conversation_id: Optional[uuid.UUID], + user_id: Optional[str] + ) -> AsyncIterator[Tuple[str, str, str, str]]: + """并行流式执行多个 Agent，实时返回结果 + + Args: + agent_tasks: [(agent_id, agent_name, agent_config, message, context), ...] + conversation_id: 会话 ID + user_id: 用户 ID + + Yields: + (agent_id, agent_name, event_type, content) 元组 + """ + # 为每个 Agent 创建异步生成器 + async def stream_single_agent(agent_id, agent_name, agent_config, message, context): + """单个 Agent 的流式执行包装器""" + try: + async for event in self._execute_sub_agent_stream( + agent_config, + message, + context, + conversation_id, + user_id + ): + # 解析事件 + if "data:" in event: + try: + import json + data_line = event.split("data: ", 1)[1].strip() + data = json.loads(data_line) + + if "content" in data: + yield (agent_id, agent_name, "content", data["content"]) + except: + pass + + # 发送完成信号 + yield (agent_id, agent_name, "done", "") + + except Exception as e: + logger.error(f"Agent {agent_name} 流式执行失败: {str(e)}") + yield (agent_id, agent_name, "error", str(e)) + + # 创建所有 Agent 的流式任务 + streams = [] + for agent_id, agent_name, agent_config, message, context in agent_tasks: + stream = stream_single_agent(agent_id, agent_name, agent_config, message, context) + streams.append(stream) + + # 使用队列来合并多个异步流 + queue = asyncio.Queue() + active_streams = len(streams) + + async def consume_stream(stream, stream_id): + """消费单个流并放入队列""" + nonlocal active_streams + try: + async for item in stream: + await queue.put(item) + finally: + active_streams -= 1 + if active_streams == 0: + await queue.put(None) # 所有流都完成了 + + # 启动所有流的消费任务 + tasks = [ + asyncio.create_task(consume_stream(stream, i)) + for i, stream in enumerate(streams) + ] + + # 从队列中读取并 yield + while True: + item = await queue.get() + if item is None: # 所有流都完成 + break + yield item + + # 等待所有任务完成 + await asyncio.gather(*tasks, return_exceptions=True) + + def _calculate_similarity(self, messages: List[str]) -> float: + """计算消息相似度（简化版） + + Args: + messages: 消息列表 + + Returns: + 相似度 (0-1) + """ + if len(messages) < 2: + return 0.0 + + # 简化版：比较长度和关键词 + # 实际应用中可以使用更复杂的算法（如编辑距离、余弦相似度等） + + # 计算平均长度 + avg_length = sum(len(m) for m in messages) / len(messages) + + # 如果长度差异很大，认为不相似 + length_variance = sum(abs(len(m) - avg_length) for m in messages) / len(messages) + if length_variance > avg_length * 0.5: + return 0.3 + + # 提取关键词（简化：取前50个字符） + keywords = [m[:50] for m in messages] + + # 计算重复度 + unique_keywords = len(set(keywords)) + total_keywords = len(keywords) + + similarity = 1.0 - (unique_keywords / total_keywords) + + return similarity diff --git a/api/app/services/multi_agent_service.py b/api/app/services/multi_agent_service.py index f6374dc5..fd4bbea2 100644 --- a/api/app/services/multi_agent_service.py +++ b/api/app/services/multi_agent_service.py @@ -116,7 +116,7 @@ class MultiAgentService: self.db.refresh(config) logger.info( - f"创建多 Agent 配置成功", + "创建多 Agent 配置成功", extra={ "config_id": str(config.id), "app_id": str(app_id), @@ -320,7 +320,7 @@ class MultiAgentService: self.db.refresh(config) logger.info( - f"创建多 Agent 配置成功", + "创建多 Agent 配置成功", extra={ "config_id": str(config.id), "app_id": str(app_id), @@ -363,12 +363,12 @@ class MultiAgentService: # if data.routing_rules is not None: # config.routing_rules = [convert_uuids_to_str(rule.model_dump()) for rule in data.routing_rules] if data.routing_rules else None - if data.execution_config is None: - execution_config_data = {} - elif isinstance(data.execution_config, dict): - execution_config_data = convert_uuids_to_str(data.execution_config) - else: - execution_config_data = convert_uuids_to_str(data.execution_config.model_dump()) + if data.execution_config is not None: + if isinstance(data.execution_config, dict): + execution_config_data = convert_uuids_to_str(data.execution_config) + else: + execution_config_data = convert_uuids_to_str(data.execution_config.model_dump()) + config.execution_config = execution_config_data if data.aggregation_strategy is not None: config.aggregation_strategy = data.aggregation_strategy @@ -380,7 +380,7 @@ class MultiAgentService: self.db.refresh(config) logger.info( - f"更新多 Agent 配置成功", + "更新多 Agent 配置成功", extra={ "config_id": str(config.id), "app_id": str(app_id) @@ -399,11 +399,12 @@ class MultiAgentService: if not config: raise ResourceNotFoundException("多 Agent 配置", str(app_id)) - self.db.delete(config) + # 逻辑删除多 Agent 配置 + config.is_active = False self.db.commit() logger.info( - f"删除多 Agent 配置成功", + "删除多 Agent 配置成功", extra={ "config_id": str(config.id), "app_id": str(app_id) @@ -542,7 +543,7 @@ class MultiAgentService: self.db.refresh(config) logger.info( - f"添加子 Agent 成功", + "添加子 Agent 成功", extra={ "config_id": str(config.id), "agent_id": str(agent_id), @@ -586,7 +587,7 @@ class MultiAgentService: self.db.refresh(config) logger.info( - f"移除子 Agent 成功", + "移除子 Agent 成功", extra={ "config_id": str(config.id), "agent_id": str(agent_id) diff --git a/api/app/services/release_share_service.py b/api/app/services/release_share_service.py index 7278aea0..eee12159 100644 --- a/api/app/services/release_share_service.py +++ b/api/app/services/release_share_service.py @@ -92,7 +92,7 @@ class ReleaseShareService: share = self.repo.create(share) logger.info( - f"创建分享配置", + "创建分享配置", extra={ "share_id": str(share.id), "release_id": str(release.id), @@ -130,7 +130,7 @@ class ReleaseShareService: share = self.repo.update(share) logger.info( - f"更新分享配置", + "更新分享配置", extra={ "share_id": str(share.id), "release_id": str(share.release_id) @@ -214,7 +214,7 @@ class ReleaseShareService: self.repo.delete(share) logger.info( - f"删除分享配置", + "删除分享配置", extra={ "share_id": str(share.id), "release_id": str(release_id) @@ -249,7 +249,7 @@ class ReleaseShareService: share = self.repo.update(share) logger.info( - f"重新生成分享 token", + "重新生成分享 token", extra={ "share_id": str(share.id), "old_token": old_token, diff --git a/api/app/services/shared_chat_service.py b/api/app/services/shared_chat_service.py index fb32b648..6bf96eb5 100644 --- a/api/app/services/shared_chat_service.py +++ b/api/app/services/shared_chat_service.py @@ -4,7 +4,7 @@ import time import asyncio from typing import Optional, Dict, Any, AsyncGenerator from sqlalchemy.orm import Session - +from app.services.memory_konwledges_server import write_rag from app.models import ReleaseShare, AppRelease, Conversation from app.services.conversation_service import ConversationService from app.services.draft_run_service import create_web_search_tool @@ -16,6 +16,8 @@ from app.services.multi_agent_service import MultiAgentService from app.models import MultiAgentConfig from app.repositories import knowledge_repository import json +from app.services.task_service import get_task_memory_write_result +from app.tasks import write_message_task logger = get_business_logger() @@ -88,7 +90,7 @@ class SharedChatService: return conversation except ResourceNotFoundException: logger.warning( - f"会话不存在，将创建新会话", + "会话不存在，将创建新会话", extra={"conversation_id": str(conversation_id)} ) @@ -102,7 +104,7 @@ class SharedChatService: ) logger.info( - f"为分享链接创建新会话", + "为分享链接创建新会话", extra={ "conversation_id": str(conversation.id), "share_token": share_token, @@ -121,17 +123,24 @@ class SharedChatService: variables: Optional[Dict[str, Any]] = None, password: Optional[str] = None, web_search: bool = False, - memory: bool = True + memory: bool = True, + storage_type: Optional[str] = None, + user_rag_memory_id: Optional[str] = None, ) -> Dict[str, Any]: """聊天（非流式）""" + actual_config_id = None + config_id=actual_config_id from app.core.agent.langchain_agent import LangChainAgent from app.services.draft_run_service import create_knowledge_retrieval_tool, create_long_term_memory_tool from app.services.model_parameter_merger import ModelParameterMerger from app.schemas.prompt_schema import render_prompt_message, PromptMessageRole from sqlalchemy import select from app.models import ModelApiKey + start_time = time.time() + actual_config_id=None + config_id=actual_config_id if variables is None: variables = {} @@ -199,10 +208,11 @@ class SharedChatService: tools.append(kb_tool) # 添加长期记忆工具 - + memory_flag=False if memory==True: memory_config = config.get("memory", {}) if memory_config.get("enabled") and user_id: + memory_flag=True memory_tool = create_long_term_memory_tool(memory_config, user_id) tools.append(memory_tool) @@ -234,6 +244,7 @@ class SharedChatService: max_tokens=model_parameters.get("max_tokens", 2000), system_prompt=system_prompt, tools=tools, + ) # 加载历史消息 @@ -254,7 +265,11 @@ class SharedChatService: message=message, history=history, context=None, - end_user_id=user_id + end_user_id=user_id, + storage_type=storage_type, + user_rag_memory_id=user_rag_memory_id, + config_id=config_id, + memory_flag=memory_flag ) # 保存消息 @@ -280,6 +295,7 @@ class SharedChatService: # ) elapsed_time = time.time() - start_time + return { "conversation_id": conversation.id, @@ -301,7 +317,9 @@ class SharedChatService: variables: Optional[Dict[str, Any]] = None, password: Optional[str] = None, web_search: bool = False, - memory: bool = True + memory: bool = True, + storage_type:Optional[str] = None, + user_rag_memory_id: Optional[str] = None, ) -> AsyncGenerator[str, None]: """聊天（流式）""" from app.core.agent.langchain_agent import LangChainAgent @@ -312,6 +330,9 @@ class SharedChatService: import json start_time = time.time() + actual_config_id=None + config_id=actual_config_id + if variables is None: variables = {} @@ -381,9 +402,11 @@ class SharedChatService: tools.append(kb_tool) # 添加长期记忆工具 + memory_flag=False if memory: memory_config = config.get("memory", {}) if memory_config.get("enabled") and user_id: + memory_flag = True memory_tool = create_long_term_memory_tool(memory_config, user_id) tools.append(memory_tool) @@ -440,7 +463,11 @@ class SharedChatService: message=message, history=history, context=None, - end_user_id=user_id + end_user_id=user_id, + storage_type=storage_type, + user_rag_memory_id=user_rag_memory_id, + config_id=config_id, + memory_flag=memory_flag ): full_content += chunk # 发送消息块事件 @@ -464,13 +491,14 @@ class SharedChatService: "usage": {} } ) + # 发送结束事件 end_data = {"elapsed_time": elapsed_time, "message_length": len(full_content)} yield f"event: end\ndata: {json.dumps(end_data, ensure_ascii=False)}\n\n" logger.info( - f"流式聊天完成", + "流式聊天完成", extra={ "conversation_id": str(conversation.id), "elapsed_time": elapsed_time, @@ -539,13 +567,19 @@ class SharedChatService: variables: Optional[Dict[str, Any]] = None, password: Optional[str] = None, web_search: bool = False, - memory: bool = True + memory: bool = True, + storage_type: Optional[str] = None, + user_rag_memory_id: Optional[str] = None ) -> Dict[str, Any]: """多 Agent 聊天（非流式）""" from app.services.multi_agent_service import MultiAgentService from app.models import MultiAgentConfig + + start_time = time.time() + actual_config_id=None + config_id=actual_config_id if variables is None: variables = {} @@ -609,6 +643,8 @@ class SharedChatService: "sub_results": result.get("sub_results") } ) + + return { "conversation_id": conversation.id, @@ -630,11 +666,16 @@ class SharedChatService: variables: Optional[Dict[str, Any]] = None, password: Optional[str] = None, web_search: bool = False, - memory: bool = True + memory: bool = True, + storage_type: Optional[str] = None, + user_rag_memory_id:Optional[str] = None ) -> AsyncGenerator[str, None]: """多 Agent 聊天（流式）""" + start_time = time.time() + actual_config_id=None + config_id=actual_config_id if variables is None: variables = {} @@ -741,13 +782,14 @@ class SharedChatService: ) logger.info( - f"多 Agent 流式聊天完成", + "多 Agent 流式聊天完成", extra={ "conversation_id": str(conversation.id), "elapsed_time": elapsed_time, "message_length": len(full_content) } ) + except (GeneratorExit, asyncio.CancelledError): # 生成器被关闭或任务被取消，正常退出 diff --git a/api/app/services/smart_router.py b/api/app/services/smart_router.py index 5889440b..063f0468 100644 --- a/api/app/services/smart_router.py +++ b/api/app/services/smart_router.py @@ -75,7 +75,7 @@ class SmartRouter: } """ logger.info( - f"开始智能路由", + "开始智能路由", extra={ "message_length": len(message), "conversation_id": conversation_id, @@ -170,7 +170,7 @@ class SmartRouter: } logger.info( - f"路由完成", + "路由完成", extra={ "agent_id": agent_id, "strategy": strategy, @@ -421,6 +421,6 @@ class SmartRouter: # 否则使用第一个子 Agent if self.sub_agents: - return list(self.sub_agents.keys())[0] + return next(iter(self.sub_agents.keys())) return "default-agent" diff --git a/api/app/services/user_service.py b/api/app/services/user_service.py index d9b6ea9d..d97e2fb2 100644 --- a/api/app/services/user_service.py +++ b/api/app/services/user_service.py @@ -64,7 +64,7 @@ def create_initial_superuser(db: Session): raise BusinessException( f"初始超级用户创建失败: {str(e)}", code=BizCode.DB_ERROR, - context={"username": username, "email": email}, + context={"username": user_in.username, "email": user_in.email}, cause=e ) @@ -423,7 +423,7 @@ def update_last_login_time(db: Session, user_id: uuid.UUID) -> User: business_logger.info(f"用户最后登录时间更新成功: {db_user.username} (ID: {user_id})") return db_user - except HTTPException: + except (BusinessException, PermissionDeniedException): raise except Exception as e: business_logger.error(f"更新用户最后登录时间失败: user_id={user_id} - {str(e)}") @@ -438,19 +438,14 @@ async def change_password(db: Session, user_id: uuid.UUID, old_password: str, ne # 检查权限：只能修改自己的密码 if current_user.id != user_id: business_logger.warning(f"用户尝试修改他人密码: current_user={current_user.id}, target_user={user_id}") - raise HTTPException( - status_code=status.HTTP_403_FORBIDDEN, - detail="You can only change your own password" - ) + raise PermissionDeniedException("You can only change your own password") try: # 获取用户 db_user = user_repository.get_user_by_id(db=db, user_id=user_id) if not db_user: business_logger.warning(f"用户不存在: {user_id}") - raise HTTPException( - status_code=status.HTTP_404_NOT_FOUND, detail="User not found" - ) + raise BusinessException("User not found", code=BizCode.USER_NOT_FOUND) # 验证旧密码 if not verify_password(old_password, db_user.hashed_password): diff --git a/api/app/services/workspace_service.py b/api/app/services/workspace_service.py index dfe18435..04ee647c 100644 --- a/api/app/services/workspace_service.py +++ b/api/app/services/workspace_service.py @@ -148,7 +148,7 @@ def create_workspace( description=f"工作空间 {workspace.name} 的默认知识库", avatar='', type=KnowledgeType.General, - permission_id=PermissionType.Private, + permission_id=PermissionType.Memory, embedding_id=uuid.UUID(getenv('KB_embedding_id')) if None else embedding, reranker_id=uuid.UUID(getenv('KB_reranker_id')) if None else rerank, llm_id=uuid.UUID(getenv('KB_llm_id')) if None else llm, @@ -459,7 +459,7 @@ def get_workspace_invites( def validate_invite_token(db: Session, token: str) -> InviteValidateResponse: """验证邀请令牌""" - business_logger.info(f"验证邀请令牌") + business_logger.info("验证邀请令牌") # 生成令牌哈希 token_hash = hashlib.sha256(token.encode()).hexdigest() @@ -469,7 +469,7 @@ def validate_invite_token(db: Session, token: str) -> InviteValidateResponse: invite = invite_repo.get_invite_by_token_hash(token_hash) if not invite: - business_logger.warning(f"邀请令牌无效") + business_logger.warning("邀请令牌无效") raise BusinessException("邀请令牌无效", BizCode.WORKSPACE_INVITE_NOT_FOUND) # 检查邀请状态和过期时间 @@ -511,7 +511,7 @@ def accept_workspace_invite( invite = invite_repo.get_invite_by_token_hash(token_hash) if not invite: - business_logger.warning(f"邀请令牌无效") + business_logger.warning("邀请令牌无效") raise BusinessException("邀请令牌无效", BizCode.WORKSPACE_INVITE_NOT_FOUND) # 检查邀请状态 @@ -522,7 +522,7 @@ def accept_workspace_invite( # 检查过期时间 now = datetime.datetime.now() if invite.expires_at < now: - business_logger.warning(f"邀请已过期") + business_logger.warning("邀请已过期") # 标记为过期 invite_repo.update_invite_status(invite.id, InviteStatus.expired) raise BusinessException("邀请已过期", BizCode.WORKSPACE_INVITE_EXPIRED) @@ -547,7 +547,7 @@ def accept_workspace_invite( ) if existing_member: - business_logger.info(f"用户已是工作空间成员，更新邀请状态") + business_logger.info("用户已是工作空间成员，更新邀请状态") invite_repo.update_invite_status( invite.id, InviteStatus.accepted, @@ -739,6 +739,34 @@ def get_workspace_storage_type( return workspace.storage_type +def get_workspace_storage_type_without_auth( + db: Session, + workspace_id: uuid.UUID, +) -> Optional[str]: + """获取工作空间的存储类型（无需权限验证，用于公开分享等场景） + + Args: + db: 数据库会话 + workspace_id: 工作空间ID + + Returns: + storage_type: 存储类型字符串，如果未设置则返回 None + """ + business_logger.info(f"获取工作空间 {workspace_id} 的存储类型（无权限验证）") + + # 查询工作空间 + workspace = workspace_repository.get_workspace_by_id(db=db, workspace_id=workspace_id) + if not workspace: + business_logger.error(f"工作空间不存在: workspace_id={workspace_id}") + raise BusinessException( + code=BizCode.WORKSPACE_NOT_FOUND, + message="工作空间不存在" + ) + + business_logger.info(f"成功获取工作空间 {workspace_id} 的存储类型: {workspace.storage_type}") + return workspace.storage_type + + def get_workspace_models_configs( db: Session, workspace_id: uuid.UUID, diff --git a/api/app/tasks.py b/api/app/tasks.py index 42642726..2d461cd3 100644 --- a/api/app/tasks.py +++ b/api/app/tasks.py @@ -13,10 +13,13 @@ from app.db import get_db from app.models.document_model import Document from app.models.knowledge_model import Knowledge from app.core.rag.llm.cv_model import QWenCV +from app.core.rag.llm.chat_model import Base from app.core.rag.vdb.elasticsearch.elasticsearch_vector import ElasticSearchVectorFactory from app.core.rag.models.chunk import DocumentChunk from app.services.memory_agent_service import MemoryAgentService from app.core.config import settings +from app.core.rag.graphrag.utils import get_llm_cache, set_llm_cache +from app.core.rag.prompts.generator import question_proposal # Import a unified Celery instance from app.celery_app import celery_app @@ -66,7 +69,12 @@ def parse_document(file_path: str, document_id: uuid.UUID): def progress_callback(prog=None, msg=None): nonlocal progress_msg # Declare the use of an external progress_msg variable progress_msg += f"{datetime.now().strftime('%H:%M:%S')} parse progress: {prog} msg: {msg}.\n" - # Prepare to configure vision_model information + # Prepare to configure chat_mdl、vision_model information + chat_model = Base( + key=db_knowledge.llm.api_keys[0].api_key, + model_name=db_knowledge.llm.api_keys[0].model_name, + base_url=db_knowledge.llm.api_keys[0].api_base + ) vision_model = QWenCV( key=db_knowledge.image2text.api_keys[0].api_key, model_name=db_knowledge.image2text.api_keys[0].model_name, @@ -116,7 +124,15 @@ def parse_document(file_path: str, document_id: uuid.UUID): "sort_id": global_idx, "status": 1, } - chunks.append(DocumentChunk(page_content=item["content_with_weight"], metadata=metadata)) + if db_document.parser_config.get("auto_questions", 0): + topn = db_document.parser_config["auto_questions"] + cached = get_llm_cache(chat_model.model_name, item["content_with_weight"], "question", {"topn": topn}) + if not cached: + cached = question_proposal(chat_model, item["content_with_weight"], topn) + set_llm_cache(chat_model.model_name, item["content_with_weight"], cached, "question", {"topn": topn}) + chunks.append(DocumentChunk(page_content=f"question: {cached} answer: {item['content_with_weight']}", metadata=metadata)) + else: + chunks.append(DocumentChunk(page_content=item["content_with_weight"], metadata=metadata)) # Bulk segmented vector import vector_service.add_chunks(chunks)